neighbour management More...

#include "platform.h"
#include "gnunet_ats_service.h"
#include "gnunet-service-transport_ats.h"
#include "gnunet-service-transport_neighbours.h"
#include "gnunet-service-transport_manipulation.h"
#include "gnunet-service-transport_plugins.h"
#include "gnunet-service-transport_validation.h"
#include "gnunet-service-transport.h"
#include "gnunet_peerinfo_service.h"
#include "gnunet_constants.h"
#include "transport.h"

Include dependency graph for gnunet-service-transport_neighbours.c:

Data Structures
struct	TransportSynMessage
	Message a peer sends to another to indicate that it intends to setup a connection/session for data exchange. More...

struct	GNUNET_ATS_SessionKeepAliveMessage
	Message a peer sends to another when connected to indicate that a session is in use and the peer is still alive or to respond to a keep alive. More...

struct	GNUNET_ATS_SessionQuotaMessage
	Message a peer sends to another when connected to indicate that the other peer should limit transmissions to the indicated quota. More...

struct	GNUNET_ATS_SessionDisconnectMessage
	Message we send to the other peer to notify it that we intentionally are disconnecting (to reduce timeouts). More...

struct	MessageQueue
	For each neighbour we keep a list of messages that we still want to transmit to the neighbour. More...

struct	NeighbourAddress
	A possible address we could use to communicate with a neighbour. More...

struct	NeighbourMapEntry
	Entry in neighbours. More...

struct	BlacklistCheckSwitchContext
	Entry in a DLL we use to keep track of pending blacklist checks. More...

struct	IteratorContext
	Closure for the neighbours_iterate() function. More...

Macros
#define	IGNORE_INBOUND_QUOTA GNUNET_YES
	Experimental option to ignore SessionQuotaMessages from the other peer. More...

#define	NEIGHBOUR_TABLE_SIZE 256
	Size of the neighbour hash map. More...

#define	DISCONNECT_SENT_TIMEOUT
	Time we give plugin to transmit DISCONNECT message before the neighbour entry self-destructs. More...

#define	QUOTA_VIOLATION_DROP_THRESHOLD 10
	How often must a peer violate bandwidth quotas before we start to simply drop its messages? More...

#define	ATS_RESPONSE_TIMEOUT
	How long are we willing to wait for a response from ATS before timing out? More...

#define	SETUP_CONNECTION_TIMEOUT
	How long are we willing to wait for an ACK from the other peer before giving up on our connect operation? More...

#define	FAST_RECONNECT_TIMEOUT GNUNET_TIME_UNIT_SECONDS
	How long are we willing to wait for a successful reconnect if an existing connection went down? Much shorter than the usual SETUP_CONNECTION_TIMEOUT as we do not inform the higher layers about the disconnect during this period. More...

#define	UTIL_TRANSMISSION_INTERVAL GNUNET_TIME_UNIT_SECONDS
	Interval to send utilization data. More...

Enumerations
enum	GST_ACK_State { ACK_UNDEFINED = 0 , ACK_SEND_SYN_ACK = 1 , ACK_SEND_ACK = 2 }
	State describing which kind a reply this neighbour should send. More...

Functions
static char *	print_ack_state (enum GST_ACK_State s)
	Convert the given ACK state to a string. More...

static void	send_outbound_quota_to_clients (struct NeighbourMapEntry *n)
	Send information about a new outbound quota to our clients. More...

static void	neighbours_connect_notification (struct NeighbourMapEntry *n)
	Notify our clients that another peer connected to us. More...

static void	neighbours_disconnect_notification (struct NeighbourMapEntry *n)
	Notify our clients (and manipulation) that a peer disconnected from us. More...

static void	neighbours_changed_notification (const struct GNUNET_PeerIdentity peer, const struct GNUNET_HELLO_Address address, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
	Notify transport clients that a neighbour peer changed its active address. More...

static struct NeighbourMapEntry *	lookup_neighbour (const struct GNUNET_PeerIdentity *pid)
	Lookup a neighbour entry in the neighbours hash map. More...

static int	test_connected (struct NeighbourMapEntry *n)
	Test if we're connected to the given peer. More...

static void	free_address (struct NeighbourAddress *na)
	We don't need a given neighbour address any more. More...

static void	master_task (void *cls)
	Master task run for every neighbour. More...

static void	set_state_and_timeout (struct NeighbourMapEntry *n, enum GNUNET_TRANSPORT_PeerState s, struct GNUNET_TIME_Absolute timeout)
	Set net state and state timeout for this neighbour and notify monitoring. More...

static void	set_alternative_address (struct NeighbourMapEntry n, const struct GNUNET_HELLO_Address address, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
	Initialize the alternative address of a neighbour. More...

static struct GNUNET_TIME_Relative	send_with_session (struct NeighbourMapEntry n, const void msgbuf, size_t msgbuf_size, uint32_t priority, struct GNUNET_TIME_Relative timeout, unsigned int use_keepalive_timeout, GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
	Transmit a message using the current session of the given neighbour. More...

static void	unset_primary_address (struct NeighbourMapEntry *n)
	Clear the primary address of a neighbour since this address is not valid anymore and notify monitoring about it. More...

static void	free_neighbour (struct NeighbourMapEntry *n)
	Free a neighbour map entry. More...

static void	send_disconnect_cont (void cls, const struct GNUNET_PeerIdentity target, int result, size_t payload, size_t physical)
	Function called when the 'DISCONNECT' message has been sent by the plugin. More...

static void	send_disconnect (struct NeighbourMapEntry *n)
	Transmit a DISCONNECT message to the other peer. More...

static void	disconnect_neighbour (struct NeighbourMapEntry *n)
	Disconnect from the given neighbour, clean up the record. More...

static int	set_incoming_quota (struct NeighbourMapEntry *n, struct GNUNET_BANDWIDTH_Value32NBO quota)
	Change the incoming quota for the given peer. More...

static void	set_primary_address (struct NeighbourMapEntry n, const struct GNUNET_HELLO_Address address, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
	Initialize the primary address of a neighbour. More...

static void	transmit_send_continuation (void cls, const struct GNUNET_PeerIdentity receiver, int success, size_t size_payload, size_t physical)
	We're done with our transmission attempt, continue processing. More...

static void	try_transmission_to_peer (struct NeighbourMapEntry *n)
	Check the message list for the given neighbour and if we can send a message, do so. More...

static void	send_keepalive (struct NeighbourMapEntry *n)
	Send keepalive message to the neighbour. More...

void	GST_neighbours_keepalive (const struct GNUNET_PeerIdentity neighbour, const struct GNUNET_MessageHeader m)
	Keep the connection to the given neighbour alive longer, we received a KEEPALIVE (or equivalent); send a response. More...

void	GST_neighbours_keepalive_response (const struct GNUNET_PeerIdentity neighbour, const struct GNUNET_MessageHeader m)
	We received a KEEP_ALIVE_RESPONSE message and use this to calculate latency to this peer. More...

struct GNUNET_TIME_Relative	GST_neighbours_calculate_receive_delay (const struct GNUNET_PeerIdentity sender, ssize_t size, int do_forward)
	We have received a message from the given sender. More...

void	GST_neighbours_send (const struct GNUNET_PeerIdentity target, const void msg, size_t msg_size, struct GNUNET_TIME_Relative timeout, GST_NeighbourSendContinuation cont, void *cont_cls)
	Transmit a message to the given target using the active connection. More...

static void	send_session_syn_cont (void cls, const struct GNUNET_PeerIdentity target, int result, size_t size_payload, size_t size_on_wire)
	Continuation called from our attempt to transmitted our GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN to the specified target. More...

static void	send_syn (struct NeighbourAddress *na)
	Send a SYN message via the given address. More...

static void	send_session_syn_ack_cont (void cls, const struct GNUNET_PeerIdentity target, int result, size_t size_payload, size_t size_on_wire)
	Continuation called from our attempt to transmitted our GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK to the specified target. More...

static void	send_syn_ack_message (struct NeighbourAddress *na, struct GNUNET_TIME_Absolute timestamp)
	Send a SYN_ACK message via the given address. More...

static void	inbound_bw_tracker_update (void *cls)
	Function called by the bandwidth tracker for a peer whenever the tracker's state changed such that we need to recalculate the delay for flow control. More...

static struct NeighbourMapEntry *	setup_neighbour (const struct GNUNET_PeerIdentity *peer)
	Create a fresh entry in the neighbour map for the given peer. More...

int	GST_neighbours_handle_session_syn (const struct GNUNET_MessageHeader message, const struct GNUNET_PeerIdentity peer)
	We received a 'SYN' message from the other peer. More...

static int	try_run_fast_ats_update (const struct GNUNET_HELLO_Address address, struct GNUNET_ATS_Session session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
	Check if the given address is the same that we are already using for the respective neighbour. More...

static void	switch_address_bl_check_cont (void cls, const struct GNUNET_PeerIdentity peer, const struct GNUNET_HELLO_Address address, struct GNUNET_ATS_Session session, int result)
	We've been asked to switch addresses, and just now got the result from the blacklist check to see if this is allowed. More...

void	GST_neighbours_switch_to_address (const struct GNUNET_HELLO_Address address, struct GNUNET_ATS_Session session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
	For the given peer, switch to this address. More...

static int	send_utilization_data (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Function called to send network utilization data to ATS for each active connection. More...

static void	utilization_transmission (void *cls)
	Task transmitting utilization in a regular interval. More...

void	GST_neighbours_notify_data_recv (const struct GNUNET_HELLO_Address address, const struct GNUNET_MessageHeader message)
	Track information about data we received from the given address (used to notify ATS about our utilization of allocated resources). More...

void	GST_neighbours_notify_data_sent (const struct GNUNET_HELLO_Address address, struct GNUNET_ATS_Session session, size_t size)
	Track information about data we transmitted using the given address and session (used to notify ATS about our utilization of allocated resources). More...

static void	send_session_ack_message (struct NeighbourMapEntry *n)
	Send a ACK message to the neighbour to confirm that we got its SYN_ACK. More...

int	GST_neighbours_handle_session_syn_ack (const struct GNUNET_MessageHeader message, const struct GNUNET_HELLO_Address address, struct GNUNET_ATS_Session *session)
	We received a 'SESSION_SYN_ACK' message from the other peer. More...

int	GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity peer, struct GNUNET_ATS_Session session)
	A session was terminated. More...

int	GST_neighbours_handle_session_ack (const struct GNUNET_MessageHeader message, const struct GNUNET_HELLO_Address address, struct GNUNET_ATS_Session *session)
	We received a 'ACK' message from the other peer. More...

int	GST_neighbours_test_connected (const struct GNUNET_PeerIdentity *target)
	Test if we're connected to the given peer. More...

static void	delayed_disconnect (void *cls)
	Task to asynchronously run free_neighbour(). More...

void	GST_neighbours_handle_quota_message (const struct GNUNET_PeerIdentity peer, const struct GNUNET_MessageHeader msg)
	We received a quota message from the given peer, validate and process. More...

void	GST_neighbours_handle_disconnect_message (const struct GNUNET_PeerIdentity peer, const struct GNUNET_MessageHeader msg)
	We received a disconnect message from the given peer, validate and process. More...

static int	neighbours_iterate (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Call the callback from the closure for each neighbour. More...

void	GST_neighbours_iterate (GST_NeighbourIterator cb, void *cb_cls)
	Iterate over all connected neighbours. More...

void	GST_neighbours_force_disconnect (const struct GNUNET_PeerIdentity *target)
	If we have an active connection to the given target, it must be shutdown. More...

const struct GNUNET_HELLO_Address *	GST_neighbour_get_current_address (const struct GNUNET_PeerIdentity *peer)
	Obtain current address information for the given neighbour. More...

void	GST_neighbours_start (unsigned int max_fds)
	Initialize the neighbours subsystem. More...

static int	disconnect_all_neighbours (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Disconnect from the given neighbour. More...

void	GST_neighbours_stop ()
	Cleanup the neighbours subsystem. More...

Variables
static struct GNUNET_CONTAINER_MultiPeerMap *	neighbours
	Hash map from peer identities to the respective `struct NeighbourMapEntry`. More...

static struct BlacklistCheckSwitchContext *	pending_bc_head
	List of pending blacklist checks: head. More...

static struct BlacklistCheckSwitchContext *	pending_bc_tail
	List of pending blacklist checks: tail. More...

static unsigned int	neighbours_connected
	counter for connected neighbours More...

static unsigned long long	bytes_in_send_queue
	Number of bytes we have currently queued for transmission. More...

static struct GNUNET_SCHEDULER_Task *	util_transmission_tk
	Task transmitting utilization data. More...

Detailed Description

neighbour management

Author: Christian Grothoff

Definition in file gnunet-service-transport_neighbours.c.

Macro Definition Documentation

◆ IGNORE_INBOUND_QUOTA

#define IGNORE_INBOUND_QUOTA GNUNET_YES

Experimental option to ignore SessionQuotaMessages from the other peer.

Definition at line 42 of file gnunet-service-transport_neighbours.c.

◆ NEIGHBOUR_TABLE_SIZE

#define NEIGHBOUR_TABLE_SIZE 256

Size of the neighbour hash map.

Definition at line 47 of file gnunet-service-transport_neighbours.c.

◆ DISCONNECT_SENT_TIMEOUT

#define DISCONNECT_SENT_TIMEOUT

Value:

GNUNET_TIME_relative_multiply ( \

GNUNET_TIME_UNIT_MILLISECONDS, 500)

GNUNET_TIME_UNIT_MILLISECONDS

#define GNUNET_TIME_UNIT_MILLISECONDS

One millisecond.

Definition: gnunet_time_lib.h:145

GNUNET_TIME_relative_multiply

struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)

Multiply relative time by a given factor.

Definition: time.c:484

Time we give plugin to transmit DISCONNECT message before the neighbour entry self-destructs.

Definition at line 53 of file gnunet-service-transport_neighbours.c.

◆ QUOTA_VIOLATION_DROP_THRESHOLD

#define QUOTA_VIOLATION_DROP_THRESHOLD 10

How often must a peer violate bandwidth quotas before we start to simply drop its messages?

Definition at line 60 of file gnunet-service-transport_neighbours.c.

◆ ATS_RESPONSE_TIMEOUT

#define ATS_RESPONSE_TIMEOUT

Value:

GNUNET_TIME_relative_multiply ( \

GNUNET_TIME_UNIT_SECONDS, 5)

GNUNET_TIME_UNIT_SECONDS

#define GNUNET_TIME_UNIT_SECONDS

One second.

Definition: gnunet_time_lib.h:150

How long are we willing to wait for a response from ATS before timing out?

Definition at line 65 of file gnunet-service-transport_neighbours.c.

◆ SETUP_CONNECTION_TIMEOUT

#define SETUP_CONNECTION_TIMEOUT

Value:

GNUNET_TIME_relative_multiply ( \

GNUNET_TIME_UNIT_SECONDS, 15)

How long are we willing to wait for an ACK from the other peer before giving up on our connect operation?

Definition at line 72 of file gnunet-service-transport_neighbours.c.

◆ FAST_RECONNECT_TIMEOUT

#define FAST_RECONNECT_TIMEOUT GNUNET_TIME_UNIT_SECONDS

How long are we willing to wait for a successful reconnect if an existing connection went down? Much shorter than the usual SETUP_CONNECTION_TIMEOUT as we do not inform the higher layers about the disconnect during this period.

Definition at line 81 of file gnunet-service-transport_neighbours.c.

◆ UTIL_TRANSMISSION_INTERVAL

#define UTIL_TRANSMISSION_INTERVAL GNUNET_TIME_UNIT_SECONDS

Interval to send utilization data.

Definition at line 86 of file gnunet-service-transport_neighbours.c.

Enumeration Type Documentation

◆ GST_ACK_State

enum GST_ACK_State

State describing which kind a reply this neighbour should send.

Enumerator
ACK_UNDEFINED	We did not receive a SYN message for this neighbour.
ACK_SEND_SYN_ACK	The neighbour received a SYN message and has to send a SYN_ACK as reply.
ACK_SEND_ACK	The neighbour sent a SYN_ACK message and has to send a ACK as reply.

Definition at line 91 of file gnunet-service-transport_neighbours.c.

 {
   ACK_UNDEFINED = 0,
  
   ACK_SEND_SYN_ACK = 1,
  
   ACK_SEND_ACK = 2
 };

Function Documentation

◆ print_ack_state()

static char* print_ack_state ( enum GST_ACK_State s )

static

Convert the given ACK state to a string.

Parameters

s state

Returns: corresponding human-readable string

Definition at line 497 of file gnunet-service-transport_neighbours.c.

 {
   switch (s)
   {
   case ACK_UNDEFINED:
     return "UNDEFINED";
  
   case ACK_SEND_SYN_ACK:
     return "SEND_SYN_ACK";
  
   case ACK_SEND_ACK:
     return "SEND_ACK";
  
   default:
     GNUNET_break (0);
     return "N/A";
   }
 }

References ACK_SEND_ACK, ACK_SEND_SYN_ACK, ACK_UNDEFINED, and GNUNET_break.

Referenced by GST_neighbours_handle_session_ack(), GST_neighbours_handle_session_syn(), and GST_neighbours_handle_session_syn_ack().

Here is the caller graph for this function:

◆ send_outbound_quota_to_clients()

static void send_outbound_quota_to_clients ( struct NeighbourMapEntry * n )

static

Send information about a new outbound quota to our clients.

Note that the outbound quota is enforced client-side (i.e. in libgnunettransport).

Parameters

n	affected peer

Definition at line 525 of file gnunet-service-transport_neighbours.c.

 {
   struct QuotaSetMessage q_msg;
   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_min;
  
   if (! GNUNET_TRANSPORT_is_connected (n->state))
     return;
 #if IGNORE_INBOUND_QUOTA
   bandwidth_min = n->primary_address.bandwidth_out;
 #else
   bandwidth_min = GNUNET_BANDWIDTH_value_min (n->primary_address.bandwidth_out,
                                               n->neighbour_receive_quota);
 #endif
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending outbound quota of %u Bps for peer `%s' to all clients\n",
               ntohl (bandwidth_min.value__),
               GNUNET_i2s (&n->id));
   q_msg.header.size = htons (sizeof(struct QuotaSetMessage));
   q_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA);
   q_msg.quota = bandwidth_min;
   q_msg.peer = n->id;
   GST_clients_broadcast (&q_msg.header,
                          GNUNET_NO);
 }

References NeighbourAddress::bandwidth_out, GNUNET_BANDWIDTH_value_min(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, GNUNET_NO, GNUNET_TRANSPORT_is_connected(), GST_clients_broadcast(), QuotaSetMessage::header, NeighbourMapEntry::id, NeighbourMapEntry::neighbour_receive_quota, QuotaSetMessage::peer, NeighbourMapEntry::primary_address, QuotaSetMessage::quota, GNUNET_MessageHeader::size, NeighbourMapEntry::state, GNUNET_MessageHeader::type, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by GST_neighbours_handle_quota_message(), set_primary_address(), and try_run_fast_ats_update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ neighbours_connect_notification()

static void neighbours_connect_notification ( struct NeighbourMapEntry * n )

static

Notify our clients that another peer connected to us.

Parameters

n	the peer that connected

Definition at line 558 of file gnunet-service-transport_neighbours.c.

 {
   size_t len = sizeof(struct ConnectInfoMessage);
   char buf[len] GNUNET_ALIGN;
   struct ConnectInfoMessage *connect_msg = (struct ConnectInfoMessage *) buf;
   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_min;
  
 #if IGNORE_INBOUND_QUOTA
   bandwidth_min = n->primary_address.bandwidth_out;
 #else
   bandwidth_min = GNUNET_BANDWIDTH_value_min (n->primary_address.bandwidth_out,
                                               n->neighbour_receive_quota);
 #endif
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "We are now connected to peer `%s'\n",
               GNUNET_i2s (&n->id));
   connect_msg->header.size = htons (sizeof(buf));
   connect_msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
   connect_msg->id = n->id;
   connect_msg->quota_out = bandwidth_min;
   GST_clients_broadcast (&connect_msg->header,
                          GNUNET_NO);
 }

References NeighbourAddress::bandwidth_out, buf, GNUNET_ALIGN, GNUNET_BANDWIDTH_value_min(), GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT, GNUNET_NO, GST_clients_broadcast(), ConnectInfoMessage::header, NeighbourMapEntry::id, ConnectInfoMessage::id, len, NeighbourMapEntry::neighbour_receive_quota, NeighbourMapEntry::primary_address, ConnectInfoMessage::quota_out, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by set_state_and_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ neighbours_disconnect_notification()

static void neighbours_disconnect_notification ( struct NeighbourMapEntry * n )

static

Notify our clients (and manipulation) that a peer disconnected from us.

Parameters

n	the peer that disconnected

Definition at line 590 of file gnunet-service-transport_neighbours.c.

 {
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Peer `%s' disconnected\n",
               GNUNET_i2s (&n->id));
   GST_manipulation_peer_disconnect (&n->id);
   GST_clients_broadcast_disconnect (&n->id);
 }

References GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GST_clients_broadcast_disconnect(), GST_manipulation_peer_disconnect(), and NeighbourMapEntry::id.

Referenced by set_state_and_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ neighbours_changed_notification()

static void neighbours_changed_notification	(	const struct GNUNET_PeerIdentity *	peer,
		const struct GNUNET_HELLO_Address *	address,
		enum GNUNET_TRANSPORT_PeerState	state,
		struct GNUNET_TIME_Absolute	state_timeout,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_in,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_out
	)

static

Notify transport clients that a neighbour peer changed its active address.

Parameters

peer	identity of the peer
address	address possibly NULL if peer is not connected
state	current state this peer is in
state_timeout	timeout for the current state of the peer
bandwidth_in	bandwidth assigned inbound, 0 on disconnect
bandwidth_out	bandwidth assigned outbound, 0 on disconnect

Definition at line 612 of file gnunet-service-transport_neighbours.c.

 {
   (void) bandwidth_in;
   (void) bandwidth_out;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Notifying about change for peer `%s' with address `%s' in state `%s' timing out at %s\n",
               GNUNET_i2s (peer),
               GST_plugins_a2s (address),
               GNUNET_TRANSPORT_ps2s (state),
               GNUNET_STRINGS_absolute_time_to_string (state_timeout));
   /* FIXME: include bandwidth in notification! */
   GST_clients_broadcast_peer_notification (peer,
                                            address,
                                            state,
                                            state_timeout);
 }

References address, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TRANSPORT_ps2s(), GST_clients_broadcast_peer_notification(), GST_plugins_a2s(), peer, and state.

Referenced by set_primary_address(), set_state_and_timeout(), and unset_primary_address().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookup_neighbour()

static struct NeighbourMapEntry* lookup_neighbour ( const struct GNUNET_PeerIdentity * pid )

static

Lookup a neighbour entry in the neighbours hash map.

Parameters

pid	identity of the peer to look up

Returns: the entry, NULL if there is no existing record

Definition at line 644 of file gnunet-service-transport_neighbours.c.

 {
   if (NULL == neighbours)
     return NULL;
   return GNUNET_CONTAINER_multipeermap_get (neighbours, pid);
 }

References GNUNET_CONTAINER_multipeermap_get(), neighbours, and pid.

Referenced by GST_neighbour_get_current_address(), GST_neighbours_calculate_receive_delay(), GST_neighbours_force_disconnect(), GST_neighbours_handle_disconnect_message(), GST_neighbours_handle_quota_message(), GST_neighbours_handle_session_ack(), GST_neighbours_handle_session_syn(), GST_neighbours_handle_session_syn_ack(), GST_neighbours_keepalive(), GST_neighbours_notify_data_recv(), GST_neighbours_notify_data_sent(), GST_neighbours_send(), GST_neighbours_session_terminated(), GST_neighbours_test_connected(), send_disconnect_cont(), send_session_syn_ack_cont(), send_session_syn_cont(), send_syn(), send_syn_ack_message(), switch_address_bl_check_cont(), transmit_send_continuation(), and try_run_fast_ats_update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ test_connected()

static int test_connected ( struct NeighbourMapEntry * n )

static

Test if we're connected to the given peer.

Parameters

n	neighbour entry of peer to test

Returns: GNUNET_YES if we are connected, GNUNET_NO if not

Definition at line 659 of file gnunet-service-transport_neighbours.c.

 {
   if (NULL == n)
     return GNUNET_NO;
   return GNUNET_TRANSPORT_is_connected (n->state);
 }

References GNUNET_NO, GNUNET_TRANSPORT_is_connected(), and NeighbourMapEntry::state.

Referenced by GST_neighbours_force_disconnect(), GST_neighbours_send(), GST_neighbours_test_connected(), send_utilization_data(), and set_incoming_quota().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_address()

static void free_address ( struct NeighbourAddress * na )

static

We don't need a given neighbour address any more.

Release its resources and give appropriate notifications to ATS and other subsystems.

Parameters

na	address we are done with; na itself must NOT be 'free'd, only the contents!

Definition at line 675 of file gnunet-service-transport_neighbours.c.

 {
   if (GNUNET_YES == na->ats_active)
     GST_validation_set_address_use (na->address,
                                     GNUNET_NO);
   if (NULL != na->address)
   {
     GST_ats_block_address (na->address,
                            na->session);
     GNUNET_HELLO_address_free (na->address);
     na->address = NULL;
   }
   na->bandwidth_in = GNUNET_BANDWIDTH_value_init (0);
   na->bandwidth_out = GNUNET_BANDWIDTH_value_init (0);
   na->ats_active = GNUNET_NO;
   na->keep_alive_nonce = 0;
   na->session = NULL;
 }

References NeighbourAddress::address, NeighbourAddress::ats_active, NeighbourAddress::bandwidth_in, NeighbourAddress::bandwidth_out, GNUNET_BANDWIDTH_value_init(), GNUNET_HELLO_address_free, GNUNET_NO, GNUNET_YES, GST_ats_block_address(), GST_validation_set_address_use(), NeighbourAddress::keep_alive_nonce, and NeighbourAddress::session.

Referenced by free_neighbour(), GST_neighbours_session_terminated(), master_task(), send_session_syn_cont(), send_syn(), send_with_session(), set_primary_address(), switch_address_bl_check_cont(), and unset_primary_address().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ master_task()

static void master_task ( void * cls )

static

Master task run for every neighbour.

Performs all of the time-related activities (keep alive, send next message, disconnect if idle, finish clean up after disconnect).

Parameters

cls	the `struct NeighbourMapEntry` for which we are running

Definition at line 3013 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n = cls;
   struct GNUNET_TIME_Relative delay;
  
   n->task = NULL;
   delay = GNUNET_TIME_absolute_get_remaining (n->timeout);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Master task runs for neighbour `%s' in state %s with timeout in %s\n",
               GNUNET_i2s (&n->id),
               GNUNET_TRANSPORT_ps2s (n->state),
               GNUNET_STRINGS_relative_time_to_string (delay,
                                                       GNUNET_YES));
   switch (n->state)
   {
   case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     /* invalid state for master task, clean up */
     GNUNET_break (0);
     free_neighbour (n);
     return;
  
   case GNUNET_TRANSPORT_PS_INIT_ATS:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Connection to `%s' timed out waiting for ATS to provide address\n",
                   GNUNET_i2s (&n->id));
       free_neighbour (n);
       return;
     }
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_SENT:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Connection to `%s' timed out waiting for other peer to send SYN_ACK\n",
                   GNUNET_i2s (&n->id));
       /* Remove address and request and additional one */
       unset_primary_address (n);
       set_state_and_timeout (n,
                              GNUNET_TRANSPORT_PS_INIT_ATS,
                              GNUNET_TIME_relative_to_absolute (
                                ATS_RESPONSE_TIMEOUT));
       return;
     }
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_RECV_ATS:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Connection to `%s' timed out waiting ATS to provide address to use for SYN_ACK\n",
                   GNUNET_i2s (&n->id));
       free_neighbour (n);
       return;
     }
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_RECV_ACK:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Connection to `%s' timed out waiting for other peer to send ACK\n",
                   GNUNET_i2s (&n->id));
       disconnect_neighbour (n);
       return;
     }
     break;
  
   case GNUNET_TRANSPORT_PS_CONNECTED:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Connection to `%s' timed out, missing KEEPALIVE_RESPONSEs\n",
                   GNUNET_i2s (&n->id));
       disconnect_neighbour (n);
       return;
     }
     try_transmission_to_peer (n);
     send_keepalive (n);
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Connection to `%s' timed out, waiting for ATS replacement address\n",
                   GNUNET_i2s (&n->id));
       disconnect_neighbour (n);
       return;
     }
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Connection to `%s' timed out, waiting for other peer to SYN_ACK replacement address\n",
                   GNUNET_i2s (&n->id));
       disconnect_neighbour (n);
       return;
     }
     break;
  
   case GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Switch failed, cleaning up alternative address\n");
       free_address (&n->alternative_address);
       set_state_and_timeout (n,
                              GNUNET_TRANSPORT_PS_CONNECTED,
                              GNUNET_TIME_relative_to_absolute (
                                SETUP_CONNECTION_TIMEOUT));
     }
     try_transmission_to_peer (n);
     send_keepalive (n);
     break;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT:
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "Cleaning up connection to `%s' after sending DISCONNECT\n",
                 GNUNET_i2s (&n->id));
     free_neighbour (n);
     return;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     /* how did we get here!? */
     GNUNET_assert (0);
     break;
  
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unhandled state `%s'\n",
                 GNUNET_TRANSPORT_ps2s (n->state));
     GNUNET_break (0);
     break;
   }
   delay = GNUNET_TIME_absolute_get_remaining (n->timeout);
   if ((GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT == n->state) ||
       (GNUNET_TRANSPORT_PS_CONNECTED == n->state))
   {
     /* if we are *now* in one of the two states, we're sending
        keep alive messages, so we need to consider the keepalive
        delay, not just the connection timeout */
     delay = GNUNET_TIME_relative_min (GNUNET_TIME_absolute_get_remaining (
                                         n->keep_alive_time),
                                       delay);
   }
   if (NULL == n->task)
     n->task = GNUNET_SCHEDULER_add_delayed (delay,
                                             &master_task,
                                             n);
 }

Referenced by disconnect_neighbour(), GST_neighbours_send(), GST_neighbours_session_terminated(), send_disconnect_cont(), set_state_and_timeout(), setup_neighbour(), and transmit_send_continuation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_state_and_timeout()

static void set_state_and_timeout	(	struct NeighbourMapEntry *	n,
		enum GNUNET_TRANSPORT_PeerState	s,
		struct GNUNET_TIME_Absolute	timeout
	)

static

Set net state and state timeout for this neighbour and notify monitoring.

Parameters

n	the respective neighbour
s	the new state
timeout	the new timeout

Definition at line 714 of file gnunet-service-transport_neighbours.c.

 {
   if (GNUNET_TRANSPORT_is_connected (s) &&
       (! GNUNET_TRANSPORT_is_connected (n->state)))
   {
     neighbours_connect_notification (n);
     GNUNET_STATISTICS_set (GST_stats,
                            gettext_noop ("# peers connected"),
                            ++neighbours_connected,
                            GNUNET_NO);
   }
   if ((! GNUNET_TRANSPORT_is_connected (s)) &&
       GNUNET_TRANSPORT_is_connected (n->state))
   {
     GNUNET_STATISTICS_set (GST_stats,
                            gettext_noop ("# peers connected"),
                            --neighbours_connected,
                            GNUNET_NO);
     neighbours_disconnect_notification (n);
   }
   n->state = s;
   if ((timeout.abs_value_us < n->timeout.abs_value_us) &&
       (NULL != n->task))
   {
     /* new timeout is earlier, reschedule master task */
     GNUNET_SCHEDULER_cancel (n->task);
     n->task = GNUNET_SCHEDULER_add_at (timeout,
                                        &master_task,
                                        n);
   }
   n->timeout = timeout;
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Neighbour `%s' changed state to %s with timeout %s\n",
               GNUNET_i2s (&n->id),
               GNUNET_TRANSPORT_ps2s (s),
               GNUNET_STRINGS_absolute_time_to_string (timeout));
   neighbours_changed_notification (&n->id,
                                    n->primary_address.address,
                                    n->state,
                                    n->timeout,
                                    n->primary_address.bandwidth_in,
                                    n->primary_address.bandwidth_out);
 }

References GNUNET_TIME_Absolute::abs_value_us, NeighbourAddress::address, NeighbourAddress::bandwidth_in, NeighbourAddress::bandwidth_out, gettext_noop, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TRANSPORT_is_connected(), GNUNET_TRANSPORT_ps2s(), GST_stats, NeighbourMapEntry::id, master_task(), neighbours_changed_notification(), neighbours_connect_notification(), neighbours_connected, neighbours_disconnect_notification(), NeighbourMapEntry::primary_address, NeighbourMapEntry::state, NeighbourMapEntry::task, timeout, and NeighbourMapEntry::timeout.

Referenced by disconnect_neighbour(), free_neighbour(), GST_neighbours_calculate_receive_delay(), GST_neighbours_handle_session_ack(), GST_neighbours_handle_session_syn(), GST_neighbours_handle_session_syn_ack(), GST_neighbours_session_terminated(), master_task(), send_session_syn_ack_cont(), send_session_syn_cont(), send_syn(), send_syn_ack_message(), setup_neighbour(), and switch_address_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_alternative_address()

static void set_alternative_address	(	struct NeighbourMapEntry *	n,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_in,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_out
	)

static

Initialize the alternative address of a neighbour.

Parameters

n	the neighbour
address	address of the other peer, NULL if other peer connected to us
session	session to use (or NULL, in which case an address must be setup)
bandwidth_in	inbound quota to be used when connection is up
bandwidth_out	outbound quota to be used when connection is up

Definition at line 773 of file gnunet-service-transport_neighbours.c.

 {
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
  
   if (NULL == (papi = GST_plugins_find (address->transport_name)))
   {
     GNUNET_break (0);
     return;
   }
   if (session == n->alternative_address.session)
   {
     n->alternative_address.bandwidth_in = bandwidth_in;
     n->alternative_address.bandwidth_out = bandwidth_out;
     return;
   }
   if (NULL != n->alternative_address.address)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Replacing existing alternative address with another one\n");
     free_address (&n->alternative_address);
   }
   if (NULL == session)
     session = papi->get_session (papi->cls,
                                  address);
   if (NULL == session)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Failed to obtain new session for peer `%s' and  address '%s'\n",
                 GNUNET_i2s (&address->peer),
                 GST_plugins_a2s (address));
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop ("# session creation failed"),
                               1,
                               GNUNET_NO);
     return;
   }
   GST_ats_new_session (address,
                        session);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Neighbour `%s' configured alternative address %s\n",
               GNUNET_i2s (&n->id),
               GST_plugins_a2s (address));
  
   n->alternative_address.address = GNUNET_HELLO_address_copy (address);
   n->alternative_address.bandwidth_in = bandwidth_in;
   n->alternative_address.bandwidth_out = bandwidth_out;
   n->alternative_address.session = session;
   n->alternative_address.ats_active = GNUNET_NO;
   n->alternative_address.keep_alive_nonce = 0;
   GNUNET_assert (GNUNET_YES ==
                  GST_ats_is_known (n->alternative_address.address,
                                    n->alternative_address.session));
 }

Referenced by switch_address_bl_check_cont().

Here is the caller graph for this function:

◆ send_with_session()

static struct GNUNET_TIME_Relative send_with_session	(	struct NeighbourMapEntry *	n,
		const void *	msgbuf,
		size_t	msgbuf_size,
		uint32_t	priority,
		struct GNUNET_TIME_Relative	timeout,
		unsigned int	use_keepalive_timeout,
		GNUNET_TRANSPORT_TransmitContinuation	cont,
		void *	cont_cls
	)

static

Transmit a message using the current session of the given neighbour.

Parameters

n	entry for the recipient
msgbuf	buffer to transmit
msgbuf_size	number of bytes in msgbuf buffer
priority	transmission priority
timeout	transmission timeout
use_keepalive_timeout	GNUNET_YES to use plugin-specific keep-alive timeout (timeout is ignored in that case), GNUNET_NO otherwise
cont	continuation to call when finished (can be NULL)
cont_cls	closure for cont

Returns: timeout (copy of timeout or a calculated one if use_keepalive_timeout is GNUNET_YES.

Definition at line 773 of file gnunet-service-transport_neighbours.c.

 {
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
   struct GNUNET_TIME_Relative result = GNUNET_TIME_UNIT_FOREVER_REL;
  
   GNUNET_assert (NULL != n->primary_address.session);
   if ((((NULL == (papi = GST_plugins_find (
                     n->primary_address.address->transport_name))) ||
         (-1 == papi->send (papi->cls,
                            n->primary_address.session,
                            msgbuf,
                            msgbuf_size,
                            priority,
                            (result = (GNUNET_NO == use_keepalive_timeout) ?
                                      timeout :
                                      GNUNET_TIME_relative_divide (
                               GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                               papi->
                               query_keepalive_factor (papi->cls))),
                            cont,
                            cont_cls)))) &&
       (NULL != cont))
     cont (cont_cls,
           &n->id,
           GNUNET_SYSERR,
           msgbuf_size,
           0);
   GST_neighbours_notify_data_sent (n->primary_address.address,
                                    n->primary_address.session,
                                    msgbuf_size);
   GNUNET_break (NULL != papi);
   return result;
 }

References address, NeighbourAddress::address, NeighbourMapEntry::alternative_address, NeighbourAddress::ats_active, NeighbourAddress::bandwidth_in, NeighbourAddress::bandwidth_out, GNUNET_TRANSPORT_PluginFunctions::cls, free_address(), GNUNET_TRANSPORT_PluginFunctions::get_session, gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_address_copy(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GST_ats_is_known(), GST_ats_new_session(), GST_plugins_a2s(), GST_plugins_find(), GST_stats, NeighbourMapEntry::id, NeighbourAddress::keep_alive_nonce, and NeighbourAddress::session.

Referenced by GST_neighbours_keepalive(), send_disconnect(), send_keepalive(), send_session_ack_message(), set_incoming_quota(), and try_transmission_to_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unset_primary_address()

static void unset_primary_address ( struct NeighbourMapEntry * n )

static

Clear the primary address of a neighbour since this address is not valid anymore and notify monitoring about it.

Parameters

n	the neighbour

Definition at line 898 of file gnunet-service-transport_neighbours.c.

 {
   /* Notify monitoring about change */
   if (NULL == n->primary_address.address)
     return;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Disabling primary address\n");
   neighbours_changed_notification (&n->id,
                                    n->primary_address.address,
                                    n->state,
                                    n->timeout,
                                    GNUNET_BANDWIDTH_value_init (0),
                                    GNUNET_BANDWIDTH_value_init (0));
   free_address (&n->primary_address);
 }

References NeighbourAddress::address, free_address(), GNUNET_BANDWIDTH_value_init(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, NeighbourMapEntry::id, neighbours_changed_notification(), NeighbourMapEntry::primary_address, NeighbourMapEntry::state, and NeighbourMapEntry::timeout.

Referenced by free_neighbour(), GST_neighbours_session_terminated(), master_task(), send_session_syn_ack_cont(), send_session_syn_cont(), send_syn(), and send_syn_ack_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_neighbour()

static void free_neighbour ( struct NeighbourMapEntry * n )

static

Free a neighbour map entry.

Parameters

n	entry to free

Definition at line 921 of file gnunet-service-transport_neighbours.c.

 {
   struct MessageQueue *mq;
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Freeing neighbour state of peer `%s'\n",
               GNUNET_i2s (&n->id));
   n->is_active = NULL; /* always free'd by its own continuation! */
  
   /* fail messages currently in the queue */
   while (NULL != (mq = n->messages_head))
   {
     GNUNET_CONTAINER_DLL_remove (n->messages_head,
                                  n->messages_tail,
                                  mq);
     if (NULL != mq->cont)
       mq->cont (mq->cont_cls,
                 GNUNET_SYSERR,
                 mq->message_buf_size,
                 0);
     GNUNET_free (mq);
   }
   /* Mark peer as disconnected */
   set_state_and_timeout (n,
                          GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED,
                          GNUNET_TIME_UNIT_FOREVER_ABS);
   /* free addresses and mark as unused */
   unset_primary_address (n);
  
   if (NULL != n->alternative_address.address)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Cleaning up alternative address\n");
     free_address (&n->alternative_address);
   }
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CONTAINER_multipeermap_remove (neighbours,
                                                        &n->id,
                                                        n));
  
   /* Cancel address requests for this peer */
   if (NULL != n->suggest_handle)
   {
     GNUNET_ATS_connectivity_suggest_cancel (n->suggest_handle);
     n->suggest_handle = NULL;
   }
  
   /* Cancel the disconnect task */
   if (NULL != n->delayed_disconnect_task)
   {
     GNUNET_SCHEDULER_cancel (n->delayed_disconnect_task);
     n->delayed_disconnect_task = NULL;
   }
  
   /* Cancel the master task */
   if (NULL != n->task)
   {
     GNUNET_SCHEDULER_cancel (n->task);
     n->task = NULL;
   }
   /* free rest of memory */
   GNUNET_free (n);
 }

Referenced by delayed_disconnect(), disconnect_all_neighbours(), disconnect_neighbour(), GST_neighbours_handle_session_syn(), GST_neighbours_handle_session_syn_ack(), GST_neighbours_session_terminated(), master_task(), and switch_address_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_disconnect_cont()

static void send_disconnect_cont	(	void *	cls,
		const struct GNUNET_PeerIdentity *	target,
		int	result,
		size_t	payload,
		size_t	physical
	)

static

Function called when the 'DISCONNECT' message has been sent by the plugin.

Frees the neighbour — if the entry still exists.

Parameters

cls	NULL
target	identity of the neighbour that was disconnected
result	GNUNET_OK if the disconnect got out successfully
payload	bytes payload
physical	bytes on wire

Definition at line 997 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
  
   (void) cls;
   (void) result;
   (void) payload;
   (void) physical;
   n = lookup_neighbour (target);
   if (NULL == n)
     return; /* already gone */
   if (GNUNET_TRANSPORT_PS_DISCONNECT != n->state)
     return; /* have created a fresh entry since */
   if (NULL != n->task)
     GNUNET_SCHEDULER_cancel (n->task);
   n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
 }

References GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_PS_DISCONNECT, lookup_neighbour(), master_task(), payload, result, NeighbourMapEntry::state, and NeighbourMapEntry::task.

Referenced by send_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_disconnect()

static void send_disconnect ( struct NeighbourMapEntry * n )

static

Transmit a DISCONNECT message to the other peer.

Parameters

n	neighbour to send DISCONNECT message.

Definition at line 1026 of file gnunet-service-transport_neighbours.c.

 {
   struct GNUNET_ATS_SessionDisconnectMessage disconnect_msg;
  
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Sending DISCONNECT message to peer `%4s'\n",
               GNUNET_i2s (&n->id));
   disconnect_msg.header.size = htons (sizeof(struct
                                              GNUNET_ATS_SessionDisconnectMessage));
   disconnect_msg.header.type =
     htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT);
   disconnect_msg.reserved = htonl (0);
   disconnect_msg.purpose.size =
     htonl (sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
            + sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
            + sizeof(struct GNUNET_TIME_AbsoluteNBO));
   disconnect_msg.purpose.purpose =
     htonl (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT);
   disconnect_msg.timestamp =
     GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
   disconnect_msg.public_key = GST_my_identity.public_key;
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CRYPTO_eddsa_sign_ (&GST_my_private_key,
                                             &disconnect_msg.purpose,
                                             &disconnect_msg.signature));
  
   (void) send_with_session (n,
                             &disconnect_msg,
                             sizeof(disconnect_msg),
                             UINT32_MAX,
                             GNUNET_TIME_UNIT_FOREVER_REL,
                             GNUNET_NO,
                             &send_disconnect_cont,
                             NULL);
   GNUNET_STATISTICS_update (GST_stats,
                             gettext_noop ("# DISCONNECT messages sent"),
                             1,
                             GNUNET_NO);
 }

References gettext_noop, GNUNET_assert, GNUNET_CRYPTO_eddsa_sign_(), GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_UNIT_FOREVER_REL, GST_my_identity, GST_my_private_key, GST_stats, GNUNET_ATS_SessionDisconnectMessage::header, NeighbourMapEntry::id, GNUNET_PeerIdentity::public_key, GNUNET_ATS_SessionDisconnectMessage::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_ATS_SessionDisconnectMessage::purpose, GNUNET_ATS_SessionDisconnectMessage::reserved, send_disconnect_cont(), send_with_session(), GNUNET_ATS_SessionDisconnectMessage::signature, GNUNET_MessageHeader::size, GNUNET_CRYPTO_EccSignaturePurpose::size, GNUNET_ATS_SessionDisconnectMessage::timestamp, and GNUNET_MessageHeader::type.

Referenced by disconnect_neighbour().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disconnect_neighbour()

static void disconnect_neighbour ( struct NeighbourMapEntry * n )

static

Disconnect from the given neighbour, clean up the record.

Parameters

n	neighbour to disconnect from

Definition at line 1073 of file gnunet-service-transport_neighbours.c.

 {
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Disconnecting from peer %s in state %s\n",
               GNUNET_i2s (&n->id),
               GNUNET_TRANSPORT_ps2s (n->state));
   /* depending on state, notify neighbour and/or upper layers of this peer
      about disconnect */
   switch (n->state)
   {
   case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
   case GNUNET_TRANSPORT_PS_INIT_ATS:
     /* other peer is completely unaware of us, no need to send DISCONNECT */
     free_neighbour (n);
     return;
  
   case GNUNET_TRANSPORT_PS_SYN_SENT:
     send_disconnect (n);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_DISCONNECT,
                            GNUNET_TIME_UNIT_FOREVER_ABS);
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_RECV_ATS:
     /* we never ACK'ed the other peer's request, no need to send DISCONNECT */
     free_neighbour (n);
     return;
  
   case GNUNET_TRANSPORT_PS_SYN_RECV_ACK:
     /* we DID ACK the other peer's request, must send DISCONNECT */
     send_disconnect (n);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_DISCONNECT,
                            GNUNET_TIME_UNIT_FOREVER_ABS);
     break;
  
   case GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT:
   case GNUNET_TRANSPORT_PS_CONNECTED:
   case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     /* we are currently connected, need to send disconnect and do
        internal notifications and update statistics */
     send_disconnect (n);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_DISCONNECT,
                            GNUNET_TIME_UNIT_FOREVER_ABS);
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     /* Disconnecting while waiting for an ATS address to reconnect,
      * cannot send DISCONNECT */
     free_neighbour (n);
     return;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT:
     /* already disconnected, ignore */
     break;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     /* already cleaned up, how did we get here!? */
     GNUNET_assert (0);
     break;
  
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unhandled state `%s'\n",
                 GNUNET_TRANSPORT_ps2s (n->state));
     GNUNET_break (0);
     break;
   }
   /* schedule timeout to clean up */
   if (NULL != n->task)
     GNUNET_SCHEDULER_cancel (n->task);
   n->task = GNUNET_SCHEDULER_add_delayed (DISCONNECT_SENT_TIMEOUT,
                                           &master_task,
                                           n);
 }

Referenced by GST_neighbours_force_disconnect(), master_task(), send_session_syn_cont(), send_syn(), and set_incoming_quota().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_incoming_quota()

static int set_incoming_quota	(	struct NeighbourMapEntry *	n,
		struct GNUNET_BANDWIDTH_Value32NBO	quota
	)

static

Change the incoming quota for the given peer.

Updates our own receive rate and informs the neighbour about the new quota.

Parameters

n	neighbour entry to change quota for
quota	new quota

Returns: GNUNET_YES if n is still valid, GNUNET_NO if n was freed

Definition at line 1162 of file gnunet-service-transport_neighbours.c.

 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Setting inbound quota of %u Bps for peer `%s' to all clients\n",
               ntohl (quota.value__), GNUNET_i2s (&n->id));
   GNUNET_BANDWIDTH_tracker_update_quota (&n->in_tracker,
                                          quota);
   if (0 != ntohl (quota.value__))
   {
     struct GNUNET_ATS_SessionQuotaMessage sqm;
  
     sqm.header.size = htons (sizeof(struct GNUNET_ATS_SessionQuotaMessage));
     sqm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_QUOTA);
     sqm.quota = quota.value__;
     if (NULL != n->primary_address.session)
       (void) send_with_session (n,
                                 &sqm,
                                 sizeof(sqm),
                                 UINT32_MAX - 1,
                                 GNUNET_TIME_UNIT_FOREVER_REL,
                                 GNUNET_NO,
                                 NULL, NULL);
     return GNUNET_YES;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Disconnecting peer `%s' due to SET_QUOTA\n",
               GNUNET_i2s (&n->id));
   if (GNUNET_YES == test_connected (n))
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop ("# disconnects due to quota of 0"),
                               1, GNUNET_NO);
   disconnect_neighbour (n);
   return GNUNET_NO;
 }

References disconnect_neighbour(), gettext_noop, GNUNET_BANDWIDTH_tracker_update_quota(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_QUOTA, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, GST_stats, GNUNET_ATS_SessionQuotaMessage::header, NeighbourMapEntry::id, NeighbourMapEntry::in_tracker, NeighbourMapEntry::primary_address, quota, GNUNET_ATS_SessionQuotaMessage::quota, send_with_session(), NeighbourAddress::session, GNUNET_MessageHeader::size, test_connected(), and GNUNET_MessageHeader::type.

Referenced by set_primary_address(), and try_run_fast_ats_update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_primary_address()

static void set_primary_address	(	struct NeighbourMapEntry *	n,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_in,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_out
	)

static

Initialize the primary address of a neighbour.

Parameters

n	the neighbour
address	address of the other peer, NULL if other peer connected to us
session	session to use (or NULL, in which case an address must be setup)
bandwidth_in	inbound quota to be used when connection is up
bandwidth_out	outbound quota to be used when connection is up

Definition at line 1211 of file gnunet-service-transport_neighbours.c.

 {
   if (session == n->primary_address.session)
   {
     GST_validation_set_address_use (n->primary_address.address,
                                     GNUNET_YES);
     if (n->primary_address.bandwidth_in.value__ != bandwidth_in.value__)
     {
       n->primary_address.bandwidth_in = bandwidth_in;
       if (GNUNET_YES !=
           set_incoming_quota (n,
                               bandwidth_in))
         return;
     }
     if (n->primary_address.bandwidth_out.value__ != bandwidth_out.value__)
     {
       n->primary_address.bandwidth_out = bandwidth_out;
       send_outbound_quota_to_clients (n);
     }
     return;
   }
   if ((NULL != n->primary_address.address) &&
       (0 == GNUNET_HELLO_address_cmp (address,
                                       n->primary_address.address)))
   {
     GNUNET_break (0);
     return;
   }
   if (NULL == session)
   {
     GNUNET_break (0);
     GST_ats_block_address (address,
                            session);
     return;
   }
   if (NULL != n->primary_address.address)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Replacing existing primary address with another one\n");
     free_address (&n->primary_address);
   }
   n->primary_address.address = GNUNET_HELLO_address_copy (address);
   n->primary_address.bandwidth_in = bandwidth_in;
   n->primary_address.bandwidth_out = bandwidth_out;
   n->primary_address.session = session;
   n->primary_address.keep_alive_nonce = 0;
   GNUNET_assert (GNUNET_YES ==
                  GST_ats_is_known (n->primary_address.address,
                                    n->primary_address.session));
   /* subsystems about address use */
   GST_validation_set_address_use (n->primary_address.address,
                                   GNUNET_YES);
   if (GNUNET_YES !=
       set_incoming_quota (n,
                           bandwidth_in))
     return;
   send_outbound_quota_to_clients (n);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Neighbour `%s' switched to address `%s'\n",
               GNUNET_i2s (&n->id),
               GST_plugins_a2s (address));
  
   neighbours_changed_notification (&n->id,
                                    n->primary_address.address,
                                    n->state,
                                    n->timeout,
                                    n->primary_address.bandwidth_in,
                                    n->primary_address.bandwidth_out);
 }

References address, NeighbourAddress::address, NeighbourAddress::bandwidth_in, NeighbourAddress::bandwidth_out, free_address(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_address_cmp(), GNUNET_HELLO_address_copy(), GNUNET_i2s(), GNUNET_log, GNUNET_YES, GST_ats_block_address(), GST_ats_is_known(), GST_plugins_a2s(), GST_validation_set_address_use(), NeighbourMapEntry::id, NeighbourAddress::keep_alive_nonce, neighbours_changed_notification(), NeighbourMapEntry::primary_address, send_outbound_quota_to_clients(), NeighbourAddress::session, set_incoming_quota(), NeighbourMapEntry::state, NeighbourMapEntry::timeout, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by GST_neighbours_handle_session_syn_ack(), and switch_address_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transmit_send_continuation()

static void transmit_send_continuation	(	void *	cls,
		const struct GNUNET_PeerIdentity *	receiver,
		int	success,
		size_t	size_payload,
		size_t	physical
	)

static

We're done with our transmission attempt, continue processing.

Parameters

cls	the `struct MessageQueue` of the message
receiver	intended receiver
success	whether it worked or not
size_payload	bytes payload sent
physical	bytes sent on wire

Definition at line 1296 of file gnunet-service-transport_neighbours.c.

 {
   struct MessageQueue *mq = cls;
   struct NeighbourMapEntry *n;
  
   if (NULL == (n = lookup_neighbour (receiver)))
   {
     if (NULL != mq->cont)
       mq->cont (mq->cont_cls,
                 GNUNET_SYSERR /* not connected */,
                 size_payload,
                 0);
     GNUNET_free (mq);
     return;   /* disconnect or other error while transmitting, can happen */
   }
   if (n->is_active == mq)
   {
     /* this is still "our" neighbour, remove us from its queue
        and allow it to send the next message now */
     n->is_active = NULL;
     if (NULL != n->task)
       GNUNET_SCHEDULER_cancel (n->task);
     n->task = GNUNET_SCHEDULER_add_now (&master_task,
                                         n);
   }
   if (bytes_in_send_queue < mq->message_buf_size)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Bytes_in_send_queue `%llu', Message_size %u, result: %s, payload %u, on wire %u\n",
                 bytes_in_send_queue,
                 (unsigned int) mq->message_buf_size,
                 (GNUNET_OK == success) ? "OK" : "FAIL",
                 (unsigned int) size_payload,
                 (unsigned int) physical);
     GNUNET_break (0);
   }
  
   GNUNET_break (size_payload == mq->message_buf_size);
   bytes_in_send_queue -= mq->message_buf_size;
   GNUNET_STATISTICS_set (GST_stats,
                          gettext_noop (
                            "# bytes in message queue for other peers"),
                          bytes_in_send_queue,
                          GNUNET_NO);
   if (GNUNET_OK == success)
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# messages transmitted to other peers"),
                               1,
                               GNUNET_NO);
   else
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop
                               (
                                 "# transmission failures for messages to other peers"),
                               1, GNUNET_NO);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending message to `%s' of type %u with %u bytes was a %s\n",
               GNUNET_i2s (receiver),
               ntohs (((struct GNUNET_MessageHeader *) mq->message_buf)->type),
               (unsigned int) mq->message_buf_size,
               (success == GNUNET_OK) ? "success" : "FAILURE");
   if (NULL != mq->cont)
     mq->cont (mq->cont_cls,
               success,
               size_payload,
               physical);
   GNUNET_free (mq);
 }

References bytes_in_send_queue, gettext_noop, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GST_stats, NeighbourMapEntry::is_active, lookup_neighbour(), master_task(), mq, receiver(), and NeighbourMapEntry::task.

Referenced by try_transmission_to_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_transmission_to_peer()

static void try_transmission_to_peer ( struct NeighbourMapEntry * n )

static

Check the message list for the given neighbour and if we can send a message, do so.

This function should only be called if the connection is at least generally ready for transmission. While we will only send one message at a time, no bandwidth quota management is performed here. If a message was given to the plugin, the continuation will automatically re-schedule the 'master' task once the next message might be transmitted.

Parameters

n	target peer for which to transmit

Definition at line 1383 of file gnunet-service-transport_neighbours.c.

 {
   struct MessageQueue *mq;
   struct GNUNET_TIME_Relative timeout;
  
   if (NULL == n->primary_address.address)
   {
     /* no address, why are we here? */
     GNUNET_break (0);
     return;
   }
   if ((0 == n->primary_address.address->address_length) &&
       (NULL == n->primary_address.session))
   {
     /* no address, why are we here? */
     GNUNET_break (0);
     return;
   }
   if (NULL != n->is_active)
   {
     /* transmission already pending */
     return;
   }
  
   /* timeout messages from the queue that are past their due date */
   while (NULL != (mq = n->messages_head))
   {
     timeout = GNUNET_TIME_absolute_get_remaining (mq->timeout);
     if (timeout.rel_value_us > 0)
       break;
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# messages timed out while in transport queue"),
                               1,
                               GNUNET_NO);
     GNUNET_CONTAINER_DLL_remove (n->messages_head,
                                  n->messages_tail,
                                  mq);
     n->is_active = mq;
     transmit_send_continuation (mq,
                                 &n->id,
                                 GNUNET_SYSERR,
                                 mq->message_buf_size,
                                 0);     /* timeout */
   }
   if (NULL == mq)
     return;                     /* no more messages */
   if (NULL == n->primary_address.address)
   {
     /* transmit_send_continuation() caused us to drop session,
        can't try transmission anymore. */
     return;
   }
  
  
   GNUNET_CONTAINER_DLL_remove (n->messages_head,
                                n->messages_tail,
                                mq);
   n->is_active = mq;
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Giving message with %u bytes to plugin session %p\n",
               (unsigned int) mq->message_buf_size,
               n->primary_address.session);
   (void) send_with_session (n,
                             mq->message_buf,
                             mq->message_buf_size,
                             0 /* priority */,
                             timeout,
                             GNUNET_NO,
                             &transmit_send_continuation,
                             mq);
 }

References NeighbourAddress::address, GNUNET_HELLO_Address::address_length, gettext_noop, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GST_stats, NeighbourMapEntry::id, NeighbourMapEntry::is_active, NeighbourMapEntry::messages_head, NeighbourMapEntry::messages_tail, mq, NeighbourMapEntry::primary_address, GNUNET_TIME_Relative::rel_value_us, send_with_session(), NeighbourAddress::session, timeout, and transmit_send_continuation().

Referenced by master_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_keepalive()

static void send_keepalive ( struct NeighbourMapEntry * n )

static

Send keepalive message to the neighbour.

Must only be called if we are on 'connected' state or while trying to switch addresses. Will internally determine if a keepalive is truly needed (so can always be called).

Parameters

n	neighbour that went idle and needs a keepalive

Definition at line 1467 of file gnunet-service-transport_neighbours.c.

 {
   struct GNUNET_ATS_SessionKeepAliveMessage m;
   struct GNUNET_TIME_Relative timeout;
   uint32_t nonce;
  
   GNUNET_assert ((GNUNET_TRANSPORT_PS_CONNECTED == n->state) ||
                  (GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT == n->state));
   if (GNUNET_TIME_absolute_get_remaining (n->keep_alive_time).rel_value_us > 0)
     return; /* no keepalive needed at this time */
  
   nonce = 0; /* 0 indicates 'not set' */
   while (0 == nonce)
     nonce = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                       UINT32_MAX);
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending KEEPALIVE to peer `%s' with nonce %u\n",
               GNUNET_i2s (&n->id),
               nonce);
   m.header.size = htons (sizeof(struct GNUNET_ATS_SessionKeepAliveMessage));
   m.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE);
   m.nonce = htonl (nonce);
  
   timeout = send_with_session (n,
                                &m,
                                sizeof(m),
                                UINT32_MAX /* priority */,
                                GNUNET_TIME_UNIT_FOREVER_REL,
                                GNUNET_YES,
                                NULL, NULL);
   GNUNET_STATISTICS_update (GST_stats,
                             gettext_noop ("# KEEPALIVES sent"),
                             1,
                             GNUNET_NO);
   n->primary_address.keep_alive_nonce = nonce;
   n->expect_latency_response = GNUNET_YES;
   n->last_keep_alive_time = GNUNET_TIME_absolute_get ();
   n->keep_alive_time = GNUNET_TIME_relative_to_absolute (timeout);
 }

References NeighbourMapEntry::expect_latency_response, gettext_noop, GNUNET_assert, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT, GNUNET_YES, GST_stats, NeighbourMapEntry::id, NeighbourAddress::keep_alive_nonce, NeighbourMapEntry::keep_alive_time, NeighbourMapEntry::last_keep_alive_time, m, NeighbourMapEntry::primary_address, GNUNET_TIME_Relative::rel_value_us, send_with_session(), NeighbourMapEntry::state, and timeout.

Referenced by master_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GST_neighbours_keepalive()

void GST_neighbours_keepalive	(	const struct GNUNET_PeerIdentity *	neighbour,
		const struct GNUNET_MessageHeader *	m
	)

Keep the connection to the given neighbour alive longer, we received a KEEPALIVE (or equivalent); send a response.

Parameters

neighbour	neighbour to keep alive (by sending keep alive response)
m	the keep alive message containing the nonce to respond to

Definition at line 1517 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
   const struct GNUNET_ATS_SessionKeepAliveMessage *msg_in;
   struct GNUNET_ATS_SessionKeepAliveMessage msg;
  
   if (sizeof(struct GNUNET_ATS_SessionKeepAliveMessage) != ntohs (m->size))
   {
     GNUNET_break_op (0);
     return;
   }
  
   msg_in = (const struct GNUNET_ATS_SessionKeepAliveMessage *) m;
   if (NULL == (n = lookup_neighbour (neighbour)))
   {
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop
                                 ("# KEEPALIVE messages discarded (peer unknown)"),
                               1, GNUNET_NO);
     return;
   }
   if (NULL == n->primary_address.session)
   {
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop
                                 ("# KEEPALIVE messages discarded (no session)"),
                               1, GNUNET_NO);
     return;
   }
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received KEEPALIVE request from peer `%s' with nonce %u\n",
               GNUNET_i2s (&n->id),
               ntohl (msg_in->nonce));
   GNUNET_STATISTICS_update (GST_stats,
                             gettext_noop (
                               "# KEEPALIVES received in good order"),
                             1,
                             GNUNET_NO);
  
   /* send reply to allow neighbour to measure latency */
   msg.header.size = htons (sizeof(struct GNUNET_ATS_SessionKeepAliveMessage));
   msg.header.type = htons (
     GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE_RESPONSE);
   msg.nonce = msg_in->nonce;
   (void) send_with_session (n,
                             &msg,
                             sizeof(struct GNUNET_ATS_SessionKeepAliveMessage),
                             UINT32_MAX /* priority */,
                             GNUNET_TIME_UNIT_FOREVER_REL,
                             GNUNET_YES,
                             NULL, NULL);
 }

References gettext_noop, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE_RESPONSE, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, GST_stats, NeighbourMapEntry::id, lookup_neighbour(), m, msg, GNUNET_ATS_SessionKeepAliveMessage::nonce, NeighbourMapEntry::primary_address, send_with_session(), NeighbourAddress::session, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ GST_neighbours_keepalive_response()

void GST_neighbours_keepalive_response	(	const struct GNUNET_PeerIdentity *	neighbour,
		const struct GNUNET_MessageHeader *	m
	)

We received a KEEP_ALIVE_RESPONSE message and use this to calculate latency to this peer.

Pass the updated information (existing ats plus calculated latency) to ATS.

Parameters

neighbour	neighbour to keep alive
m	the message containing the keep alive response

Definition at line 1582 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
   const struct GNUNET_ATS_SessionKeepAliveMessage *msg;
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
   struct GNUNET_TIME_Relative latency;
  
   if (sizeof(struct GNUNET_ATS_SessionKeepAliveMessage) != ntohs (m->size))
   {
     GNUNET_break_op (0);
     return;
   }
  
   msg = (const struct GNUNET_ATS_SessionKeepAliveMessage *) m;
   if (NULL == (n = lookup_neighbour (neighbour)))
   {
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# KEEPALIVE_RESPONSEs discarded (not connected)"),
                               1,
                               GNUNET_NO);
     return;
   }
   if ((GNUNET_TRANSPORT_PS_CONNECTED != n->state) ||
       (GNUNET_YES != n->expect_latency_response))
   {
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# KEEPALIVE_RESPONSEs discarded (not expected)"),
                               1,
                               GNUNET_NO);
     return;
   }
   if (NULL == n->primary_address.address)
   {
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# KEEPALIVE_RESPONSEs discarded (address changed)"),
                               1,
                               GNUNET_NO);
     return;
   }
   if (n->primary_address.keep_alive_nonce != ntohl (msg->nonce))
   {
     if (0 == n->primary_address.keep_alive_nonce)
       GNUNET_STATISTICS_update (GST_stats,
                                 gettext_noop (
                                   "# KEEPALIVE_RESPONSEs discarded (no nonce)"),
                                 1,
                                 GNUNET_NO);
     else
       GNUNET_STATISTICS_update (GST_stats,
                                 gettext_noop (
                                   "# KEEPALIVE_RESPONSEs discarded (bad nonce)"),
                                 1,
                                 GNUNET_NO);
     return;
   }
   GNUNET_STATISTICS_update (GST_stats,
                             gettext_noop (
                               "# KEEPALIVE_RESPONSEs received (OK)"),
                             1,
                             GNUNET_NO);
  
  
   /* Update session timeout here */
   if (NULL != (papi = GST_plugins_find (
                  n->primary_address.address->transport_name)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Updating session for peer `%s' for session %p\n",
                 GNUNET_i2s (&n->id),
                 n->primary_address.session);
     papi->update_session_timeout (papi->cls,
                                   &n->id,
                                   n->primary_address.session);
   }
   else
   {
     GNUNET_break (0);
   }
  
   n->primary_address.keep_alive_nonce = 0;
   n->expect_latency_response = GNUNET_NO;
   set_state_and_timeout (n,
                          n->state,
                          GNUNET_TIME_relative_to_absolute (
                            GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
  
   latency = GNUNET_TIME_absolute_get_duration (n->last_keep_alive_time);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received KEEPALIVE_RESPONSE from peer `%s', latency is %s\n",
               GNUNET_i2s (&n->id),
               GNUNET_STRINGS_relative_time_to_string (latency,
                                                       GNUNET_YES));
   GST_ats_update_delay (n->primary_address.address,
                         GNUNET_TIME_relative_divide (latency,
                                                      2));
 }

◆ GST_neighbours_calculate_receive_delay()

struct GNUNET_TIME_Relative GST_neighbours_calculate_receive_delay	(	const struct GNUNET_PeerIdentity *	sender,
		ssize_t	size,
		int *	do_forward
	)

We have received a message from the given sender.

How long should we delay before receiving more? (Also used to keep the peer marked as live).

Parameters

sender	sender of the message
size	size of the message
do_forward	set to GNUNET_YES if the message should be forwarded to clients GNUNET_NO if the neighbour is not connected or violates the quota, GNUNET_SYSERR if the connection is not fully up yet

Returns: how long to wait before reading more from this sender

Definition at line 1582 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
   struct GNUNET_TIME_Relative ret;
  
   if (NULL == neighbours)
   {
     *do_forward = GNUNET_NO;
     return GNUNET_TIME_UNIT_FOREVER_REL;   /* This can happen during shutdown */
   }
   if (NULL == (n = lookup_neighbour (sender)))
   {
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# messages discarded due to lack of neighbour record"),
                               1,
                               GNUNET_NO);
     *do_forward = GNUNET_NO;
     return GNUNET_TIME_UNIT_ZERO;
   }
   if (! test_connected (n))
   {
     *do_forward = GNUNET_SYSERR;
     return GNUNET_TIME_UNIT_ZERO;
   }
   if (GNUNET_YES == GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, size))
   {
     n->quota_violation_count++;
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Bandwidth quota (%u b/s) violation detected (total of %u).\n",
                 n->in_tracker.available_bytes_per_s__,
                 n->quota_violation_count);
     /* Discount 32k per violation */
     GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, -32 * 1024);
   }
   else
   {
     if (n->quota_violation_count > 0)
     {
       /* try to add 32k back */
       GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, 32 * 1024);
       n->quota_violation_count--;
     }
   }
   if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD)
   {
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop
                                 ("# bandwidth quota violations by other peers"),
                               1, GNUNET_NO);
     *do_forward = GNUNET_NO;
     return GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT;
   }
   *do_forward = GNUNET_YES;
   ret = GNUNET_BANDWIDTH_tracker_get_delay (&n->in_tracker, 32 * 1024);
   if (ret.rel_value_us > 0)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Throttling read (%lld bytes excess at %u b/s), waiting %s before reading more.\n",
                 (long long) n->in_tracker.consumption_since_last_update__,
                 (unsigned int) n->in_tracker.available_bytes_per_s__,
                 GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop ("# ms throttling suggested"),
                               (int64_t) ret.rel_value_us / 1000LL,
                               GNUNET_NO);
   }
   return ret;
 }

References NeighbourAddress::address, GNUNET_TRANSPORT_PluginFunctions::cls, NeighbourMapEntry::expect_latency_response, gettext_noop, GNUNET_break, GNUNET_break_op, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_YES, GST_ats_update_delay(), GST_plugins_find(), GST_stats, NeighbourMapEntry::id, NeighbourAddress::keep_alive_nonce, NeighbourMapEntry::last_keep_alive_time, lookup_neighbour(), m, msg, NeighbourMapEntry::primary_address, NeighbourAddress::session, set_state_and_timeout(), NeighbourMapEntry::state, GNUNET_HELLO_Address::transport_name, and GNUNET_TRANSPORT_PluginFunctions::update_session_timeout.

Referenced by inbound_bw_tracker_update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GST_neighbours_send()

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

Transmit a message to the given target using the active connection.

Parameters

target	destination
msg	message to send
msg_size	number of bytes in msg
timeout	when to fail with timeout
cont	function to call when done
cont_cls	closure for cont

Definition at line 1772 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
   struct MessageQueue *mq;
  
   /* All ove these cases should never happen; they are all API violations.
      But we check anyway, just to be sure. */
   if (NULL == (n = lookup_neighbour (target)))
   {
     GNUNET_break (0);
     if (NULL != cont)
       cont (cont_cls,
             GNUNET_SYSERR,
             msg_size,
             0);
     return;
   }
   if (GNUNET_YES != test_connected (n))
   {
     GNUNET_break (0);
     if (NULL != cont)
       cont (cont_cls,
             GNUNET_SYSERR,
             msg_size,
             0);
     return;
   }
   bytes_in_send_queue += msg_size;
   GNUNET_STATISTICS_set (GST_stats,
                          gettext_noop
                            ("# bytes in message queue for other peers"),
                          bytes_in_send_queue, GNUNET_NO);
   mq = GNUNET_malloc (sizeof(struct MessageQueue) + msg_size);
   mq->cont = cont;
   mq->cont_cls = cont_cls;
   GNUNET_memcpy (&mq[1], msg, msg_size);
   mq->message_buf = (const char *) &mq[1];
   mq->message_buf_size = msg_size;
   mq->timeout = GNUNET_TIME_relative_to_absolute (timeout);
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Enqueueing %u bytes to send to peer %s\n",
               (unsigned int) msg_size,
               GNUNET_i2s (target));
   GNUNET_CONTAINER_DLL_insert_tail (n->messages_head,
                                     n->messages_tail,
                                     mq);
   if (NULL != n->task)
     GNUNET_SCHEDULER_cancel (n->task);
   n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
 }

References bytes_in_send_queue, MessageQueue::cont, MessageQueue::cont_cls, gettext_noop, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_relative_to_absolute(), GNUNET_YES, GST_stats, lookup_neighbour(), master_task(), NeighbourMapEntry::messages_head, NeighbourMapEntry::messages_tail, mq, msg, NeighbourMapEntry::task, test_connected(), and timeout.

Referenced by GST_manipulation_send(), send_delayed(), and transmit_our_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_session_syn_cont()

static void send_session_syn_cont	(	void *	cls,
		const struct GNUNET_PeerIdentity *	target,
		int	result,
		size_t	size_payload,
		size_t	size_on_wire
	)

static

Continuation called from our attempt to transmitted our GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN to the specified target.

Continue processing based on the result. Specifically, if we failed to transmit, discard the address we used.

Parameters

cls	NULL
target	which peer received the transmission
result	GNUNET_OK if sending worked
size_payload	how many bytes of payload were sent (ignored)
size_on_wire	how much bandwidth was consumed on the wire (ignored)

Definition at line 1843 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
  
   (void) cls;
   (void) size_payload;
   (void) size_on_wire;
   n = lookup_neighbour (target);
   if (NULL == n)
   {
     /* SYN continuation was called after neighbor was freed,
      * for example due to a time out for the state or the session
      * used was already terminated: nothing to do here... */
     return;
   }
  
   if ((GNUNET_TRANSPORT_PS_SYN_SENT != n->state) &&
       (GNUNET_TRANSPORT_PS_RECONNECT_SENT != n->state) &&
       (GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT != n->state))
   {
     /* SYN continuation was called after neighbor changed state,
      * for example due to a time out for the state or the session
      * used was already terminated: nothing to do here... */
     return;
   }
   if (GNUNET_OK == result)
     return;
  
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _ ("Failed to send SYN message to peer `%s'\n"),
               GNUNET_i2s (target));
   switch (n->state)
   {
   case GNUNET_TRANSPORT_PS_SYN_SENT:
     /* Remove address and request an additional one */
     unset_primary_address (n);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_INIT_ATS,
                            GNUNET_TIME_relative_to_absolute (
                              FAST_RECONNECT_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     /* Remove address and request an additional one */
     unset_primary_address (n);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_RECONNECT_ATS,
                            GNUNET_TIME_relative_to_absolute (
                              ATS_RESPONSE_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT:
     /* Remove address and request and go back to primary address */
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# Failed attempts to switch addresses (failed to send SYN CONT)"),
                               1,
                               GNUNET_NO);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Switch failed, cleaning up alternative address\n");
     free_address (&n->alternative_address);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_CONNECTED,
                            GNUNET_TIME_relative_to_absolute (
                              ATS_RESPONSE_TIMEOUT));
     break;
  
   default:
     disconnect_neighbour (n);
     break;
   }
 }

References _, NeighbourMapEntry::alternative_address, ATS_RESPONSE_TIMEOUT, disconnect_neighbour(), FAST_RECONNECT_TIMEOUT, free_address(), gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TRANSPORT_PS_RECONNECT_ATS, GNUNET_TRANSPORT_PS_RECONNECT_SENT, GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT, GNUNET_TRANSPORT_PS_SYN_SENT, GST_stats, lookup_neighbour(), result, set_state_and_timeout(), NeighbourMapEntry::state, and unset_primary_address().

Referenced by send_syn().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_syn()

static void send_syn ( struct NeighbourAddress * na )

static

Send a SYN message via the given address.

Parameters

na	address to use

Definition at line 1927 of file gnunet-service-transport_neighbours.c.

 {
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
   struct TransportSynMessage connect_msg;
   struct NeighbourMapEntry *n;
  
   GNUNET_assert (NULL != na->session);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Sending SYN message to peer `%s' at %s\n",
               GNUNET_i2s (&na->address->peer),
               GST_plugins_a2s (na->address));
  
   papi = GST_plugins_find (na->address->transport_name);
   GNUNET_assert (NULL != papi);
   GNUNET_STATISTICS_update (GST_stats,
                             gettext_noop
                               ("# SYN messages sent"),
                             1, GNUNET_NO);
   na->connect_timestamp = GNUNET_TIME_absolute_get ();
   connect_msg.header.size = htons (sizeof(struct TransportSynMessage));
   connect_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN);
   connect_msg.reserved = htonl (0);
   connect_msg.timestamp = GNUNET_TIME_absolute_hton (na->connect_timestamp);
   if (-1 ==
       papi->send (papi->cls,
                   na->session,
                   (const char *) &connect_msg,
                   sizeof(struct TransportSynMessage),
                   UINT_MAX,
                   SETUP_CONNECTION_TIMEOUT,
                   &send_session_syn_cont, NULL))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _ ("Failed to transmit SYN message to %s\n"),
                 GST_plugins_a2s (na->address));
     n = lookup_neighbour (&na->address->peer);
     if (NULL == n)
     {
       GNUNET_break (0);
       return;
     }
     switch (n->state)
     {
     case GNUNET_TRANSPORT_PS_SYN_SENT:
       /* Remove address and request and additional one */
       GNUNET_assert (na == &n->primary_address);
       unset_primary_address (n);
       set_state_and_timeout (n,
                              GNUNET_TRANSPORT_PS_INIT_ATS,
                              GNUNET_TIME_relative_to_absolute (
                                FAST_RECONNECT_TIMEOUT));
       /* Hard failure to send the SYN message with this address:
          Destroy address and session */
       break;
  
     case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
       /* Remove address and request an additional one */
       GNUNET_assert (na == &n->primary_address);
       unset_primary_address (n);
       set_state_and_timeout (n,
                              GNUNET_TRANSPORT_PS_RECONNECT_ATS,
                              GNUNET_TIME_relative_to_absolute (
                                ATS_RESPONSE_TIMEOUT));
       break;
  
     case GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT:
       GNUNET_assert (na == &n->alternative_address);
       GNUNET_STATISTICS_update (GST_stats,
                                 gettext_noop (
                                   "# Failed attempts to switch addresses (failed to send SYN)"),
                                 1,
                                 GNUNET_NO);
       /* Remove address and request an additional one */
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Switch failed, cleaning up alternative address\n");
       free_address (&n->alternative_address);
       set_state_and_timeout (n,
                              GNUNET_TRANSPORT_PS_CONNECTED,
                              GNUNET_TIME_relative_to_absolute (
                                ATS_RESPONSE_TIMEOUT));
       break;
  
     default:
       GNUNET_break (0);
       disconnect_neighbour (n);
       break;
     }
     return;
   }
   GST_neighbours_notify_data_sent (na->address,
                                    na->session,
                                    sizeof(struct TransportSynMessage));
 }

References _, NeighbourAddress::address, NeighbourMapEntry::alternative_address, ATS_RESPONSE_TIMEOUT, GNUNET_TRANSPORT_PluginFunctions::cls, NeighbourAddress::connect_timestamp, disconnect_neighbour(), FAST_RECONNECT_TIMEOUT, free_address(), gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TRANSPORT_PS_RECONNECT_ATS, GNUNET_TRANSPORT_PS_RECONNECT_SENT, GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT, GNUNET_TRANSPORT_PS_SYN_SENT, GST_neighbours_notify_data_sent(), GST_plugins_a2s(), GST_plugins_find(), GST_stats, TransportSynMessage::header, lookup_neighbour(), GNUNET_HELLO_Address::peer, NeighbourMapEntry::primary_address, TransportSynMessage::reserved, GNUNET_TRANSPORT_PluginFunctions::send, send_session_syn_cont(), NeighbourAddress::session, set_state_and_timeout(), SETUP_CONNECTION_TIMEOUT, GNUNET_MessageHeader::size, NeighbourMapEntry::state, TransportSynMessage::timestamp, GNUNET_HELLO_Address::transport_name, GNUNET_MessageHeader::type, and unset_primary_address().

Referenced by switch_address_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_session_syn_ack_cont()

static void send_session_syn_ack_cont	(	void *	cls,
		const struct GNUNET_PeerIdentity *	target,
		int	result,
		size_t	size_payload,
		size_t	size_on_wire
	)

static

Continuation called from our attempt to transmitted our GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK to the specified target.

Continue processing based on the result. Specifically, if we failed to transmit, discard the address we used.

Parameters

cls	NULL
target	which peer received the transmission
result	GNUNET_OK if sending worked
size_payload	how many bytes of payload were sent (ignored)
size_on_wire	how much bandwidth was consumed on the wire (ignored)

Definition at line 2035 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
  
   (void) cls;
   (void) size_payload;
   (void) size_on_wire;
   n = lookup_neighbour (target);
   if (NULL == n)
   {
     /* SYN_ACK continuation was called after neighbor was freed,
      * for example due to a time out for the state or the session
      * used was already terminated: nothing to do here... */
     return;
   }
  
   if (GNUNET_TRANSPORT_PS_SYN_RECV_ACK != n->state)
   {
     /* SYN_ACK continuation was called after neighbor changed state,
      * for example due to a time out for the state or the session
      * used was already terminated: nothing to do here... */
     return;
   }
   if (GNUNET_OK == result)
     return;
  
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _ (
                 "Failed to send SYN_ACK message to peer `%s' using address `%s'\n"),
               GNUNET_i2s (target),
               GST_plugins_a2s (n->primary_address.address));
  
   /* Remove address and request and additional one */
   /* FIXME: what if the neighbour's primary address
      changed in the meantime? Might want to instead
      pass "something" around in closure to be sure. */
   unset_primary_address (n);
   n->ack_state = ACK_SEND_SYN_ACK;
   set_state_and_timeout (n,
                          GNUNET_TRANSPORT_PS_SYN_RECV_ATS,
                          GNUNET_TIME_relative_to_absolute (
                            ATS_RESPONSE_TIMEOUT));
 }

References _, ACK_SEND_SYN_ACK, NeighbourMapEntry::ack_state, NeighbourAddress::address, ATS_RESPONSE_TIMEOUT, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_PS_SYN_RECV_ACK, GNUNET_TRANSPORT_PS_SYN_RECV_ATS, GST_plugins_a2s(), lookup_neighbour(), NeighbourMapEntry::primary_address, result, set_state_and_timeout(), NeighbourMapEntry::state, and unset_primary_address().

Referenced by send_syn_ack_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_syn_ack_message()

static void send_syn_ack_message	(	struct NeighbourAddress *	na,
		struct GNUNET_TIME_Absolute	timestamp
	)

static

Send a SYN_ACK message via the given address.

Parameters

na	address and session to use
timestamp	timestamp to use for the ACK message

Returns: GNUNET_SYSERR if sending immediately failed, GNUNET_OK otherwise

Definition at line 2092 of file gnunet-service-transport_neighbours.c.

 {
   const struct GNUNET_HELLO_Address *address = na->address;
   struct GNUNET_ATS_Session *session = na->session;
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
   struct TransportSynMessage connect_msg;
   struct NeighbourMapEntry *n;
  
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Sending SYN_ACK to peer `%s'\n",
               GNUNET_i2s (&address->peer));
  
   if (NULL == (papi = GST_plugins_find (address->transport_name)))
   {
     GNUNET_break (0);
     return;
   }
   if (NULL == session)
     session = papi->get_session (papi->cls,
                                  address);
   if (NULL == session)
   {
     GNUNET_break (0);
     return;
   }
   GST_ats_new_session (address,
                        session);
   GNUNET_STATISTICS_update (GST_stats,
                             gettext_noop
                               ("# SYN_ACK messages sent"),
                             1, GNUNET_NO);
   connect_msg.header.size = htons (sizeof(struct TransportSynMessage));
   connect_msg.header.type = htons (
     GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK);
   connect_msg.reserved = htonl (0);
   connect_msg.timestamp = GNUNET_TIME_absolute_hton (timestamp);
  
   if (GNUNET_SYSERR ==
       papi->send (papi->cls,
                   session,
                   (const char *) &connect_msg,
                   sizeof(struct TransportSynMessage),
                   UINT_MAX,
                   GNUNET_TIME_UNIT_FOREVER_REL,
                   &send_session_syn_ack_cont, NULL))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _ ("Failed to transmit SYN_ACK message to %s\n"),
                 GST_plugins_a2s (address));
  
     n = lookup_neighbour (&address->peer);
     if (NULL == n)
     {
       GNUNET_break (0);
       return;
     }
     /* Remove address and request and additional one */
     unset_primary_address (n);
     n->ack_state = ACK_SEND_SYN_ACK;
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SYN_RECV_ATS,
                            GNUNET_TIME_relative_to_absolute (
                              ATS_RESPONSE_TIMEOUT));
     return;
   }
 }

References _, ACK_SEND_SYN_ACK, NeighbourMapEntry::ack_state, address, NeighbourAddress::address, ATS_RESPONSE_TIMEOUT, GNUNET_TRANSPORT_PluginFunctions::cls, GNUNET_TRANSPORT_PluginFunctions::get_session, gettext_noop, GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_PS_SYN_RECV_ATS, GST_ats_new_session(), GST_plugins_a2s(), GST_plugins_find(), GST_stats, TransportSynMessage::header, lookup_neighbour(), TransportSynMessage::reserved, GNUNET_TRANSPORT_PluginFunctions::send, send_session_syn_ack_cont(), NeighbourAddress::session, set_state_and_timeout(), GNUNET_MessageHeader::size, TransportSynMessage::timestamp, GNUNET_MessageHeader::type, and unset_primary_address().

Referenced by GST_neighbours_handle_session_syn(), and switch_address_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inbound_bw_tracker_update()

static void inbound_bw_tracker_update ( void * cls )

static

Function called by the bandwidth tracker for a peer whenever the tracker's state changed such that we need to recalculate the delay for flow control.

We calculate the latest delay and inform the plugin (if applicable).

Parameters

cls	the `struct NeighbourMapEntry` to update calculations for

Definition at line 2170 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n = cls;
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
   struct GNUNET_TIME_Relative delay;
   int do_forward;
  
   if (NULL == n->primary_address.address)
     return; /* not active, ignore */
   papi = GST_plugins_find (n->primary_address.address->transport_name);
   GNUNET_assert (NULL != papi);
   if (NULL == papi->update_inbound_delay)
     return;
   delay = GST_neighbours_calculate_receive_delay (&n->id,
                                                   0,
                                                   &do_forward);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "New inbound delay for peer `%s' is %llu ms\n",
               GNUNET_i2s (&n->id),
               (unsigned long long) delay.rel_value_us / 1000LL);
   if (NULL == n->primary_address.session)
     return;
   papi->update_inbound_delay (papi->cls,
                               &n->id,
                               n->primary_address.session,
                               delay);
 }

References NeighbourAddress::address, GNUNET_TRANSPORT_PluginFunctions::cls, delay, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GST_neighbours_calculate_receive_delay(), GST_plugins_find(), NeighbourMapEntry::id, NeighbourMapEntry::primary_address, GNUNET_TIME_Relative::rel_value_us, NeighbourAddress::session, GNUNET_HELLO_Address::transport_name, and GNUNET_TRANSPORT_PluginFunctions::update_inbound_delay.

Referenced by setup_neighbour().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setup_neighbour()

static struct NeighbourMapEntry* setup_neighbour ( const struct GNUNET_PeerIdentity * peer )

static

Create a fresh entry in the neighbour map for the given peer.

Parameters

peer	peer to create an entry for

Returns: new neighbour map entry

Definition at line 2206 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
  
   if (0 ==
       memcmp (&GST_my_identity,
               peer,
               sizeof(struct GNUNET_PeerIdentity)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Cowardly refusing to consider myself my neighbour!\n");
     return NULL;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Creating new neighbour entry for `%s'\n",
               GNUNET_i2s (peer));
   n = GNUNET_new (struct NeighbourMapEntry);
   n->id = *peer;
   n->ack_state = ACK_UNDEFINED;
   n->last_util_transmission = GNUNET_TIME_absolute_get ();
   n->neighbour_receive_quota = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
   GNUNET_BANDWIDTH_tracker_init (&n->in_tracker,
                                  &inbound_bw_tracker_update,
                                  n,
                                  GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
                                  MAX_BANDWIDTH_CARRY_S);
   n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
   set_state_and_timeout (n,
                          GNUNET_TRANSPORT_PS_NOT_CONNECTED,
                          GNUNET_TIME_UNIT_FOREVER_ABS);
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONTAINER_multipeermap_put (neighbours,
                                                     &n->id,
                                                     n,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   n->suggest_handle = GNUNET_ATS_connectivity_suggest (GST_ats_connect,
                                                        peer,
                                                        0);
  
   return n;
 }

References NeighbourMapEntry::ack_state, ACK_UNDEFINED, GNUNET_assert, GNUNET_ATS_connectivity_suggest(), GNUNET_BANDWIDTH_tracker_init(), GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TRANSPORT_PS_NOT_CONNECTED, GST_ats_connect, GST_my_identity, NeighbourMapEntry::id, NeighbourMapEntry::in_tracker, inbound_bw_tracker_update(), NeighbourMapEntry::last_util_transmission, master_task(), MAX_BANDWIDTH_CARRY_S, NeighbourMapEntry::neighbour_receive_quota, neighbours, peer, set_state_and_timeout(), NeighbourMapEntry::suggest_handle, and NeighbourMapEntry::task.

Referenced by GST_neighbours_handle_session_syn(), and switch_address_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GST_neighbours_handle_session_syn()

int GST_neighbours_handle_session_syn	(	const struct GNUNET_MessageHeader *	message,
		const struct GNUNET_PeerIdentity *	peer
	)

We received a 'SYN' message from the other peer.

We received a 'SESSION_CONNECT' message from the other peer.

Consider switching to it.

Parameters

message	possibly a `struct TransportSynMessage` (check format)
peer	identity of the peer to switch the address for

Returns: GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

Definition at line 2290 of file gnunet-service-transport_neighbours.c.

 {
   const struct TransportSynMessage *scm;
   struct NeighbourMapEntry *n;
   struct GNUNET_TIME_Absolute ts;
  
   if (ntohs (message->size) != sizeof(struct TransportSynMessage))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
   GNUNET_STATISTICS_update (GST_stats,
                             gettext_noop
                               ("# SYN messages received"),
                             1, GNUNET_NO);
   if (NULL == neighbours)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _ (
                   "SYN request from peer `%s' ignored due impending shutdown\n"),
                 GNUNET_i2s (peer));
     return GNUNET_OK;   /* we're shutting down */
   }
   scm = (const struct TransportSynMessage *) message;
   GNUNET_break_op (0 == ntohl (scm->reserved));
   ts = GNUNET_TIME_absolute_ntoh (scm->timestamp);
   if (0 ==
       memcmp (&GST_my_identity,
               peer,
               sizeof(struct GNUNET_PeerIdentity)))
   {
     /* loopback connection-to-self, ignore */
     return GNUNET_SYSERR;
   }
   n = lookup_neighbour (peer);
   if (NULL == n)
   {
     /* This is a new neighbour and set to not connected */
     n = setup_neighbour (peer);
     GNUNET_assert (NULL != n);
   }
  
   /* Remember this SYN message in neighbour */
   n->ack_state = ACK_SEND_SYN_ACK;
   n->connect_ack_timestamp = ts;
  
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Received SYN for peer `%s' in state %s/%s\n",
               GNUNET_i2s (peer),
               GNUNET_TRANSPORT_ps2s (n->state),
               print_ack_state (n->ack_state));
  
   switch (n->state)
   {
   case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     /* Request an address from ATS to send SYN_ACK to this peer */
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SYN_RECV_ATS,
                            GNUNET_TIME_relative_to_absolute (
                              ATS_RESPONSE_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_INIT_ATS:
     /* SYN message takes priority over us asking ATS for address:
      * Wait for ATS to suggest an address and send SYN_ACK */
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SYN_RECV_ATS,
                            GNUNET_TIME_relative_to_absolute (
                              ATS_RESPONSE_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_RECV_ATS:
     /* We already wait for an address to send an SYN_ACK */
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_SENT:
   case GNUNET_TRANSPORT_PS_SYN_RECV_ACK:
     /* Send ACK immediately */
     n->ack_state = ACK_SEND_ACK;
     send_syn_ack_message (&n->primary_address,
                           ts);
     break;
  
   case GNUNET_TRANSPORT_PS_CONNECTED:
     /* we are already connected and can thus send the ACK immediately */
     GNUNET_assert (NULL != n->primary_address.address);
     GNUNET_assert (NULL != n->primary_address.session);
     n->ack_state = ACK_SEND_ACK;
     send_syn_ack_message (&n->primary_address,
                           ts);
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     /* We wait for ATS address suggestion */
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     /* We received a SYN message while waiting for a SYN_ACK in fast
      * reconnect. Send SYN_ACK immediately */
     n->ack_state = ACK_SEND_ACK;
     send_syn_ack_message (&n->primary_address,
                           n->connect_ack_timestamp);
     break;
  
   case GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT:
     /* We are already connected and can thus send the ACK immediately;
        still, it can never hurt to have an alternative address, so also
        tell ATS  about it */
     GNUNET_assert (NULL != n->primary_address.address);
     GNUNET_assert (NULL != n->primary_address.session);
     n->ack_state = ACK_SEND_ACK;
     send_syn_ack_message (&n->primary_address,
                           ts);
     break;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT:
     /* Get rid of remains and re-try */
     free_neighbour (n);
     n = setup_neighbour (peer);
     GNUNET_assert (NULL != n);
     /* Remember the SYN time stamp for ACK message */
     n->ack_state = ACK_SEND_SYN_ACK;
     n->connect_ack_timestamp = ts;
     /* Request an address for the peer */
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SYN_RECV_ATS,
                            GNUNET_TIME_relative_to_absolute (
                              ATS_RESPONSE_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     /* should not be possible */
     GNUNET_assert (0);
     break;
  
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unhandled state `%s'\n",
                 GNUNET_TRANSPORT_ps2s (n->state));
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
   return GNUNET_OK;
 }

Referenced by connect_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_run_fast_ats_update()

static int try_run_fast_ats_update	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_in,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_out
	)

static

Check if the given address is the same that we are already using for the respective neighbour.

If so, update the bandwidth assignment and possibly the session and return GNUNET_OK. If the new address is different from what the neighbour is using right now, return GNUNET_NO.

Parameters

address	address of the other peer,
session	session to use or NULL if transport should initiate a session
bandwidth_in	inbound quota to be used when connection is up, 0 to disconnect from peer
bandwidth_out	outbound quota to be used when connection is up, 0 to disconnect from peer

Returns: GNUNET_OK if we were able to just update the bandwidth and session, GNUNET_NO if more extensive changes are required (address changed)

Definition at line 2454 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
  
   n = lookup_neighbour (&address->peer);
   if ((NULL == n) ||
       (NULL == n->primary_address.address) ||
       (0 != GNUNET_HELLO_address_cmp (address,
                                       n->primary_address.address)))
     return GNUNET_NO;
   /* We are not really switching addresses, but merely adjusting
      session and/or bandwidth, can do fast ATS update! */
   if (session != n->primary_address.session)
   {
     /* switch to a different session, but keeping same address; could
        happen if there is a 2nd inbound connection */
     n->primary_address.session = session;
     GNUNET_assert (GNUNET_YES ==
                    GST_ats_is_known (n->primary_address.address,
                                      n->primary_address.session));
   }
   if (n->primary_address.bandwidth_in.value__ != bandwidth_in.value__)
   {
     n->primary_address.bandwidth_in = bandwidth_in;
     if (GNUNET_YES !=
         set_incoming_quota (n,
                             bandwidth_in))
       return GNUNET_NO;
   }
   if (n->primary_address.bandwidth_out.value__ != bandwidth_out.value__)
   {
     n->primary_address.bandwidth_out = bandwidth_out;
     send_outbound_quota_to_clients (n);
   }
   return GNUNET_OK;
 }

References address, NeighbourAddress::address, NeighbourAddress::bandwidth_in, NeighbourAddress::bandwidth_out, GNUNET_assert, GNUNET_HELLO_address_cmp(), GNUNET_NO, GNUNET_OK, GNUNET_YES, GST_ats_is_known(), lookup_neighbour(), NeighbourMapEntry::primary_address, send_outbound_quota_to_clients(), NeighbourAddress::session, set_incoming_quota(), and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by GST_neighbours_switch_to_address(), and switch_address_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ switch_address_bl_check_cont()

static void switch_address_bl_check_cont	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		int	result
	)

static

We've been asked to switch addresses, and just now got the result from the blacklist check to see if this is allowed.

Parameters

cls	the `struct BlacklistCheckSwitchContext` with the information about the future address
peer	the peer we may switch addresses on
address	address associated with the request
session	session associated with the request
result	GNUNET_OK if the connection is allowed, GNUNET_NO if not, GNUNET_SYSERR if operation was aborted

Definition at line 2509 of file gnunet-service-transport_neighbours.c.

 {
   struct BlacklistCheckSwitchContext *blc_ctx = cls;
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
   struct NeighbourMapEntry *n;
  
   if (GNUNET_SYSERR == result)
     goto cleanup;
  
   papi = GST_plugins_find (address->transport_name);
   if (NULL == papi)
   {
     /* This can happen during shutdown. */
     goto cleanup;
   }
  
   if (GNUNET_NO == result)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Blacklist denied to switch to suggested address `%s' session %p for peer `%s'\n",
                 GST_plugins_a2s (address),
                 session,
                 GNUNET_i2s (peer));
     GNUNET_STATISTICS_update (GST_stats,
                               "# ATS suggestions ignored (blacklist denied)",
                               1,
                               GNUNET_NO);
     if (NULL != session)
       papi->disconnect_session (papi->cls,
                                 session);
     if (GNUNET_YES !=
         GNUNET_HELLO_address_check_option (address,
                                            GNUNET_HELLO_ADDRESS_INFO_INBOUND))
       GST_ats_block_address (address,
                              NULL);
     goto cleanup;
   }
  
  
   if (NULL == session)
   {
     /* need to create a session, ATS only gave us an address */
     session = papi->get_session (papi->cls,
                                  address);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Obtained new session for peer `%s' and  address '%s': %p\n",
                 GNUNET_i2s (&address->peer),
                 GST_plugins_a2s (address),
                 session);
     if (NULL != session)
       GST_ats_new_session (address,
                            session);
   }
   if (NULL == session)
   {
     /* session creation failed, bad!, fail! */
     GNUNET_STATISTICS_update (GST_stats,
                               "# ATS suggestions ignored (failed to create session)",
                               1,
                               GNUNET_NO);
     /* No session could be obtained, remove blacklist check and clean up */
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Failed to obtain new session for peer `%s' and address '%s'\n",
                 GNUNET_i2s (&address->peer),
                 GST_plugins_a2s (address));
     GST_ats_block_address (address,
                            session);
     goto cleanup;
   }
  
   /* We did this check already before going into blacklist, but
      it is theoretically possible that the situation changed in
      the meantime, hence we check again here */
   if (GNUNET_OK ==
       try_run_fast_ats_update (address,
                                session,
                                blc_ctx->bandwidth_in,
                                blc_ctx->bandwidth_out))
     goto cleanup; /* was just a minor update, we're done */
  
   /* check if we also need to setup the neighbour entry */
   if (NULL == (n = lookup_neighbour (peer)))
   {
     n = setup_neighbour (peer);
     if (NULL == n)
     {
       /* not sure how this can happen... */
       GNUNET_break (0);
       goto cleanup;
     }
     n->state = GNUNET_TRANSPORT_PS_INIT_ATS;
   }
  
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Peer `%s' switches to address `%s'\n",
               GNUNET_i2s (&address->peer),
               GST_plugins_a2s (address));
  
   switch (n->state)
   {
   case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     GNUNET_break (0);
     GST_ats_block_address (address,
                            session);
     free_neighbour (n);
     return;
  
   case GNUNET_TRANSPORT_PS_INIT_ATS:
     /* We requested an address and ATS suggests one:
      * set primary address and send SYN message*/
     set_primary_address (n,
                          address,
                          session,
                          blc_ctx->bandwidth_in,
                          blc_ctx->bandwidth_out);
     if (ACK_SEND_SYN_ACK == n->ack_state)
     {
       /* Send pending SYN_ACK message */
       n->ack_state = ACK_SEND_ACK;
       send_syn_ack_message (&n->primary_address,
                             n->connect_ack_timestamp);
     }
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SYN_SENT,
                            GNUNET_TIME_relative_to_absolute (
                              SETUP_CONNECTION_TIMEOUT));
     send_syn (&n->primary_address);
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_SENT:
     /* ATS suggested a new address while waiting for an SYN_ACK:
      * Switch and send new SYN */
     /* ATS suggests a different address, switch again */
     set_primary_address (n,
                          address,
                          session,
                          blc_ctx->bandwidth_in,
                          blc_ctx->bandwidth_out);
     if (ACK_SEND_SYN_ACK == n->ack_state)
     {
       /* Send pending SYN_ACK message */
       n->ack_state = ACK_SEND_ACK;
       send_syn_ack_message (&n->primary_address,
                             n->connect_ack_timestamp);
     }
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SYN_SENT,
                            GNUNET_TIME_relative_to_absolute (
                              SETUP_CONNECTION_TIMEOUT));
     send_syn (&n->primary_address);
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_RECV_ATS:
     /* We requested an address and ATS suggests one:
     * set primary address and send SYN_ACK message*/
     set_primary_address (n,
                          address,
                          session,
                          blc_ctx->bandwidth_in,
                          blc_ctx->bandwidth_out);
     /* Send an ACK message as a response to the SYN msg */
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SYN_RECV_ACK,
                            GNUNET_TIME_relative_to_absolute (
                              SETUP_CONNECTION_TIMEOUT));
     send_syn_ack_message (&n->primary_address,
                           n->connect_ack_timestamp);
     if ((ACK_SEND_SYN_ACK == n->ack_state) ||
         (ACK_UNDEFINED == n->ack_state))
       n->ack_state = ACK_SEND_ACK;
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_RECV_ACK:
     /* ATS asks us to switch while we were trying to connect; switch to new
        address and check blacklist again */
     if ((ACK_SEND_SYN_ACK == n->ack_state))
     {
       n->ack_state = ACK_SEND_ACK;
       send_syn_ack_message (&n->primary_address,
                             n->connect_ack_timestamp);
     }
     set_primary_address (n,
                          address,
                          session,
                          blc_ctx->bandwidth_in,
                          blc_ctx->bandwidth_out);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SYN_RECV_ACK,
                            GNUNET_TIME_relative_to_absolute (
                              SETUP_CONNECTION_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_CONNECTED:
     GNUNET_assert (NULL != n->primary_address.address);
     GNUNET_assert (NULL != n->primary_address.session);
     GNUNET_break (n->primary_address.session != session);
     /* ATS asks us to switch a life connection; see if we can get
        a SYN_ACK on it before we actually do this! */
     set_alternative_address (n,
                              address,
                              session,
                              blc_ctx->bandwidth_in,
                              blc_ctx->bandwidth_out);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT,
                            GNUNET_TIME_relative_to_absolute (
                              SETUP_CONNECTION_TIMEOUT));
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop ("# Attempts to switch addresses"),
                               1,
                               GNUNET_NO);
     send_syn (&n->alternative_address);
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     set_primary_address (n,
                          address,
                          session,
                          blc_ctx->bandwidth_in,
                          blc_ctx->bandwidth_out);
     if (ACK_SEND_SYN_ACK == n->ack_state)
     {
       /* Send pending SYN_ACK message */
       n->ack_state = ACK_SEND_ACK;
       send_syn_ack_message (&n->primary_address,
                             n->connect_ack_timestamp);
     }
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_RECONNECT_SENT,
                            GNUNET_TIME_relative_to_absolute (
                              FAST_RECONNECT_TIMEOUT));
     send_syn (&n->primary_address);
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     /* ATS asks us to switch while we were trying to reconnect; switch to new
        address and send SYN again */
     set_primary_address (n,
                          address,
                          session,
                          blc_ctx->bandwidth_in,
                          blc_ctx->bandwidth_out);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_RECONNECT_SENT,
                            GNUNET_TIME_relative_to_absolute (
                              FAST_RECONNECT_TIMEOUT));
     send_syn (&n->primary_address);
     break;
  
   case GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT:
     if ((0 == GNUNET_HELLO_address_cmp (n->primary_address.address,
                                         address)) &&
         (n->primary_address.session == session))
     {
       /* ATS switches back to still-active session */
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "ATS double-switched, cleaning up alternative address\n");
       free_address (&n->alternative_address);
       set_state_and_timeout (n,
                              GNUNET_TRANSPORT_PS_CONNECTED,
                              n->timeout);
       break;
     }
     /* ATS asks us to switch a life connection, send */
     set_alternative_address (n,
                              address,
                              session,
                              blc_ctx->bandwidth_in,
                              blc_ctx->bandwidth_out);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT,
                            GNUNET_TIME_relative_to_absolute (
                              SETUP_CONNECTION_TIMEOUT));
     send_syn (&n->alternative_address);
     break;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT:
     /* not going to switch addresses while disconnecting */
     GNUNET_STATISTICS_update (GST_stats,
                               "# ATS suggestion ignored (disconnecting)",
                               1,
                               GNUNET_NO);
     return;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     GNUNET_assert (0);
     break;
  
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unhandled state `%s'\n",
                 GNUNET_TRANSPORT_ps2s (n->state));
     GNUNET_break (0);
     break;
   }
 cleanup:
   GNUNET_CONTAINER_DLL_remove (pending_bc_head,
                                pending_bc_tail,
                                blc_ctx);
   GNUNET_free (blc_ctx);
 }

Referenced by GST_neighbours_switch_to_address().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GST_neighbours_switch_to_address()

void GST_neighbours_switch_to_address	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_in,
		struct GNUNET_BANDWIDTH_Value32NBO	bandwidth_out
	)

For the given peer, switch to this address.

For an existing neighbour record, set the active connection to use the given address.

Before accepting this addresses and actively using it, a blacklist check is performed.

If any check fails or the suggestion can somehow not be followed, we MUST call GST_ats_block_address() to tell ATS that the suggestion could not be satisfied and force ATS to do something else.

Parameters

address	address of the other peer,
session	session to use or NULL if transport should initiate a session
bandwidth_in	inbound quota to be used when connection is up, 0 to disconnect from peer
bandwidth_out	outbound quota to be used when connection is up, 0 to disconnect from peer

Definition at line 2834 of file gnunet-service-transport_neighbours.c.

 {
   struct GST_BlacklistCheck *blc;
   struct BlacklistCheckSwitchContext *blc_ctx;
  
   GNUNET_assert (NULL != address->transport_name);
   if (GNUNET_OK ==
       try_run_fast_ats_update (address,
                                session,
                                bandwidth_in,
                                bandwidth_out))
     return;
  
   /* Check if plugin is available */
   if (NULL == (GST_plugins_find (address->transport_name)))
   {
     /* we don't have the plugin for this address */
     GNUNET_break (0);
     GST_ats_block_address (address,
                            session);
     return;
   }
   if ((NULL == session) &&
       (GNUNET_HELLO_address_check_option (address,
                                           GNUNET_HELLO_ADDRESS_INFO_INBOUND)))
   {
     /* This is a inbound address and we do not have a session to use! */
     GNUNET_break (0);
     GST_ats_block_address (address,
                            session);
     return;
   }
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "ATS suggests address '%s' for peer `%s' at %u/%u speed\n",
               GST_plugins_a2s (address),
               GNUNET_i2s (&address->peer),
               (unsigned int) ntohl (bandwidth_in.value__),
               (unsigned int) ntohl (bandwidth_out.value__));
  
   /* Perform blacklist check */
   blc_ctx = GNUNET_new (struct BlacklistCheckSwitchContext);
   blc_ctx->bandwidth_in = bandwidth_in;
   blc_ctx->bandwidth_out = bandwidth_out;
   GNUNET_CONTAINER_DLL_insert (pending_bc_head,
                                pending_bc_tail,
                                blc_ctx);
   if (NULL != (blc = GST_blacklist_test_allowed (&address->peer,
                                                  address->transport_name,
                                                  &switch_address_bl_check_cont,
                                                  blc_ctx,
                                                  address,
                                                  session)))
   {
     blc_ctx->blc = blc;
   }
 }

References address, BlacklistCheckSwitchContext::bandwidth_in, BlacklistCheckSwitchContext::bandwidth_out, BlacklistCheckSwitchContext::blc, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_OK, GST_ats_block_address(), GST_blacklist_test_allowed(), GST_plugins_a2s(), GST_plugins_find(), pending_bc_head, pending_bc_tail, switch_address_bl_check_cont(), try_run_fast_ats_update(), and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by ats_request_address_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_utilization_data()

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

static

Function called to send network utilization data to ATS for each active connection.

Parameters

cls	NULL
key	peer we send utilization data for
value	the `struct NeighbourMapEntry *` with data to send

Returns: GNUNET_OK (continue to iterate)

Definition at line 2908 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n = value;
   uint32_t bps_in;
   uint32_t bps_out;
   struct GNUNET_TIME_Relative delta;
  
   (void) cls;
   if ((GNUNET_YES != test_connected (n)) ||
       (NULL == n->primary_address.address))
     return GNUNET_OK;
   delta = GNUNET_TIME_absolute_get_difference (n->last_util_transmission,
                                                GNUNET_TIME_absolute_get ());
   bps_in = 0;
   if ((0 != n->util_total_bytes_recv) && (0 != delta.rel_value_us))
     bps_in = (1000LL * 1000LL * n->util_total_bytes_recv)
              / (delta.rel_value_us);
   bps_out = 0;
   if ((0 != n->util_total_bytes_sent) && (0 != delta.rel_value_us))
     bps_out = (1000LL * 1000LL * n->util_total_bytes_sent) / delta.rel_value_us;
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "`%s' total: received %u Bytes/s, sent %u Bytes/s\n",
               GNUNET_i2s (key),
               bps_in,
               bps_out);
   GST_ats_update_utilization (n->primary_address.address,
                               bps_in,
                               bps_out);
   n->util_total_bytes_recv = 0;
   n->util_total_bytes_sent = 0;
   n->last_util_transmission = GNUNET_TIME_absolute_get ();
   return GNUNET_OK;
 }

References NeighbourAddress::address, delta, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_YES, GST_ats_update_utilization(), key, NeighbourMapEntry::last_util_transmission, NeighbourMapEntry::primary_address, GNUNET_TIME_Relative::rel_value_us, test_connected(), NeighbourMapEntry::util_total_bytes_recv, NeighbourMapEntry::util_total_bytes_sent, and value.

Referenced by utilization_transmission().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ utilization_transmission()

static void utilization_transmission ( void * cls )

static

Task transmitting utilization in a regular interval.

Parameters

cls	the `struct NeighbourMapEntry` for which we are running

Definition at line 2952 of file gnunet-service-transport_neighbours.c.

 {
   (void) cls;
   util_transmission_tk = NULL;
   GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                          &send_utilization_data,
                                          NULL);
   util_transmission_tk
     = GNUNET_SCHEDULER_add_delayed (UTIL_TRANSMISSION_INTERVAL,
                                     &utilization_transmission,
                                     NULL);
 }

References GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_SCHEDULER_add_delayed(), neighbours, send_utilization_data(), UTIL_TRANSMISSION_INTERVAL, and util_transmission_tk.

Referenced by GST_neighbours_start().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GST_neighbours_notify_data_recv()

void GST_neighbours_notify_data_recv	(	const struct GNUNET_HELLO_Address *	address,
		const struct GNUNET_MessageHeader *	message
	)

Track information about data we received from the given address (used to notify ATS about our utilization of allocated resources).

Parameters

address	the address we got data from
message	the message we received (really only the size is used)

Definition at line 2975 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
  
   n = lookup_neighbour (&address->peer);
   if (NULL == n)
     return;
   n->util_total_bytes_recv += ntohs (message->size);
 }

References address, lookup_neighbour(), GNUNET_MessageHeader::size, and NeighbourMapEntry::util_total_bytes_recv.

Here is the call graph for this function:

◆ GST_neighbours_notify_data_sent()

void GST_neighbours_notify_data_sent	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		size_t	size
	)

Track information about data we transmitted using the given address and session (used to notify ATS about our utilization of allocated resources).

Parameters

address	the address we transmitted data to
session	session we used to transmit data
message	the message we sent (really only the size is used)

Definition at line 2997 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
  
   n = lookup_neighbour (&address->peer);
   if (NULL == n)
     return;
   if (n->primary_address.session != session)
     return;
   n->util_total_bytes_sent += size;
 }

References address, lookup_neighbour(), NeighbourMapEntry::primary_address, NeighbourAddress::session, size, and NeighbourMapEntry::util_total_bytes_sent.

Referenced by GST_validation_handle_ping(), multicast_pong(), send_syn(), and transmit_ping_if_allowed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_session_ack_message()

static void send_session_ack_message ( struct NeighbourMapEntry * n )

static

Send a ACK message to the neighbour to confirm that we got its SYN_ACK.

Parameters

n	neighbour to send the ACK to

Definition at line 3177 of file gnunet-service-transport_neighbours.c.

 {
   struct GNUNET_MessageHeader msg;
  
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Sending ACK message to peer `%s'\n",
               GNUNET_i2s (&n->id));
  
   msg.size = htons (sizeof(struct GNUNET_MessageHeader));
   msg.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_ACK);
   (void) send_with_session (n,
                             &msg,
                             sizeof(struct GNUNET_MessageHeader),
                             UINT32_MAX,
                             GNUNET_TIME_UNIT_FOREVER_REL,
                             GNUNET_NO,
                             NULL, NULL);
 }

References GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_ACK, GNUNET_NO, GNUNET_TIME_UNIT_FOREVER_REL, NeighbourMapEntry::id, msg, send_with_session(), GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by GST_neighbours_handle_session_syn_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GST_neighbours_handle_session_syn_ack()

int GST_neighbours_handle_session_syn_ack	(	const struct GNUNET_MessageHeader *	message,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session
	)

We received a 'SESSION_SYN_ACK' message from the other peer.

We received a 'SESSION_CONNECT_ACK' message from the other peer.

Consider switching to it.

Parameters

message	possibly a `struct GNUNET_ATS_SessionConnectMessage` (check format)
peer	identity of the peer to switch the address for
address	address of the other peer, NULL if other peer connected to us
session	session to use (or NULL)

Returns: GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

Definition at line 3209 of file gnunet-service-transport_neighbours.c.

 {
   const struct TransportSynMessage *scm;
   struct GNUNET_TIME_Absolute ts;
   struct NeighbourMapEntry *n;
  
   (void) session;
   if (ntohs (message->size) != sizeof(struct TransportSynMessage))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
   GNUNET_STATISTICS_update (GST_stats,
                             gettext_noop
                               ("# SYN_ACK messages received"),
                             1, GNUNET_NO);
   scm = (const struct TransportSynMessage *) message;
   GNUNET_break_op (ntohl (scm->reserved) == 0);
   if (NULL == (n = lookup_neighbour (&address->peer)))
   {
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop
                                 ("# unexpected SYN_ACK messages (no peer)"),
                               1, GNUNET_NO);
     return GNUNET_SYSERR;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received SYN_ACK message from peer `%s' in state %s/%s\n",
               GNUNET_i2s (&address->peer),
               GNUNET_TRANSPORT_ps2s (n->state),
               print_ack_state (n->ack_state));
   ts = GNUNET_TIME_absolute_ntoh (scm->timestamp);
   switch (n->state)
   {
   case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     GNUNET_break (0);
     free_neighbour (n);
     return GNUNET_SYSERR;
  
   case GNUNET_TRANSPORT_PS_INIT_ATS:
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# unexpected SYN_ACK messages (not ready)"),
                               1,
                               GNUNET_NO);
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_SENT:
     if (ts.abs_value_us != n->primary_address.connect_timestamp.abs_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "SYN_ACK ignored as the timestamp does not match our SYN request\n");
       return GNUNET_OK;
     }
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_CONNECTED,
                            GNUNET_TIME_relative_to_absolute (
                              GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
     set_primary_address (n,
                          n->primary_address.address,
                          n->primary_address.session,
                          n->primary_address.bandwidth_in,
                          n->primary_address.bandwidth_out);
     send_session_ack_message (n);
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_RECV_ATS:
   case GNUNET_TRANSPORT_PS_SYN_RECV_ACK:
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# unexpected SYN_ACK messages (not ready)"),
                               1,
                               GNUNET_NO);
     break;
  
   case GNUNET_TRANSPORT_PS_CONNECTED:
     /* duplicate SYN_ACK, let's answer by duplicate ACK just in case */
     send_session_ack_message (n);
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     /* we didn't expect any SYN_ACK, as we are waiting for ATS
        to give us a new address... */
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# unexpected SYN_ACK messages (waiting on ATS)"),
                               1,
                               GNUNET_NO);
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     /* Reconnecting with new address address worked; go back to connected! */
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_CONNECTED,
                            GNUNET_TIME_relative_to_absolute (
                              GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
     send_session_ack_message (n);
     break;
  
   case GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT:
     /* new address worked; adopt it and go back to connected! */
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_CONNECTED,
                            GNUNET_TIME_relative_to_absolute (
                              GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
     GNUNET_break (GNUNET_NO == n->alternative_address.ats_active);
  
     /* Set primary addresses */
     set_primary_address (n,
                          n->alternative_address.address,
                          n->alternative_address.session,
                          n->alternative_address.bandwidth_in,
                          n->alternative_address.bandwidth_out);
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop (
                                 "# Successful attempts to switch addresses"),
                               1,
                               GNUNET_NO);
  
     GNUNET_HELLO_address_free (n->alternative_address.address);
     memset (&n->alternative_address,
             0,
             sizeof(n->alternative_address));
     send_session_ack_message (n);
     break;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT:
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop
                                 ("# unexpected SYN_ACK messages (disconnecting)"),
                               1, GNUNET_NO);
     return GNUNET_SYSERR;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     GNUNET_assert (0);
     break;
  
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unhandled state `%s'\n",
                 GNUNET_TRANSPORT_ps2s (n->state));
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
   return GNUNET_OK;
 }

Here is the call graph for this function:

◆ GST_neighbours_session_terminated()

int GST_neighbours_session_terminated	(	const struct GNUNET_PeerIdentity *	peer,
		struct GNUNET_ATS_Session *	session
	)

A session was terminated.

Take note; if needed, try to get an alternative address from ATS.

Parameters

peer	identity of the peer where the session died
session	session that is gone

Returns: GNUNET_YES if this was a session used, GNUNET_NO if this session was not in use

Definition at line 3371 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
  
   if (NULL == (n = lookup_neighbour (peer)))
     return GNUNET_NO; /* can't affect us */
   if (session != n->primary_address.session)
   {
     /* Free alternative address */
     if (session == n->alternative_address.session)
     {
       if (GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT == n->state)
         set_state_and_timeout (n,
                                GNUNET_TRANSPORT_PS_CONNECTED,
                                n->timeout);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Session died, cleaning up alternative address\n");
       free_address (&n->alternative_address);
     }
     return GNUNET_NO;   /* doesn't affect us further */
   }
  
   n->expect_latency_response = GNUNET_NO;
   /* The session for neighbour's primary address died */
   switch (n->state)
   {
   case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     GNUNET_break (0);
     free_neighbour (n);
     return GNUNET_YES;
  
   case GNUNET_TRANSPORT_PS_INIT_ATS:
     GNUNET_break (0);
     free_neighbour (n);
     return GNUNET_YES;
  
   case GNUNET_TRANSPORT_PS_SYN_SENT:
     /* The session used to send the SYN terminated:
      * this implies a connect error*/
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "Failed to send SYN in CONNECT_SENT with `%s' %p: session terminated\n",
                 GST_plugins_a2s (n->primary_address.address),
                 n->primary_address.session);
  
     /* Destroy the address since it cannot be used */
     unset_primary_address (n);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_INIT_ATS,
                            GNUNET_TIME_relative_to_absolute (
                              ATS_RESPONSE_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_SYN_RECV_ATS:
   case GNUNET_TRANSPORT_PS_SYN_RECV_ACK:
     /* error on inbound session; free neighbour entirely */
     free_neighbour (n);
     return GNUNET_YES;
  
   case GNUNET_TRANSPORT_PS_CONNECTED:
     /* Our primary connection died, try a fast reconnect */
     unset_primary_address (n);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_RECONNECT_ATS,
                            GNUNET_TIME_relative_to_absolute (
                              ATS_RESPONSE_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     /* we don't have an address, how can it go down? */
     GNUNET_break (0);
     break;
  
   case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "Failed to send SYN in RECONNECT_SENT with `%s' %p: session terminated\n",
                 GST_plugins_a2s (n->primary_address.address),
                 n->primary_address.session);
     /* Destroy the address since it cannot be used */
     unset_primary_address (n);
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_RECONNECT_ATS,
                            GNUNET_TIME_relative_to_absolute (
                              ATS_RESPONSE_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT:
     /* primary went down while we were waiting for SYN_ACK on secondary;
        secondary as primary */
  
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Connection `%s' %p to peer `%s' was terminated while switching, "
                 "switching to alternative address `%s' %p\n",
                 GST_plugins_a2s (n->primary_address.address),
                 n->primary_address.session,
                 GNUNET_i2s (peer),
                 GST_plugins_a2s (n->alternative_address.address),
                 n->alternative_address.session);
  
     /* Destroy the inbound address since it cannot be used */
     free_address (&n->primary_address);
     n->primary_address = n->alternative_address;
     GNUNET_assert (GNUNET_YES ==
                    GST_ats_is_known (n->primary_address.address,
                                      n->primary_address.session));
     memset (&n->alternative_address,
             0,
             sizeof(struct NeighbourAddress));
     set_state_and_timeout (n,
                            GNUNET_TRANSPORT_PS_RECONNECT_SENT,
                            GNUNET_TIME_relative_to_absolute (
                              FAST_RECONNECT_TIMEOUT));
     break;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT:
     unset_primary_address (n);
     break;
  
   case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     /* neighbour was freed and plugins told to terminate session */
     return GNUNET_NO;
  
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unhandled state `%s'\n",
                 GNUNET_TRANSPORT_ps2s (n->state));
     GNUNET_break (0);
     break;
   }
   if (NULL != n->task)
     GNUNET_SCHEDULER_cancel (n->task);
   n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
   return GNUNET_YES;
 }

Referenced by plugin_env_session_end().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GST_neighbours_handle_session_ack()

int GST_neighbours_handle_session_ack	(	const struct GNUNET_MessageHeader *	message,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session
	)

We received a 'ACK' message from the other peer.

We received a 'SESSION_ACK' message from the other peer.

If we sent a 'SYN_ACK' last, this means we are now connected. Otherwise, do nothing.

Parameters

message	possibly a 'struct GNUNET_ATS_SessionConnectMessage' (check format)
address	address of the other peer
session	session to use (or NULL)

Returns: GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

Definition at line 3518 of file gnunet-service-transport_neighbours.c.

 {
   struct NeighbourMapEntry *n;
  
   (void) session;
   if (ntohs (message->size) != sizeof(struct GNUNET_MessageHeader))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
   GNUNET_STATISTICS_update (GST_stats,
                             gettext_noop ("# ACK messages received"),
                             1,
                             GNUNET_NO);
   if (NULL == (n = lookup_neighbour (&address->peer)))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received ACK for peer `%s' in state %s/%s\n",
               GNUNET_i2s (&address->peer),
               GNUNET_TRANSPORT_ps2s (n->state),
               print_ack_state (n->ack_state));
  
   /* Check if we are in a plausible state for having sent
      a SYN_ACK.  If not, return, otherwise break.
  
      The remote peers sends a ACK as a response for a SYN_ACK
      message.
  
      We expect a ACK:
      - If a remote peer has sent a SYN, we responded with a SYN_ACK and
      now wait for the ACK to finally be connected
      - If we sent a SYN_ACK to this peer before */if (((GNUNET_TRANSPORT_PS_SYN_RECV_ACK != n->state) &&
        (ACK_SEND_ACK != n->ack_state)) ||
       (NULL == n->primary_address.address))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "Received unexpected ACK message from peer `%s' in state %s/%s\n",
                 GNUNET_i2s (&address->peer),
                 GNUNET_TRANSPORT_ps2s (n->state),
                 print_ack_state (n->ack_state));
  
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop ("# unexpected ACK messages"),
                               1,
                               GNUNET_NO);
     return GNUNET_OK;
   }
   if (GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT == n->state)
   {
     /* We tried to switch addresses while being connect. We explicitly wait
      * for a SYN_ACK before going to GNUNET_TRANSPORT_PS_CONNECTED,
      * so we do not want to set the address as in use! */
     return GNUNET_OK;
   }
   set_state_and_timeout (n,
                          GNUNET_TRANSPORT_PS_CONNECTED,
                          GNUNET_TIME_relative_to_absolute (
                            GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
  
   if (NULL == n->primary_address.address)
   {
     /* See issue #3693.
      * We are in state = PSY_SYN_RECV_ACK or ack_state = ACK_SEND_ACK, which
      * really means we did try (and succeed) to send a SYN and are waiting for
      * an ACK.
      * That suggests that the primary_address used to be non-NULL, but maybe it
      * got reset to NULL without the state being changed appropriately?
      */GNUNET_break (0);
     return GNUNET_OK;
   }
  
   /* Reset backoff for primary address */
   GST_ats_block_reset (n->primary_address.address,
                        n->primary_address.session);
   return GNUNET_OK;
 }

References ACK_SEND_ACK, NeighbourMapEntry::ack_state, address, NeighbourAddress::address, gettext_noop, GNUNET_break, GNUNET_break_op, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_ps2s(), GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT, GNUNET_TRANSPORT_PS_SYN_RECV_ACK, GST_ats_block_reset(), GST_stats, lookup_neighbour(), NeighbourMapEntry::primary_address, print_ack_state(), NeighbourAddress::session, set_state_and_timeout(), GNUNET_MessageHeader::size, and NeighbourMapEntry::state.

Here is the call graph for this function:

◆ GST_neighbours_test_connected()

int GST_neighbours_test_connected ( const struct GNUNET_PeerIdentity * target )

Test if we're connected to the given peer.

Parameters

target peer to test

Returns: GNUNET_YES if we are connected, GNUNET_NO if not

Definition at line 3608 of file gnunet-service-transport_neighbours.c.

 {
   return test_connected (lookup_neighbour (target));
 }

References lookup_neighbour(), and test_connected().

Referenced by handle_client_send(), notify_client_about_neighbour(), send_delayed(), and transmit_our_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ IGNORE_INBOUND_QUOTA

◆ NEIGHBOUR_TABLE_SIZE

◆ DISCONNECT_SENT_TIMEOUT

◆ QUOTA_VIOLATION_DROP_THRESHOLD

◆ ATS_RESPONSE_TIMEOUT

◆ SETUP_CONNECTION_TIMEOUT

◆ FAST_RECONNECT_TIMEOUT

◆ UTIL_TRANSMISSION_INTERVAL

Enumeration Type Documentation

◆ GST_ACK_State

Function Documentation

◆ print_ack_state()

◆ send_outbound_quota_to_clients()

◆ neighbours_connect_notification()

◆ neighbours_disconnect_notification()

◆ neighbours_changed_notification()

◆ lookup_neighbour()

◆ test_connected()

◆ free_address()

◆ master_task()

◆ set_state_and_timeout()

◆ set_alternative_address()

◆ send_with_session()

◆ unset_primary_address()

◆ free_neighbour()

◆ send_disconnect_cont()

◆ send_disconnect()

◆ disconnect_neighbour()

◆ set_incoming_quota()

◆ set_primary_address()

◆ transmit_send_continuation()

◆ try_transmission_to_peer()

◆ send_keepalive()

◆ GST_neighbours_keepalive()

◆ GST_neighbours_keepalive_response()

◆ GST_neighbours_calculate_receive_delay()

◆ GST_neighbours_send()

◆ send_session_syn_cont()

◆ send_syn()

◆ send_session_syn_ack_cont()

◆ send_syn_ack_message()

◆ inbound_bw_tracker_update()

◆ setup_neighbour()

◆ GST_neighbours_handle_session_syn()

◆ try_run_fast_ats_update()

◆ switch_address_bl_check_cont()

◆ GST_neighbours_switch_to_address()

◆ send_utilization_data()

◆ utilization_transmission()

◆ GST_neighbours_notify_data_recv()

◆ GST_neighbours_notify_data_sent()

◆ send_session_ack_message()

◆ GST_neighbours_handle_session_syn_ack()

◆ GST_neighbours_session_terminated()

◆ GST_neighbours_handle_session_ack()

◆ GST_neighbours_test_connected()