GNUnet  0.10.x
Data Structures | Macros | Enumerations | Functions | Variables
gnunet-service-transport_neighbours.c File Reference

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:

Go to the source code of this file.

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   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500)
 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   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
 How long are we willing to wait for a response from ATS before timing out? More...
 
#define SETUP_CONNECTION_TIMEOUT   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? 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 NeighbourMapEntrylookup_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 NeighbourMapEntrysetup_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_AddressGST_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_MultiPeerMapneighbours
 Hash map from peer identities to the respective struct NeighbourMapEntry. More...
 
static struct BlacklistCheckSwitchContextpending_bc_head
 List of pending blacklist checks: head. More...
 
static struct BlacklistCheckSwitchContextpending_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_Taskutil_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.

Referenced by GST_neighbours_start().

◆ DISCONNECT_SENT_TIMEOUT

#define DISCONNECT_SENT_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500)

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.

Referenced by disconnect_neighbour().

◆ 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 59 of file gnunet-service-transport_neighbours.c.

Referenced by GST_neighbours_calculate_receive_delay().

◆ ATS_RESPONSE_TIMEOUT

#define ATS_RESPONSE_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

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

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

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

◆ SETUP_CONNECTION_TIMEOUT

#define SETUP_CONNECTION_TIMEOUT   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 70 of file gnunet-service-transport_neighbours.c.

Referenced by master_task(), send_syn(), and switch_address_bl_check_cont().

◆ 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 78 of file gnunet-service-transport_neighbours.c.

Referenced by GST_neighbours_session_terminated(), send_session_syn_cont(), send_syn(), and switch_address_bl_check_cont().

◆ UTIL_TRANSMISSION_INTERVAL

#define UTIL_TRANSMISSION_INTERVAL   GNUNET_TIME_UNIT_SECONDS

Interval to send utilization data.

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

Referenced by GST_neighbours_start(), and utilization_transmission().

Enumeration Type Documentation

◆ 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 88 of file gnunet-service-transport_neighbours.c.

89 {
93  ACK_UNDEFINED = 0,
94 
99  ACK_SEND_SYN_ACK = 1,
100 
105  ACK_SEND_ACK = 2
106 };
We did not receive a SYN message for this neighbour.
The neighbour sent a SYN_ACK message and has to send a ACK as reply.
The neighbour received a SYN message and has to send a SYN_ACK as reply.

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
sstate
Returns
corresponding human-readable string

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

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

501 {
502  switch (s) {
503  case ACK_UNDEFINED:
504  return "UNDEFINED";
505  case ACK_SEND_SYN_ACK:
506  return "SEND_SYN_ACK";
507  case ACK_SEND_ACK:
508  return "SEND_ACK";
509  default:
510  GNUNET_break (0);
511  return "N/A";
512  }
513 }
We did not receive a SYN message for this neighbour.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
The neighbour sent a SYN_ACK message and has to send a ACK as reply.
The neighbour received a SYN message and has to send a SYN_ACK as reply.
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
naffected peer

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

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

525 {
526  struct QuotaSetMessage q_msg;
527  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_min;
528 
530  return;
531 #if IGNORE_INBOUND_QUOTA
532  bandwidth_min = n->primary_address.bandwidth_out;
533 #else
536 #endif
537 
539  "Sending outbound quota of %u Bps for peer `%s' to all clients\n",
540  ntohl (bandwidth_min.value__),
541  GNUNET_i2s (&n->id));
542  q_msg.header.size = htons (sizeof (struct QuotaSetMessage));
543  q_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA);
544  q_msg.quota = bandwidth_min;
545  q_msg.peer = n->id;
546  GST_clients_broadcast (&q_msg.header,
547  GNUNET_NO);
548 }
void GST_clients_broadcast(const struct GNUNET_MessageHeader *msg, int may_drop)
Broadcast the given message to all of our clients.
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_min(struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2)
Compute the MIN of two bandwidth values.
Definition: bandwidth.c:56
#define GNUNET_NO
Definition: gnunet_common.h:81
int GNUNET_TRANSPORT_is_connected(enum GNUNET_TRANSPORT_PeerState state)
Check if a state is defined as connected.
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
Message used to set a particular bandwidth quota.
Definition: transport.h:180
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Outbound bandwidth from ATS for this address.
#define GNUNET_log(kind,...)
struct GNUNET_BANDWIDTH_Value32NBO neighbour_receive_quota
Latest quota the other peer send us in bytes per second.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA
Message telling transport to limit its receive rate.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
nthe peer that connected

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

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, ConnectInfoMessage::id, NeighbourMapEntry::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().

558 {
559  size_t len = sizeof(struct ConnectInfoMessage);
560  char buf[len] GNUNET_ALIGN;
561  struct ConnectInfoMessage *connect_msg = (struct ConnectInfoMessage *) buf;
562  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_min;
563 
564 #if IGNORE_INBOUND_QUOTA
565  bandwidth_min = n->primary_address.bandwidth_out;
566 #else
569 #endif
571  "We are now connected to peer `%s'\n",
572  GNUNET_i2s (&n->id));
573  connect_msg->header.size = htons (sizeof(buf));
574  connect_msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
575  connect_msg->id = n->id;
576  connect_msg->quota_out = bandwidth_min;
577  GST_clients_broadcast (&connect_msg->header,
578  GNUNET_NO);
579 }
struct GNUNET_PeerIdentity id
Identity of the new neighbour.
Definition: transport.h:145
void GST_clients_broadcast(const struct GNUNET_MessageHeader *msg, int may_drop)
Broadcast the given message to all of our clients.
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_min(struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2)
Compute the MIN of two bandwidth values.
Definition: bandwidth.c:56
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT.
Definition: transport.h:124
struct GNUNET_BANDWIDTH_Value32NBO quota_out
Current outbound quota for this peer.
Definition: transport.h:139
#define GNUNET_NO
Definition: gnunet_common.h:81
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
Message from TRANSPORT notifying about a client that connected to us.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
static char buf[2048]
Message from the transport service to the library informing about neighbors.
Definition: transport.h:118
struct GNUNET_PeerIdentity id
Identity of this neighbour.
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Outbound bandwidth from ATS for this address.
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's...
#define GNUNET_log(kind,...)
struct GNUNET_BANDWIDTH_Value32NBO neighbour_receive_quota
Latest quota the other peer send us in bytes per second.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
nthe peer that disconnected

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

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

590 {
592  "Peer `%s' disconnected\n",
593  GNUNET_i2s (&n->id));
596 }
void GST_manipulation_peer_disconnect(const struct GNUNET_PeerIdentity *peer)
Notify manipulation about disconnect so it can discard queued messages.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
void GST_clients_broadcast_disconnect(const struct GNUNET_PeerIdentity *peer)
Notify all clients about a disconnect, and cancel pending SEND_OK messages for this peer...
#define GNUNET_log(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
peeridentity of the peer
addressaddress possibly NULL if peer is not connected
statecurrent state this peer is in
state_timeouttimeout for the current state of the peer
bandwidth_inbandwidth assigned inbound, 0 on disconnect
bandwidth_outbandwidth assigned outbound, 0 on disconnect

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

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

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

617 {
618  (void) bandwidth_in;
619  (void) bandwidth_out;
621  "Notifying about change for peer `%s' with address `%s' in state `%s' timing out at %s\n",
622  GNUNET_i2s (peer),
623  GST_plugins_a2s (address),
626  /* FIXME: include bandwidth in notification! */
628  address,
629  state,
630  state_timeout);
631 }
void GST_clients_broadcast_peer_notification(const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout)
Broadcast the new active address to all clients monitoring the peer.
enum State state
current state of profiling
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
const char * GNUNET_TRANSPORT_ps2s(enum GNUNET_TRANSPORT_PeerState state)
Convert a transport state to a human readable string.
#define GNUNET_log(kind,...)
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:792
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
pididentity of the peer to look up
Returns
the entry, NULL if there is no existing record

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

References GNUNET_CONTAINER_multipeermap_get().

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_keepalive_response(), 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().

642 {
643  if (NULL == neighbours)
644  return NULL;
646 }
static struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Hash map from peer identities to the respective struct NeighbourMapEntry.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
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
nneighbour entry of peer to test
Returns
GNUNET_YES if we are connected, GNUNET_NO if not

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

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

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

657 {
658  if (NULL == n)
659  return GNUNET_NO;
661 }
#define GNUNET_NO
Definition: gnunet_common.h:81
int GNUNET_TRANSPORT_is_connected(enum GNUNET_TRANSPORT_PeerState state)
Check if a state is defined as connected.
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
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
naaddress we are done with; na itself must NOT be 'free'd, only the contents!

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

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, master_task(), and NeighbourAddress::session.

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

673 {
674  if (GNUNET_YES == na->ats_active)
676  GNUNET_NO);
677  if (NULL != na->address)
678  {
680  na->session);
682  na->address = NULL;
683  }
686  na->ats_active = GNUNET_NO;
687  na->keep_alive_nonce = 0;
688  na->session = NULL;
689 }
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
Inbound bandwidth from ATS for this address.
void GST_validation_set_address_use(const struct GNUNET_HELLO_Address *address, int in_use)
Update if we are using an address for a connection actively right now.
struct GNUNET_ATS_Session * session
Active session for this address.
int ats_active
Did we tell ATS that this is our 'active' address?
struct GNUNET_HELLO_Address * address
Network-level address information.
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_init(uint32_t bytes_per_second)
Create a new bandwidth value.
Definition: bandwidth.c:39
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Outbound bandwidth from ATS for this address.
#define GNUNET_YES
Definition: gnunet_common.h:80
uint32_t keep_alive_nonce
The current nonce sent in the last keep alive messages.
void GST_ats_block_address(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Temporarily block a valid address for use by ATS for address suggestions.
#define GNUNET_HELLO_address_free(addr)
Free an 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
clsthe struct NeighbourMapEntry for which we are running

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

Parameters
clsthe 'struct NeighbourMapEntry' for which we are running

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

References NeighbourMapEntry::alternative_address, ATS_RESPONSE_TIMEOUT, disconnect_neighbour(), free_address(), free_neighbour(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_ps2s(), GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TRANSPORT_PS_DISCONNECT, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TRANSPORT_PS_RECONNECT_ATS, GNUNET_TRANSPORT_PS_RECONNECT_SENT, GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT, GNUNET_TRANSPORT_PS_SYN_RECV_ACK, GNUNET_TRANSPORT_PS_SYN_RECV_ATS, GNUNET_TRANSPORT_PS_SYN_SENT, GNUNET_YES, NeighbourMapEntry::id, NeighbourMapEntry::keep_alive_time, GNUNET_TIME_Relative::rel_value_us, send_keepalive(), set_state_and_timeout(), SETUP_CONNECTION_TIMEOUT, NeighbourMapEntry::state, NeighbourMapEntry::task, NeighbourMapEntry::timeout, try_transmission_to_peer(), and unset_primary_address().

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

2942 {
2943  struct NeighbourMapEntry *n = cls;
2944  struct GNUNET_TIME_Relative delay;
2945 
2946  n->task = NULL;
2949  "Master task runs for neighbour `%s' in state %s with timeout in %s\n",
2950  GNUNET_i2s (&n->id),
2953  GNUNET_YES));
2954  switch (n->state)
2955  {
2957  /* invalid state for master task, clean up */
2958  GNUNET_break (0);
2959  free_neighbour (n);
2960  return;
2962  if (0 == delay.rel_value_us)
2963  {
2965  "Connection to `%s' timed out waiting for ATS to provide address\n",
2966  GNUNET_i2s (&n->id));
2967  free_neighbour (n);
2968  return;
2969  }
2970  break;
2972  if (0 == delay.rel_value_us)
2973  {
2975  "Connection to `%s' timed out waiting for other peer to send SYN_ACK\n",
2976  GNUNET_i2s (&n->id));
2977  /* Remove address and request and additional one */
2982  return;
2983  }
2984  break;
2986  if (0 == delay.rel_value_us)
2987  {
2989  "Connection to `%s' timed out waiting ATS to provide address to use for SYN_ACK\n",
2990  GNUNET_i2s (&n->id));
2991  free_neighbour (n);
2992  return;
2993  }
2994  break;
2996  if (0 == delay.rel_value_us)
2997  {
2999  "Connection to `%s' timed out waiting for other peer to send ACK\n",
3000  GNUNET_i2s (&n->id));
3002  return;
3003  }
3004  break;
3006  if (0 == delay.rel_value_us)
3007  {
3009  "Connection to `%s' timed out, missing KEEPALIVE_RESPONSEs\n",
3010  GNUNET_i2s (&n->id));
3012  return;
3013  }
3015  send_keepalive (n);
3016  break;
3018  if (0 == delay.rel_value_us)
3019  {
3021  "Connection to `%s' timed out, waiting for ATS replacement address\n",
3022  GNUNET_i2s (&n->id));
3024  return;
3025  }
3026  break;
3028  if (0 == delay.rel_value_us)
3029  {
3031  "Connection to `%s' timed out, waiting for other peer to SYN_ACK replacement address\n",
3032  GNUNET_i2s (&n->id));
3034  return;
3035  }
3036  break;
3038  if (0 == delay.rel_value_us)
3039  {
3041  "Switch failed, cleaning up alternative address\n");
3046  }
3048  send_keepalive (n);
3049  break;
3052  "Cleaning up connection to `%s' after sending DISCONNECT\n",
3053  GNUNET_i2s (&n->id));
3054  free_neighbour (n);
3055  return;
3057  /* how did we get here!? */
3058  GNUNET_assert (0);
3059  break;
3060  default:
3062  "Unhandled state `%s'\n",
3064  GNUNET_break (0);
3065  break;
3066  }
3070  {
3071  /* if we are *now* in one of the two states, we're sending
3072  keep alive messages, so we need to consider the keepalive
3073  delay, not just the connection timeout */
3075  delay);
3076  }
3077  if (NULL == n->task)
3079  &master_task,
3080  n);
3081 }
Connection got into trouble, rest of the system still believes it to be up, but we're getting a new a...
We have some primary connection, but ATS suggested we switch to some alternative; we now sent a SYN m...
uint64_t rel_value_us
The actual value.
Sent SYN over new address (either by ATS telling us to switch addresses or from RECONNECT_ATS); if th...
struct NeighbourAddress alternative_address
Alternative address currently under consideration for communicating with the neighbour.
We're finished with the disconnect; and are cleaning up the state now! We put the struct into this st...
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
struct GNUNET_TIME_Absolute timeout
Time where we should cut the connection (timeout) if we don't make progress in the state machine (or ...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Received a SYN, asking ATS about address suggestions.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static void free_neighbour(struct NeighbourMapEntry *n)
Free a neighbour map entry.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
Fresh peer or completely disconnected.
struct GNUNET_TIME_Absolute keep_alive_time
At what time should we sent the next keep-alive message?
#define SETUP_CONNECTION_TIMEOUT
How long are we willing to wait for an ACK from the other peer before giving up on our connect operat...
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:727
struct GNUNET_PeerIdentity id
Identity of this neighbour.
Asked to initiate connection, trying to get address from ATS.
struct GNUNET_SCHEDULER_Task * task
Main task that drives this peer (timeouts, keepalives, etc.).
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:271
const char * GNUNET_TRANSPORT_ps2s(enum GNUNET_TRANSPORT_PeerState state)
Convert a transport state to a human readable string.
Sent SYN message to other peer, waiting for SYN_ACK.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
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.
static void send_keepalive(struct NeighbourMapEntry *n)
Send keepalive message to the neighbour.
static void free_address(struct NeighbourAddress *na)
We don't need a given neighbour address any 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 monitorin...
Disconnect in progress (we're sending the DISCONNECT message to the other peer; after that is finishe...
static void disconnect_neighbour(struct NeighbourMapEntry *n)
Disconnect from the given neighbour, clean up the record.
#define ATS_RESPONSE_TIMEOUT
How long are we willing to wait for a response from ATS before timing out?
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
#define GNUNET_YES
Definition: gnunet_common.h:80
Got our SYN_ACK/ACK, connection is up.
static void master_task(void *cls)
Master task run for every neighbour.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
SYN request from other peer was SYN_ACK'ed, waiting for ACK.
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.
Time for relative time used by GNUnet, in microseconds.
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
nthe respective neighbour
sthe new state
timeoutthe new timeout

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

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_handle_session_ack(), GST_neighbours_handle_session_syn(), GST_neighbours_handle_session_syn_ack(), GST_neighbours_keepalive_response(), 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().

714 {
717  {
720  gettext_noop ("# peers connected"),
722  GNUNET_NO);
723  }
724  if ((! GNUNET_TRANSPORT_is_connected (s)) &&
726  {
728  gettext_noop ("# peers connected"),
730  GNUNET_NO);
732  }
733  n->state = s;
734  if ( (timeout.abs_value_us < n->timeout.abs_value_us) &&
735  (NULL != n->task ) )
736  {
737  /* new timeout is earlier, reschedule master task */
739  n->task = GNUNET_SCHEDULER_add_at (timeout,
740  &master_task,
741  n);
742  }
743  n->timeout = timeout;
745  "Neighbour `%s' changed state to %s with timeout %s\n",
746  GNUNET_i2s (&n->id),
751  n->state,
752  n->timeout,
755 }
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.
struct GNUNET_TIME_Absolute timeout
Time where we should cut the connection (timeout) if we don&#39;t make progress in the state machine (or ...
static void neighbours_connect_notification(struct NeighbourMapEntry *n)
Notify our clients that another peer connected to us.
#define GNUNET_NO
Definition: gnunet_common.h:81
uint64_t abs_value_us
The actual value.
int GNUNET_TRANSPORT_is_connected(enum GNUNET_TRANSPORT_PeerState state)
Check if a state is defined as connected.
static unsigned int neighbours_connected
counter for connected neighbours
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:114
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
Inbound bandwidth from ATS for this address.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
static void neighbours_disconnect_notification(struct NeighbourMapEntry *n)
Notify our clients (and manipulation) that a peer disconnected from us.
struct GNUNET_SCHEDULER_Task * task
Main task that drives this peer (timeouts, keepalives, etc.).
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
const char * GNUNET_TRANSPORT_ps2s(enum GNUNET_TRANSPORT_PeerState state)
Convert a transport state to a human readable string.
struct GNUNET_HELLO_Address * address
Network-level address information.
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Outbound bandwidth from ATS for this address.
#define GNUNET_log(kind,...)
static void master_task(void *cls)
Master task run for every neighbour.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:792
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run at the specified time.
Definition: scheduler.c:1223
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
nthe neighbour
addressaddress of the other peer, NULL if other peer connected to us
sessionsession to use (or NULL, in which case an address must be setup)
bandwidth_ininbound quota to be used when connection is up
bandwidth_outoutbound quota to be used when connection is up

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

References 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, GNUNET_HELLO_Address::peer, NeighbourAddress::session, and GNUNET_HELLO_Address::transport_name.

Referenced by switch_address_bl_check_cont().

775 {
777 
778  if (NULL == (papi = GST_plugins_find (address->transport_name)))
779  {
780  GNUNET_break (0);
781  return;
782  }
783  if (session == n->alternative_address.session)
784  {
785  n->alternative_address.bandwidth_in = bandwidth_in;
786  n->alternative_address.bandwidth_out = bandwidth_out;
787  return;
788  }
789  if (NULL != n->alternative_address.address)
790  {
792  "Replacing existing alternative address with another one\n");
794  }
795  if (NULL == session)
796  session = papi->get_session (papi->cls,
797  address);
798  if (NULL == session)
799  {
801  "Failed to obtain new session for peer `%s' and address '%s'\n",
802  GNUNET_i2s (&address->peer),
803  GST_plugins_a2s (address));
805  gettext_noop ("# session creation failed"),
806  1,
807  GNUNET_NO);
808  return;
809  }
810  GST_ats_new_session (address,
811  session);
813  "Neighbour `%s' configured alternative address %s\n",
814  GNUNET_i2s (&n->id),
815  GST_plugins_a2s(address));
816 
818  n->alternative_address.bandwidth_in = bandwidth_in;
819  n->alternative_address.bandwidth_out = bandwidth_out;
820  n->alternative_address.session = session;
826 }
GNUNET_TRANSPORT_CreateSession get_session
Function that will be called tell the plugin to create a session object.
int GST_ats_is_known(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Test if ATS knows about this address and session.
struct NeighbourAddress alternative_address
Alternative address currently under consideration for communicating with the neighbour.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
#define GNUNET_NO
Definition: gnunet_common.h:81
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
void * cls
Closure for all of the callbacks.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
Inbound bandwidth from ATS for this address.
const char * transport_name
Name of the transport plugin enabling the communication using this address.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_ATS_Session * session
Active session for this address.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
struct GNUNET_TRANSPORT_PluginFunctions * GST_plugins_find(const char *name)
Obtain the plugin API based on a plugin name.
int ats_active
Did we tell ATS that this is our &#39;active&#39; address?
struct GNUNET_HELLO_Address * address
Network-level address information.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Outbound bandwidth from ATS for this address.
static void free_address(struct NeighbourAddress *na)
We don&#39;t need a given neighbour address any more.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
uint32_t keep_alive_nonce
The current nonce sent in the last keep alive messages.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GST_ats_new_session(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Notify ATS about a new session now existing for the given address.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
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
nentry for the recipient
msgbufbuffer to transmit
msgbuf_sizenumber of bytes in msgbuf buffer
prioritytransmission priority
timeouttransmission timeout
use_keepalive_timeoutGNUNET_YES to use plugin-specific keep-alive timeout (timeout is ignored in that case), GNUNET_NO otherwise
contcontinuation to call when finished (can be NULL)
cont_clsclosure for cont
Returns
timeout (copy of timeout or a calculated one if use_keepalive_timeout is GNUNET_YES.

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

References GNUNET_TRANSPORT_PluginFunctions::cls, GNUNET_assert, GNUNET_break, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_NO, GNUNET_SYSERR, GNUNET_TIME_relative_divide(), GNUNET_TIME_UNIT_FOREVER_REL, GST_neighbours_notify_data_sent(), GST_plugins_find(), GNUNET_TRANSPORT_PluginFunctions::query_keepalive_factor, result, and GNUNET_TRANSPORT_PluginFunctions::send.

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

854 {
857 
859  if ( ((NULL == (papi = GST_plugins_find (n->primary_address.address->transport_name)) ||
860  (-1 == papi->send (papi->cls,
862  msgbuf,
863  msgbuf_size,
864  priority,
865  (result = (GNUNET_NO == use_keepalive_timeout) ? timeout :
867  papi->query_keepalive_factor (papi->cls))),
868  cont,
869  cont_cls)))) &&
870  (NULL != cont))
871  cont (cont_cls,
872  &n->id,
874  msgbuf_size,
875  0);
878  msgbuf_size);
879  GNUNET_break (NULL != papi);
880  return result;
881 }
GNUNET_TRANSPORT_TransmitFunction send
Function that the transport service will use to transmit data to another peer.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * cls
Closure for all of the callbacks.
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
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 a...
const char * transport_name
Name of the transport plugin enabling the communication using this address.
static int result
Global testing status.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_ATS_Session * session
Active session for this address.
struct GNUNET_TRANSPORT_PluginFunctions * GST_plugins_find(const char *name)
Obtain the plugin API based on a plugin name.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_HELLO_Address * address
Network-level address information.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don&#39;t receive messages from the peer...
GNUNET_TRANSPORT_QueryKeepaliveFactorFunction query_keepalive_factor
Function that is used to query keepalive factor.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Divide relative time by a given factor.
Definition: time.c:525
Time for relative time used by GNUnet, in microseconds.
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
nthe neighbour

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

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

892 {
893  /* Notify monitoring about change */
894  if (NULL == n->primary_address.address)
895  return;
897  "Disabling primary address\n");
900  n->state,
901  n->timeout,
905 }
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.
struct GNUNET_TIME_Absolute timeout
Time where we should cut the connection (timeout) if we don&#39;t make progress in the state machine (or ...
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_HELLO_Address * address
Network-level address information.
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_init(uint32_t bytes_per_second)
Create a new bandwidth value.
Definition: bandwidth.c:39
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
static void free_address(struct NeighbourAddress *na)
We don&#39;t need a given neighbour address any more.
#define GNUNET_log(kind,...)
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
nentry to free

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

References NeighbourAddress::address, NeighbourMapEntry::alternative_address, MessageQueue::cont, MessageQueue::cont_cls, NeighbourMapEntry::delayed_disconnect_task, free_address(), GNUNET_assert, GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED, GNUNET_YES, NeighbourMapEntry::id, NeighbourMapEntry::is_active, MessageQueue::message_buf_size, NeighbourMapEntry::messages_head, NeighbourMapEntry::messages_tail, mq, set_state_and_timeout(), NeighbourMapEntry::suggest_handle, NeighbourMapEntry::task, and unset_primary_address().

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

915 {
916  struct MessageQueue *mq;
917 
919  "Freeing neighbour state of peer `%s'\n",
920  GNUNET_i2s (&n->id));
921  n->is_active = NULL; /* always free'd by its own continuation! */
922 
923  /* fail messages currently in the queue */
924  while (NULL != (mq = n->messages_head))
925  {
927  n->messages_tail,
928  mq);
929  if (NULL != mq->cont)
930  mq->cont (mq->cont_cls,
932  mq->message_buf_size,
933  0);
934  GNUNET_free (mq);
935  }
936  /* Mark peer as disconnected */
940  /* free addresses and mark as unused */
942 
943  if (NULL != n->alternative_address.address)
944  {
946  "Cleaning up alternative address\n");
948  }
951  &n->id,
952  n));
953 
954  /* Cancel address requests for this peer */
955  if (NULL != n->suggest_handle)
956  {
958  n->suggest_handle = NULL;
959  }
960 
961  /* Cancel the disconnect task */
962  if (NULL != n->delayed_disconnect_task)
963  {
965  n->delayed_disconnect_task = NULL;
966  }
967 
968  /* Cancel the master task */
969  if (NULL != n->task)
970  {
972  n->task = NULL;
973  }
974  /* free rest of memory */
975  GNUNET_free (n);
976 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Hash map from peer identities to the respective struct NeighbourMapEntry.
struct NeighbourAddress alternative_address
Alternative address currently under consideration for communicating with the neighbour.
We&#39;re finished with the disconnect; and are cleaning up the state now! We put the struct into this st...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
void GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
We no longer care about being connected to a peer.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
struct MessageQueue * messages_tail
Tail of list of messages we would like to send to this peer; must contain at most one message per cli...
struct GNUNET_ATS_ConnectivitySuggestHandle * suggest_handle
ATS address suggest handle.
void * cont_cls
Closure for cont.
For each neighbour we keep a list of messages that we still want to transmit to the neighbour...
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct MessageQueue * messages_head
Head of list of messages we would like to send to this peer; must contain at most one message per cli...
struct GNUNET_SCHEDULER_Task * task
Main task that drives this peer (timeouts, keepalives, etc.).
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_HELLO_Address * address
Network-level address information.
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.
GST_NeighbourSendContinuation cont
Function to call once we&#39;re done.
static void free_address(struct NeighbourAddress *na)
We don&#39;t need a given neighbour address any more.
struct MessageQueue * is_active
Are we currently trying to send a message? If so, which one?
struct GNUNET_SCHEDULER_Task * delayed_disconnect_task
Task to disconnect neighbour after we received a DISCONNECT message.
static void unset_primary_address(struct NeighbourMapEntry *n)
Clear the primary address of a neighbour since this address is not valid anymore and notify monitorin...
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
size_t message_buf_size
Size of the message buf.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
clsNULL
targetidentity of the neighbour that was disconnected
resultGNUNET_OK if the disconnect got out successfully
payloadbytes payload
physicalbytes on wire

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

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

Referenced by send_disconnect().

995 {
996  struct NeighbourMapEntry *n;
997 
998  (void) cls;
999  (void) result;
1000  (void) payload;
1001  (void) physical;
1002  n = lookup_neighbour (target);
1003  if (NULL == n)
1004  return; /* already gone */
1006  return; /* have created a fresh entry since */
1007  if (NULL != n->task)
1010 }
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
static int result
Global testing status.
struct GNUNET_SCHEDULER_Task * task
Main task that drives this peer (timeouts, keepalives, etc.).
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
static unsigned long long payload
How much data are we currently storing in the database?
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
Disconnect in progress (we&#39;re sending the DISCONNECT message to the other peer; after that is finishe...
static void master_task(void *cls)
Master task run for every neighbour.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
nneighbour to send DISCONNECT message.

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

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_ATS_SessionDisconnectMessage::public_key, GNUNET_PeerIdentity::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_CRYPTO_EccSignaturePurpose::size, GNUNET_MessageHeader::size, GNUNET_ATS_SessionDisconnectMessage::timestamp, and GNUNET_MessageHeader::type.

Referenced by disconnect_neighbour().

1020 {
1021  struct GNUNET_ATS_SessionDisconnectMessage disconnect_msg;
1022 
1024  "Sending DISCONNECT message to peer `%4s'\n",
1025  GNUNET_i2s (&n->id));
1026  disconnect_msg.header.size = htons (sizeof (struct GNUNET_ATS_SessionDisconnectMessage));
1027  disconnect_msg.header.type =
1029  disconnect_msg.reserved = htonl (0);
1030  disconnect_msg.purpose.size =
1031  htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
1032  sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) +
1033  sizeof (struct GNUNET_TIME_AbsoluteNBO));
1034  disconnect_msg.purpose.purpose =
1036  disconnect_msg.timestamp =
1038  disconnect_msg.public_key = GST_my_identity.public_key;
1041  &disconnect_msg.purpose,
1042  &disconnect_msg.signature));
1043 
1044  (void) send_with_session (n,
1045  &disconnect_msg,
1046  sizeof (disconnect_msg),
1047  UINT32_MAX,
1049  GNUNET_NO,
1051  NULL);
1053  gettext_noop ("# DISCONNECT messages sent"),
1054  1,
1055  GNUNET_NO);
1056 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void send_disconnect_cont(void *cls, const struct GNUNET_PeerIdentity *target, int result, size_t payload, size_t physical)
Function called when the &#39;DISCONNECT&#39; message has been sent by the plugin.
int GNUNET_CRYPTO_eddsa_sign(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
EdDSA sign a given block.
Definition: crypto_ecc.c:989
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
Time for absolute time used by GNUnet, in microseconds and in network byte order. ...
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
Message we send to the other peer to notify it that we intentionally are disconnecting (to reduce tim...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT
Transport DISCONNECT message exchanged between transport services to indicate that a connection shoul...
static struct GNUNET_CRYPTO_EddsaPrivateKey * GST_my_private_key
Our private key.
#define GNUNET_log(kind,...)
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.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:654
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
#define gettext_noop(String)
Definition: gettext.h:69
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...
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
nneighbour to disconnect from

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

References DISCONNECT_SENT_TIMEOUT, free_neighbour(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TRANSPORT_ps2s(), GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TRANSPORT_PS_DISCONNECT, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TRANSPORT_PS_RECONNECT_ATS, GNUNET_TRANSPORT_PS_RECONNECT_SENT, GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT, GNUNET_TRANSPORT_PS_SYN_RECV_ACK, GNUNET_TRANSPORT_PS_SYN_RECV_ATS, GNUNET_TRANSPORT_PS_SYN_SENT, NeighbourMapEntry::id, master_task(), send_disconnect(), set_state_and_timeout(), NeighbourMapEntry::state, and NeighbourMapEntry::task.

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

1066 {
1068  "Disconnecting from peer %s in state %s\n",
1069  GNUNET_i2s (&n->id),
1071  /* depending on state, notify neighbour and/or upper layers of this peer
1072  about disconnect */
1073  switch (n->state)
1074  {
1077  /* other peer is completely unaware of us, no need to send DISCONNECT */
1078  free_neighbour (n);
1079  return;
1081  send_disconnect (n);
1085  break;
1087  /* we never ACK'ed the other peer's request, no need to send DISCONNECT */
1088  free_neighbour (n);
1089  return;
1091  /* we DID ACK the other peer's request, must send DISCONNECT */
1092  send_disconnect (n);
1096  break;
1100  /* we are currently connected, need to send disconnect and do
1101  internal notifications and update statistics */
1102  send_disconnect (n);
1106  break;
1108  /* Disconnecting while waiting for an ATS address to reconnect,
1109  * cannot send DISCONNECT */
1110  free_neighbour (n);
1111  return;
1113  /* already disconnected, ignore */
1114  break;
1116  /* already cleaned up, how did we get here!? */
1117  GNUNET_assert (0);
1118  break;
1119  default:
1121  "Unhandled state `%s'\n",
1123  GNUNET_break (0);
1124  break;
1125  }
1126  /* schedule timeout to clean up */
1127  if (NULL != n->task)
1130  &master_task,
1131  n);
1132 }
Connection got into trouble, rest of the system still believes it to be up, but we&#39;re getting a new a...
We have some primary connection, but ATS suggested we switch to some alternative; we now sent a SYN m...
Sent SYN over new address (either by ATS telling us to switch addresses or from RECONNECT_ATS); if th...
We&#39;re finished with the disconnect; and are cleaning up the state now! We put the struct into this st...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define DISCONNECT_SENT_TIMEOUT
Time we give plugin to transmit DISCONNECT message before the neighbour entry self-destructs.
Received a SYN, asking ATS about address suggestions.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
static void free_neighbour(struct NeighbourMapEntry *n)
Free a neighbour map entry.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
Fresh peer or completely disconnected.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
Asked to initiate connection, trying to get address from ATS.
struct GNUNET_SCHEDULER_Task * task
Main task that drives this peer (timeouts, keepalives, etc.).
const char * GNUNET_TRANSPORT_ps2s(enum GNUNET_TRANSPORT_PeerState state)
Convert a transport state to a human readable string.
Sent SYN message to other peer, waiting for SYN_ACK.
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
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.
static void send_disconnect(struct NeighbourMapEntry *n)
Transmit a DISCONNECT message to the other peer.
Disconnect in progress (we&#39;re sending the DISCONNECT message to the other peer; after that is finishe...
#define GNUNET_log(kind,...)
Got our SYN_ACK/ACK, connection is up.
static void master_task(void *cls)
Master task run for every neighbour.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
SYN request from other peer was SYN_ACK&#39;ed, waiting for ACK.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
nneighbour entry to change quota for
quotanew quota
Returns
GNUNET_YES if n is still valid, GNUNET_NO if n was freed

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

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, GNUNET_ATS_SessionQuotaMessage::quota, send_with_session(), NeighbourAddress::session, GNUNET_MessageHeader::size, test_connected(), GNUNET_MessageHeader::type, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by set_primary_address(), and try_run_fast_ats_update().

1148 {
1150  "Setting inbound quota of %u Bps for peer `%s' to all clients\n",
1151  ntohl (quota.value__), GNUNET_i2s (&n->id));
1153  quota);
1154  if (0 != ntohl (quota.value__))
1155  {
1156  struct GNUNET_ATS_SessionQuotaMessage sqm;
1157 
1158  sqm.header.size = htons (sizeof (struct GNUNET_ATS_SessionQuotaMessage));
1159  sqm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_QUOTA);
1160  sqm.quota = quota.value__;
1161  if (NULL != n->primary_address.session)
1162  (void) send_with_session (n,
1163  &sqm,
1164  sizeof (sqm),
1165  UINT32_MAX - 1,
1167  GNUNET_NO,
1168  NULL, NULL);
1169  return GNUNET_YES;
1170  }
1172  "Disconnecting peer `%s' due to SET_QUOTA\n",
1173  GNUNET_i2s (&n->id));
1174  if (GNUNET_YES == test_connected (n))
1176  gettext_noop ("# disconnects due to quota of 0"),
1177  1, GNUNET_NO);
1179  return GNUNET_NO;
1180 }
struct GNUNET_BANDWIDTH_Tracker in_tracker
Tracker for inbound bandwidth.
void GNUNET_BANDWIDTH_tracker_update_quota(struct GNUNET_BANDWIDTH_Tracker *av, struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit)
Update quota of bandwidth tracker.
Definition: bandwidth.c:526
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_QUOTA
Message exchanged between transport services to indicate that the sender should limit its transmissio...
Message a peer sends to another when connected to indicate that the other peer should limit transmiss...
#define GNUNET_NO
Definition: gnunet_common.h:81
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_MessageHeader header
Header of type GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_QUOTA.
uint32_t value__
The actual value (bytes per second).
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
static int test_connected(struct NeighbourMapEntry *n)
Test if we&#39;re connected to the given peer.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_ATS_Session * session
Active session for this address.
static void disconnect_neighbour(struct NeighbourMapEntry *n)
Disconnect from the given neighbour, clean up the record.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
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.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define gettext_noop(String)
Definition: gettext.h:69
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
nthe neighbour
addressaddress of the other peer, NULL if other peer connected to us
sessionsession to use (or NULL, in which case an address must be setup)
bandwidth_ininbound quota to be used when connection is up
bandwidth_outoutbound quota to be used when connection is up

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

References 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().

1200 {
1201  if (session == n->primary_address.session)
1202  {
1204  GNUNET_YES);
1205  if (n->primary_address.bandwidth_in.value__ != bandwidth_in.value__)
1206  {
1207  n->primary_address.bandwidth_in = bandwidth_in;
1208  if (GNUNET_YES !=
1209  set_incoming_quota (n,
1210  bandwidth_in))
1211  return;
1212  }
1213  if (n->primary_address.bandwidth_out.value__ != bandwidth_out.value__)
1214  {
1215  n->primary_address.bandwidth_out = bandwidth_out;
1217  }
1218  return;
1219  }
1220  if ( (NULL != n->primary_address.address) &&
1221  (0 == GNUNET_HELLO_address_cmp (address,
1222  n->primary_address.address)) )
1223  {
1224  GNUNET_break (0);
1225  return;
1226  }
1227  if (NULL == session)
1228  {
1229  GNUNET_break (0);
1230  GST_ats_block_address (address,
1231  session);
1232  return;
1233  }
1234  if (NULL != n->primary_address.address)
1235  {
1237  "Replacing existing primary address with another one\n");
1239  }
1241  n->primary_address.bandwidth_in = bandwidth_in;
1242  n->primary_address.bandwidth_out = bandwidth_out;
1243  n->primary_address.session = session;
1247  n->primary_address.session));
1248  /* subsystems about address use */
1250  GNUNET_YES);
1251  if (GNUNET_YES !=
1252  set_incoming_quota (n,
1253  bandwidth_in))
1254  return;
1257  "Neighbour `%s' switched to address `%s'\n",
1258  GNUNET_i2s (&n->id),
1259  GST_plugins_a2s(address));
1260 
1263  n->state,
1264  n->timeout,
1267 }
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.
int GST_ats_is_known(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Test if ATS knows about this address and session.
struct GNUNET_TIME_Absolute timeout
Time where we should cut the connection (timeout) if we don&#39;t make progress in the state machine (or ...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint32_t value__
The actual value (bytes per second).
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in
Inbound bandwidth from ATS for this address.
void GST_validation_set_address_use(const struct GNUNET_HELLO_Address *address, int in_use)
Update if we are using an address for a connection actively right now.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_ATS_Session * session
Active session for this address.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
struct GNUNET_HELLO_Address * address
Network-level address information.
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out
Outbound bandwidth from ATS for this address.
static void free_address(struct NeighbourAddress *na)
We don&#39;t need a given neighbour address any more.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
static int set_incoming_quota(struct NeighbourMapEntry *n, struct GNUNET_BANDWIDTH_Value32NBO quota)
Change the incoming quota for the given peer.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
uint32_t keep_alive_nonce
The current nonce sent in the last keep alive messages.
static void send_outbound_quota_to_clients(struct NeighbourMapEntry *n)
Send information about a new outbound quota to our clients.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GST_ats_block_address(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Temporarily block a valid address for use by ATS for address suggestions.
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
clsthe struct MessageQueue of the message
receiverintended receiver
successwhether it worked or not
size_payloadbytes payload sent
physicalbytes sent on wire

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

References bytes_in_send_queue, MessageQueue::cont, MessageQueue::cont_cls, 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(), MessageQueue::message_buf, MessageQueue::message_buf_size, mq, and NeighbourMapEntry::task.

Referenced by try_transmission_to_peer().

1285 {
1286  struct MessageQueue *mq = cls;
1287  struct NeighbourMapEntry *n;
1288 
1289  if (NULL == (n = lookup_neighbour (receiver)))
1290  {
1291  if (NULL != mq->cont)
1292  mq->cont (mq->cont_cls,
1293  GNUNET_SYSERR /* not connected */,
1294  size_payload,
1295  0);
1296  GNUNET_free (mq);
1297  return; /* disconnect or other error while transmitting, can happen */
1298  }
1299  if (n->is_active == mq)
1300  {
1301  /* this is still "our" neighbour, remove us from its queue
1302  and allow it to send the next message now */
1303  n->is_active = NULL;
1304  if (NULL != n->task)
1307  n);
1308  }
1309  if (bytes_in_send_queue < mq->message_buf_size)
1310  {
1312  "Bytes_in_send_queue `%llu', Message_size %u, result: %s, payload %u, on wire %u\n",
1314  (unsigned int) mq->message_buf_size,
1315  (GNUNET_OK == success) ? "OK" : "FAIL",
1316  (unsigned int) size_payload,
1317  (unsigned int) physical);
1318  GNUNET_break (0);
1319  }
1320 
1321  GNUNET_break (size_payload == mq->message_buf_size);
1324  gettext_noop ("# bytes in message queue for other peers"),
1326  GNUNET_NO);
1327  if (GNUNET_OK == success)
1329  gettext_noop ("# messages transmitted to other peers"),
1330  1,
1331  GNUNET_NO);
1332  else
1334  gettext_noop
1335  ("# transmission failures for messages to other peers"),
1336  1, GNUNET_NO);
1338  "Sending message to `%s' of type %u with %u bytes was a %s\n",
1339  GNUNET_i2s (receiver),
1340  ntohs (((struct GNUNET_MessageHeader *) mq->message_buf)->type),
1341  (unsigned int) mq->message_buf_size,
1342  (success == GNUNET_OK) ? "success" : "FAILURE");
1343  if (NULL != mq->cont)
1344  mq->cont (mq->cont_cls,
1345  success,
1346  size_payload,
1347  physical);
1348  GNUNET_free (mq);
1349 }
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
void * cont_cls
Closure for cont.
For each neighbour we keep a list of messages that we still want to transmit to the neighbour...
struct GNUNET_SCHEDULER_Task * task
Main task that drives this peer (timeouts, keepalives, etc.).
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
static unsigned long long bytes_in_send_queue
Number of bytes we have currently queued for transmission.
const char * message_buf
The message(s) we want to transmit, GNUNET_MessageHeader(s) stuck together in memory.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
GST_NeighbourSendContinuation cont
Function to call once we&#39;re done.
struct MessageQueue * is_active
Are we currently trying to send a message? If so, which one?
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
Header for all communications.
static void master_task(void *cls)
Master task run for every neighbour.
size_t message_buf_size
Size of the message buf.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
ntarget peer for which to transmit

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

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, MessageQueue::message_buf, MessageQueue::message_buf_size, NeighbourMapEntry::messages_head, NeighbourMapEntry::messages_tail, mq, NeighbourMapEntry::primary_address, GNUNET_TIME_Relative::rel_value_us, send_with_session(), NeighbourAddress::session, MessageQueue::timeout, and transmit_send_continuation().

Referenced by master_task().

1365 {
1366  struct MessageQueue *mq;
1368 
1369  if (NULL == n->primary_address.address)
1370  {
1371  /* no address, why are we here? */
1372  GNUNET_break (0);
1373  return;
1374  }
1375  if ((0 == n->primary_address.address->address_length) &&
1376  (NULL == n->primary_address.session))
1377  {
1378  /* no address, why are we here? */
1379  GNUNET_break (0);
1380  return;
1381  }
1382  if (NULL != n->is_active)
1383  {
1384  /* transmission already pending */
1385  return;
1386  }
1387 
1388  /* timeout messages from the queue that are past their due date */
1389  while (NULL != (mq = n->messages_head))
1390  {
1392  if (timeout.rel_value_us > 0)
1393  break;
1395  gettext_noop ("# messages timed out while in transport queue"),
1396  1,
1397  GNUNET_NO);
1399  n->messages_tail,
1400  mq);
1401  n->is_active = mq;
1403  &n->id,
1404  GNUNET_SYSERR,
1405  mq->message_buf_size,
1406  0); /* timeout */
1407  }
1408  if (NULL == mq)
1409  return; /* no more messages */
1410  if (NULL == n->primary_address.address)
1411  {
1412  /* transmit_send_continuation() caused us to drop session,
1413  can't try transmission anymore. */
1414  return;
1415  }
1416 
1417 
1419  n->messages_tail,
1420  mq);
1421  n->is_active = mq;
1422 
1424  "Giving message with %u bytes to plugin session %p\n",
1425  (unsigned int) mq->message_buf_size,
1427  (void) send_with_session (n,
1428  mq->message_buf,
1429  mq->message_buf_size,
1430  0 /* priority */,
1431  timeout,
1432  GNUNET_NO,
1434  mq);
1435 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
size_t address_length
Number of bytes in address.
uint64_t rel_value_us
The actual value.
struct GNUNET_TIME_Absolute timeout
At what time should we fail?
#define GNUNET_NO
Definition: gnunet_common.h:81
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct MessageQueue * messages_tail
Tail of list of messages we would like to send to this peer; must contain at most one message per cli...
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:114
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
For each neighbour we keep a list of messages that we still want to transmit to the neighbour...
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_ATS_Session * session
Active session for this address.
struct MessageQueue * messages_head
Head of list of messages we would like to send to this peer; must contain at most one message per cli...
const char * message_buf
The message(s) we want to transmit, GNUNET_MessageHeader(s) stuck together in memory.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_HELLO_Address * address
Network-level address information.
struct MessageQueue * is_active
Are we currently trying to send a message? If so, which one?
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
static void transmit_send_continuation(void *cls, const struct GNUNET_PeerIdentity *receiver, int success, size_t size_payload, size_t physical)
We&#39;re done with our transmission attempt, continue processing.
size_t message_buf_size
Size of the message buf.
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.
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
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
nneighbour that went idle and needs a keepalive

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

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, GNUNET_ATS_SessionKeepAliveMessage::header, NeighbourMapEntry::id, NeighbourAddress::keep_alive_nonce, NeighbourMapEntry::keep_alive_time, NeighbourMapEntry::last_keep_alive_time, GNUNET_ATS_SessionKeepAliveMessage::nonce, NeighbourMapEntry::primary_address, GNUNET_TIME_Relative::rel_value_us, send_with_session(), GNUNET_MessageHeader::size, NeighbourMapEntry::state, and GNUNET_MessageHeader::type.

Referenced by master_task().

1448 {
1451  uint32_t nonce;
1452 
1456  return; /* no keepalive needed at this time */
1457 
1458  nonce = 0; /* 0 indicates 'not set' */
1459  while (0 == nonce)
1461  UINT32_MAX);
1462 
1464  "Sending KEEPALIVE to peer `%s' with nonce %u\n",
1465  GNUNET_i2s (&n->id),
1466  nonce);
1467  m.header.size = htons (sizeof (struct GNUNET_ATS_SessionKeepAliveMessage));
1468  m.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE);
1469  m.nonce = htonl (nonce);
1470 
1472  &m,
1473  sizeof (m),
1474  UINT32_MAX /* priority */,
1476  GNUNET_YES,
1477  NULL, NULL);
1479  gettext_noop ("# KEEPALIVES sent"),
1480  1,
1481  GNUNET_NO);
1482  n->primary_address.keep_alive_nonce = nonce;
1486 }
We have some primary connection, but ATS suggested we switch to some alternative; we now sent a SYN m...
uint64_t rel_value_us
The actual value.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:81
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_TIME_Absolute last_keep_alive_time
At what time did we sent the last keep-alive message? Used to calculate round-trip time ("latency")...
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct GNUNET_TIME_Absolute keep_alive_time
At what time should we sent the next keep-alive message?
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:114
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
Randomness for IVs etc.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE
Message send by a peer to notify the other to keep the session alive and measure latency in a regular...
Message a peer sends to another when connected to indicate that a session is in use and the peer is s...
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
int expect_latency_response
Did we sent an KEEP_ALIVE message and are we expecting a response?
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
#define GNUNET_YES
Definition: gnunet_common.h:80
Got our SYN_ACK/ACK, connection is up.
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.
uint32_t keep_alive_nonce
The current nonce sent in the last keep alive messages.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
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
neighbourneighbour to keep alive (by sending keep alive response)
mthe keep alive message containing the nonce to respond to

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

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, GNUNET_ATS_SessionKeepAliveMessage::header, NeighbourMapEntry::id, lookup_neighbour(), GNUNET_ATS_SessionKeepAliveMessage::nonce, NeighbourMapEntry::primary_address, send_with_session(), NeighbourAddress::session, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by GST_receive_callback().

1499 {
1500  struct NeighbourMapEntry *n;
1501  const struct GNUNET_ATS_SessionKeepAliveMessage *msg_in;
1503 
1504  if (sizeof (struct GNUNET_ATS_SessionKeepAliveMessage) != ntohs (m->size))
1505  {
1506  GNUNET_break_op (0);
1507  return;
1508  }
1509 
1510  msg_in = (const struct GNUNET_ATS_SessionKeepAliveMessage *) m;
1511  if (NULL == (n = lookup_neighbour (neighbour)))
1512  {
1514  gettext_noop
1515  ("# KEEPALIVE messages discarded (peer unknown)"),
1516  1, GNUNET_NO);
1517  return;
1518  }
1519  if (NULL == n->primary_address.session)
1520  {
1522  gettext_noop
1523  ("# KEEPALIVE messages discarded (no session)"),
1524  1, GNUNET_NO);
1525  return;
1526  }
1527 
1529  "Received KEEPALIVE request from peer `%s' with nonce %u\n",
1530  GNUNET_i2s (&n->id),
1531  ntohl (msg_in->nonce));
1533  gettext_noop ("# KEEPALIVES received in good order"),
1534  1,
1535  GNUNET_NO);
1536 
1537  /* send reply to allow neighbour to measure latency */
1538  msg.header.size = htons (sizeof (struct GNUNET_ATS_SessionKeepAliveMessage));
1540  msg.nonce = msg_in->nonce;
1541  (void) send_with_session (n,
1542  &msg,
1543  sizeof (struct GNUNET_ATS_SessionKeepAliveMessage),
1544  UINT32_MAX /* priority */,
1546  GNUNET_YES,
1547  NULL, NULL);
1548 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_NO
Definition: gnunet_common.h:81
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE_RESPONSE
Response to a GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE message to measure latency in a regular...
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_ATS_Session * session
Active session for this address.
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
Message a peer sends to another when connected to indicate that a session is in use and the peer is s...
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
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.
uint32_t nonce
A nonce to identify the session the keep alive is used for.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller 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
neighbourneighbour to keep alive
mthe message containing the keep alive response

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

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(), msg, GNUNET_ATS_SessionKeepAliveMessage::nonce, NeighbourMapEntry::primary_address, NeighbourAddress::session, set_state_and_timeout(), GNUNET_MessageHeader::size, NeighbourMapEntry::state, GNUNET_HELLO_Address::transport_name, and GNUNET_TRANSPORT_PluginFunctions::update_session_timeout.

Referenced by GST_receive_callback().

1562 {
1563  struct NeighbourMapEntry *n;
1565  struct GNUNET_TRANSPORT_PluginFunctions *papi;
1566  struct GNUNET_TIME_Relative latency;
1567 
1568  if (sizeof (struct GNUNET_ATS_SessionKeepAliveMessage) != ntohs (m->size))
1569  {
1570  GNUNET_break_op (0);
1571  return;
1572  }
1573 
1574  msg = (const struct GNUNET_ATS_SessionKeepAliveMessage *) m;
1575  if (NULL == (n = lookup_neighbour (neighbour)))
1576  {
1578  gettext_noop ("# KEEPALIVE_RESPONSEs discarded (not connected)"),
1579  1,
1580  GNUNET_NO);
1581  return;
1582  }
1583  if ( (GNUNET_TRANSPORT_PS_CONNECTED != n->state) ||
1585  {
1587  gettext_noop ("# KEEPALIVE_RESPONSEs discarded (not expected)"),
1588  1,
1589  GNUNET_NO);
1590  return;
1591  }
1592  if (NULL == n->primary_address.address)
1593  {
1595  gettext_noop ("# KEEPALIVE_RESPONSEs discarded (address changed)"),
1596  1,
1597  GNUNET_NO);
1598  return;
1599  }
1600  if (n->primary_address.keep_alive_nonce != ntohl (msg->nonce))
1601  {
1602  if (0 == n->primary_address.keep_alive_nonce)
1604  gettext_noop ("# KEEPALIVE_RESPONSEs discarded (no nonce)"),
1605  1,
1606  GNUNET_NO);
1607  else
1609  gettext_noop ("# KEEPALIVE_RESPONSEs discarded (bad nonce)"),
1610  1,
1611  GNUNET_NO);
1612  return;
1613  }
1615  gettext_noop ("# KEEPALIVE_RESPONSEs received (OK)"),
1616  1,
1617  GNUNET_NO);
1618 
1619 
1620  /* Update session timeout here */
1621  if (NULL != (papi = GST_plugins_find (n->primary_address.address->transport_name)))
1622  {
1624  "Updating session for peer `%s' for session %p\n",
1625  GNUNET_i2s (&n->id),
1627  papi->update_session_timeout (papi->cls,
1628  &n->id,
1630  }
1631  else
1632  {
1633  GNUNET_break (0);
1634  }
1635 
1639  n->state,
1641 
1644  "Received KEEPALIVE_RESPONSE from peer `%s', latency is %s\n",
1645  GNUNET_i2s (&n->id),
1647  GNUNET_YES));
1649  GNUNET_TIME_relative_divide (latency,
1650  2));
1651 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
#define GNUNET_NO
Definition: gnunet_common.h:81
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
GNUNET_TRANSPORT_UpdateSessionTimeout update_session_timeout
Function that will be called whenever the transport service wants to notify the plugin that a session...
struct GNUNET_TIME_Absolute last_keep_alive_time
At what time did we sent the last keep-alive message? Used to calculate round-trip time ("latency")...
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
void * cls
Closure for all of the callbacks.
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:727
const char * transport_name
Name of the transport plugin enabling the communication using this address.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_ATS_Session * session
Active session for this address.
struct GNUNET_TRANSPORT_PluginFunctions * GST_plugins_find(const char *name)
Obtain the plugin API based on a plugin name.
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
struct GNUNET_HELLO_Address * address
Network-level address information.
Message a peer sends to another when connected to indicate that a session is in use and the peer is s...
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
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.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don&#39;t receive messages from the peer...
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
int expect_latency_response
Did we sent an KEEP_ALIVE message and are we expecting a response?
void GST_ats_update_delay(const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Relative delay)
Notify ATS about delay changes to properties of an address.
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Divide relative time by a given factor.
Definition: time.c:525
#define GNUNET_YES
Definition: gnunet_common.h:80
Got our SYN_ACK/ACK, connection is up.
uint32_t keep_alive_nonce
The current nonce sent in the last keep alive messages.
uint32_t nonce
A nonce to identify the session the keep alive is used for.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ 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
sendersender of the message
sizesize of the message
do_forwardset 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 1667 of file gnunet-service-transport_neighbours.c.

References GNUNET_BANDWIDTH_Tracker::available_bytes_per_s__, GNUNET_BANDWIDTH_Tracker::consumption_since_last_update__, gettext_noop, GNUNET_BANDWIDTH_tracker_consume(), GNUNET_BANDWIDTH_tracker_get_delay(), GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, GST_stats, NeighbourMapEntry::in_tracker, lookup_neighbour(), NeighbourMapEntry::quota_violation_count, QUOTA_VIOLATION_DROP_THRESHOLD, GNUNET_TIME_Relative::rel_value_us, ret, size, and test_connected().

Referenced by inbound_bw_tracker_update(), and process_payload().

1670 {
1671  struct NeighbourMapEntry *n;
1672  struct GNUNET_TIME_Relative ret;
1673 
1674  if (NULL == neighbours)
1675  {
1676  *do_forward = GNUNET_NO;
1677  return GNUNET_TIME_UNIT_FOREVER_REL; /* This can happen during shutdown */
1678  }
1679  if (NULL == (n = lookup_neighbour (sender)))
1680  {
1682  gettext_noop ("# messages discarded due to lack of neighbour record"),
1683  1,
1684  GNUNET_NO);
1685  *do_forward = GNUNET_NO;
1686  return GNUNET_TIME_UNIT_ZERO;
1687  }
1688  if (! test_connected (n))
1689  {
1690  *do_forward = GNUNET_SYSERR;
1691  return GNUNET_TIME_UNIT_ZERO;
1692  }
1694  {
1695  n->quota_violation_count++;
1697  "Bandwidth quota (%u b/s) violation detected (total of %u).\n",
1700  /* Discount 32k per violation */
1701  GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, -32 * 1024);
1702  }
1703  else
1704  {
1705  if (n->quota_violation_count > 0)
1706  {
1707  /* try to add 32k back */
1709  n->quota_violation_count--;
1710  }
1711  }
1713  {
1715  gettext_noop
1716  ("# bandwidth quota violations by other peers"),
1717  1, GNUNET_NO);
1718  *do_forward = GNUNET_NO;
1720  }
1721  *do_forward = GNUNET_YES;
1723  if (ret.rel_value_us > 0)
1724  {
1726  "Throttling read (%lld bytes excess at %u b/s), waiting %s before reading more.\n",
1728  (unsigned int) n->in_tracker.available_bytes_per_s__,
1731  gettext_noop ("# ms throttling suggested"),
1732  (int64_t) ret.rel_value_us / 1000LL,
1733  GNUNET_NO);
1734  }
1735  return ret;
1736 }
static struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Hash map from peer identities to the respective struct NeighbourMapEntry.
int GNUNET_BANDWIDTH_tracker_consume(struct GNUNET_BANDWIDTH_Tracker *av, ssize_t size)
Notify the tracker that a certain number of bytes of bandwidth have been consumed.
Definition: bandwidth.c:402
unsigned int quota_violation_count
How often has the other peer (recently) violated the inbound traffic limit? Incremented by 10 per vio...
struct GNUNET_BANDWIDTH_Tracker in_tracker
Tracker for inbound bandwidth.
#define GNUNET_NO
Definition: gnunet_common.h:81
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static int ret
Final status code.
Definition: gnunet-arm.c:89
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
int64_t consumption_since_last_update__
Number of bytes consumed since we last updated the tracker.
static int test_connected(struct NeighbourMapEntry *n)
Test if we&#39;re connected to the given peer.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:727
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT
How long do we delay reading more from a peer after a quota violation?
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
struct GNUNET_TIME_Relative GNUNET_BANDWIDTH_tracker_get_delay(struct GNUNET_BANDWIDTH_Tracker *av, size_t size)
Compute how long we should wait until consuming size bytes of bandwidth in order to stay within the g...
Definition: bandwidth.c:458
#define QUOTA_VIOLATION_DROP_THRESHOLD
How often must a peer violate bandwidth quotas before we start to simply drop its messages...
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
uint32_t available_bytes_per_s__
Bandwidth limit to enforce in bytes per second.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
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
targetdestination
msgmessage to send
msg_sizenumber of bytes in msg
timeoutwhen to fail with timeout
contfunction to call when done
cont_clsclosure for cont

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

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(), MessageQueue::message_buf, MessageQueue::message_buf_size, NeighbourMapEntry::messages_head, NeighbourMapEntry::messages_tail, mq, NeighbourMapEntry::task, test_connected(), and MessageQueue::timeout.

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

1756 {
1757  struct NeighbourMapEntry *n;
1758  struct MessageQueue *mq;
1759 
1760  /* All ove these cases should never happen; they are all API violations.
1761  But we check anyway, just to be sure. */
1762  if (NULL == (n = lookup_neighbour (target)))
1763  {
1764  GNUNET_break (0);
1765  if (NULL != cont)
1766  cont (cont_cls,
1767  GNUNET_SYSERR,
1768  msg_size,
1769  0);
1770  return;
1771  }
1772  if (GNUNET_YES != test_connected (n))
1773  {
1774  GNUNET_break (0);
1775  if (NULL != cont)
1776  cont (cont_cls,
1777  GNUNET_SYSERR,
1778  msg_size,
1779  0);
1780  return;
1781  }
1782  bytes_in_send_queue += msg_size;
1784  gettext_noop
1785  ("# bytes in message queue for other peers"),
1787  mq = GNUNET_malloc (sizeof (struct MessageQueue) + msg_size);
1788  mq->cont = cont;
1789  mq->cont_cls = cont_cls;
1790  GNUNET_memcpy (&mq[1], msg, msg_size);
1791  mq->message_buf = (const char *) &mq[1];
1792  mq->message_buf_size = msg_size;
1793  mq->timeout = GNUNET_TIME_relative_to_absolute (timeout);
1794 
1796  "Enqueueing %u bytes to send to peer %s\n",
1797  (unsigned int) msg_size,
1798  GNUNET_i2s (target));
1800  n->messages_tail,
1801  mq);
1802  if (NULL != n->task)
1805 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
struct GNUNET_TIME_Absolute timeout
At what time should we fail?
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct MessageQueue * messages_tail
Tail of list of messages we would like to send to this peer; must contain at most one message per cli...
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
#define GNUNET_memcpy(dst, src, n)
static int test_connected(struct NeighbourMapEntry *n)
Test if we&#39;re connected to the given peer.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
void * cont_cls
Closure for cont.
For each neighbour we keep a list of messages that we still want to transmit to the neighbour...
struct MessageQueue * messages_head
Head of list of messages we would like to send to this peer; must contain at most one message per cli...
struct GNUNET_SCHEDULER_Task * task
Main task that drives this peer (timeouts, keepalives, etc.).
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
static unsigned long long bytes_in_send_queue
Number of bytes we have currently queued for transmission.
const char * message_buf
The message(s) we want to transmit, GNUNET_MessageHeader(s) stuck together in memory.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
GST_NeighbourSendContinuation cont
Function to call once we&#39;re done.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
static void master_task(void *cls)
Master task run for every neighbour.
size_t message_buf_size
Size of the message buf.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_malloc(size)
Wrapper around malloc.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
clsNULL
targetwhich peer received the transmission
resultGNUNET_OK if sending worked
size_payloadhow many bytes of payload were sent (ignored)
size_on_wirehow much bandwidth was consumed on the wire (ignored)

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

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(), set_state_and_timeout(), NeighbourMapEntry::state, and unset_primary_address().

Referenced by send_syn().

1826 {
1827  struct NeighbourMapEntry *n;
1828 
1829  (void) cls;
1830  (void) size_payload;
1831  (void) size_on_wire;
1832  n = lookup_neighbour (target);
1833  if (NULL == n)
1834  {
1835  /* SYN continuation was called after neighbor was freed,
1836  * for example due to a time out for the state or the session
1837  * used was already terminated: nothing to do here... */
1838  return;
1839  }
1840 
1841  if ( (GNUNET_TRANSPORT_PS_SYN_SENT != n->state) &&
1844  {
1845  /* SYN continuation was called after neighbor changed state,
1846  * for example due to a time out for the state or the session
1847  * used was already terminated: nothing to do here... */
1848  return;
1849  }
1850  if (GNUNET_OK == result)
1851  return;
1852 
1854  _("Failed to send SYN message to peer `%s'\n"),
1855  GNUNET_i2s (target));
1856  switch (n->state) {
1858  /* Remove address and request an additional one */
1863  break;
1865  /* Remove address and request an additional one */
1870  break;
1872  /* Remove address and request and go back to primary address */
1874  gettext_noop ("# Failed attempts to switch addresses (failed to send SYN CONT)"),
1875  1,
1876  GNUNET_NO);
1878  "Switch failed, cleaning up alternative address\n");
1883  break;
1884  default:
1886  break;
1887  }
1888 }
Connection got into trouble, rest of the system still believes it to be up, but we&#39;re getting a new a...
We have some primary connection, but ATS suggested we switch to some alternative; we now sent a SYN m...
Sent SYN over new address (either by ATS telling us to switch addresses or from RECONNECT_ATS); if th...
struct NeighbourAddress alternative_address
Alternative address currently under consideration for communicating with the neighbour.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
#define FAST_RECONNECT_TIMEOUT
How long are we willing to wait for a successful reconnect if an existing connection went down...
static int result
Global testing status.
Asked to initiate connection, trying to get address from ATS.
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
Sent SYN message to other peer, waiting for SYN_ACK.
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
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.
static void free_address(struct NeighbourAddress *na)
We don&#39;t need a given neighbour address any 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 monitorin...
static void disconnect_neighbour(struct NeighbourMapEntry *n)
Disconnect from the given neighbour, clean up the record.
#define ATS_RESPONSE_TIMEOUT
How long are we willing to wait for a response from ATS before timing out?
#define GNUNET_log(kind,...)
Got our SYN_ACK/ACK, connection is up.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define gettext_noop(String)
Definition: gettext.h:69
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
naaddress to use

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

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

1898 {
1899  struct GNUNET_TRANSPORT_PluginFunctions *papi;
1900  struct TransportSynMessage connect_msg;
1901  struct NeighbourMapEntry *n;
1902 
1903  GNUNET_assert (NULL != na->session);
1905  "Sending SYN message to peer `%s' at %s\n",
1906  GNUNET_i2s (&na->address->peer),
1907  GST_plugins_a2s (na->address));
1908 
1909  papi = GST_plugins_find (na->address->transport_name);
1910  GNUNET_assert (NULL != papi);
1912  gettext_noop
1913  ("# SYN messages sent"),
1914  1, GNUNET_NO);
1916  connect_msg.header.size = htons (sizeof (struct TransportSynMessage));
1917  connect_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN);
1918  connect_msg.reserved = htonl (0);
1919  connect_msg.timestamp = GNUNET_TIME_absolute_hton (na->connect_timestamp);
1920  if (-1 ==
1921  papi->send (papi->cls,
1922  na->session,
1923  (const char *) &connect_msg,
1924  sizeof (struct TransportSynMessage),
1925  UINT_MAX,
1927  &send_session_syn_cont, NULL))
1928  {
1930  _("Failed to transmit SYN message to %s\n"),
1931  GST_plugins_a2s (na->address));
1932  n = lookup_neighbour (&na->address->peer);
1933  if (NULL == n)
1934  {
1935  GNUNET_break (0);
1936  return;
1937  }
1938  switch (n->state) {
1940  /* Remove address and request and additional one */
1941  GNUNET_assert (na == &n->primary_address);
1946  /* Hard failure to send the SYN message with this address:
1947  Destroy address and session */
1948  break;
1950  /* Remove address and request an additional one */
1951  GNUNET_assert (na == &n->primary_address);
1956  break;
1958  GNUNET_assert (na == &n->alternative_address);
1960  gettext_noop ("# Failed attempts to switch addresses (failed to send SYN)"),
1961  1,
1962  GNUNET_NO);
1963  /* Remove address and request an additional one */
1965  "Switch failed, cleaning up alternative address\n");
1970  break;
1971  default:
1972  GNUNET_break (0);
1974  break;
1975  }
1976  return;
1977  }
1979  na->session,
1980  sizeof (struct TransportSynMessage));
1981 }
Connection got into trouble, rest of the system still believes it to be up, but we&#39;re getting a new a...
We have some primary connection, but ATS suggested we switch to some alternative; we now sent a SYN m...
Sent SYN over new address (either by ATS telling us to switch addresses or from RECONNECT_ATS); if th...
struct NeighbourAddress alternative_address
Alternative address currently under consideration for communicating with the neighbour.
GNUNET_TRANSPORT_TransmitFunction send
Function that the transport service will use to transmit data to another peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
#define GNUNET_NO
Definition: gnunet_common.h:81
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
Message a peer sends to another to indicate that it intends to setup a connection/session for data ex...
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
void * cls
Closure for all of the callbacks.
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
#define FAST_RECONNECT_TIMEOUT
How long are we willing to wait for a successful reconnect if an existing connection went down...
#define SETUP_CONNECTION_TIMEOUT
How long are we willing to wait for an ACK from the other peer before giving up on our connect operat...
struct GNUNET_TIME_Absolute connect_timestamp
Timestamp of the &#39;SESSION_CONNECT&#39; message we sent to the other peer for this address.
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 a...
const char * transport_name
Name of the transport plugin enabling the communication using this address.
struct GNUNET_ATS_Session * session
Active session for this address.
Asked to initiate connection, trying to get address from ATS.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
struct GNUNET_TRANSPORT_PluginFunctions * GST_plugins_find(const char *name)
Obtain the plugin API based on a plugin name.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
struct GNUNET_HELLO_Address * address
Network-level address information.
Sent SYN message to other peer, waiting for SYN_ACK.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
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.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN
Transport SYN message exchanged between transport services to indicate that a session should be marke...
static void free_address(struct NeighbourAddress *na)
We don&#39;t need a given neighbour address any 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 monitorin...
static void disconnect_neighbour(struct NeighbourMapEntry *n)
Disconnect from the given neighbour, clean up the record.
#define ATS_RESPONSE_TIMEOUT
How long are we willing to wait for a response from ATS before timing out?
#define GNUNET_log(kind,...)
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 ...
Got our SYN_ACK/ACK, connection is up.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:654
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define gettext_noop(String)
Definition: gettext.h:69
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
clsNULL
targetwhich peer received the transmission
resultGNUNET_OK if sending worked
size_payloadhow many bytes of payload were sent (ignored)
size_on_wirehow much bandwidth was consumed on the wire (ignored)

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

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, set_state_and_timeout(), NeighbourMapEntry::state, and unset_primary_address().

Referenced by send_syn_ack_message().

2002 {
2003  struct NeighbourMapEntry *n;
2004 
2005  (void) cls;
2006  (void) size_payload;
2007  (void) size_on_wire;
2008  n = lookup_neighbour (target);
2009  if (NULL == n)
2010  {
2011  /* SYN_ACK continuation was called after neighbor was freed,
2012  * for example due to a time out for the state or the session
2013  * used was already terminated: nothing to do here... */
2014  return;
2015  }
2016 
2018  {
2019  /* SYN_ACK continuation was called after neighbor changed state,
2020  * for example due to a time out for the state or the session
2021  * used was already terminated: nothing to do here... */
2022  return;
2023  }
2024  if (GNUNET_OK == result)
2025  return;
2026 
2028  _("Failed to send SYN_ACK message to peer `%s' using address `%s'\n"),
2029  GNUNET_i2s (target),
2031 
2032  /* Remove address and request and additional one */
2033  /* FIXME: what if the neighbour's primary address
2034  changed in the meantime? Might want to instead
2035  pass "something" around in closure to be sure. */
2041 }
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
Received a SYN, asking ATS about address suggestions.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
static int result
Global testing status.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
struct GNUNET_HELLO_Address * address
Network-level address information.
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
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.
static void unset_primary_address(struct NeighbourMapEntry *n)
Clear the primary address of a neighbour since this address is not valid anymore and notify monitorin...
#define ATS_RESPONSE_TIMEOUT
How long are we willing to wait for a response from ATS before timing out?
#define GNUNET_log(kind,...)
enum GST_ACK_State ack_state
When a peer wants to connect we have to reply to the 1st SYN message with a SYN_ACK message...
The neighbour received a SYN message and has to send a SYN_ACK as reply.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
SYN request from other peer was SYN_ACK&#39;ed, waiting for ACK.
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
naaddress and session to use
timestamptimestamp to use for the ACK message
Returns
GNUNET_SYSERR if sending immediately failed, GNUNET_OK otherwise

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

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(), GNUNET_HELLO_Address::peer, TransportSynMessage::reserved, GNUNET_TRANSPORT_PluginFunctions::send, send_session_syn_ack_cont(), NeighbourAddress::session, set_state_and_timeout(), GNUNET_MessageHeader::size, TransportSynMessage::timestamp, GNUNET_HELLO_Address::transport_name, GNUNET_MessageHeader::type, and unset_primary_address().

Referenced by GST_neighbours_handle_session_syn(), and switch_address_bl_check_cont().

2054 {
2055  const struct GNUNET_HELLO_Address *address = na->address;
2056  struct GNUNET_ATS_Session *session = na->session;
2057  struct GNUNET_TRANSPORT_PluginFunctions *papi;
2058  struct TransportSynMessage connect_msg;
2059  struct NeighbourMapEntry *n;
2060 
2062  "Sending SYN_ACK to peer `%s'\n",
2063  GNUNET_i2s (&address->peer));
2064 
2065  if (NULL == (papi = GST_plugins_find (address->transport_name)))
2066  {
2067  GNUNET_break (0);
2068  return;
2069  }
2070  if (NULL == session)
2071  session = papi->get_session (papi->cls,
2072  address);
2073  if (NULL == session)
2074  {
2075  GNUNET_break (0);
2076  return;
2077  }
2078  GST_ats_new_session (address,
2079  session);
2081  gettext_noop
2082  ("# SYN_ACK messages sent"),
2083  1, GNUNET_NO);
2084  connect_msg.header.size = htons (sizeof (struct TransportSynMessage));
2085  connect_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK);
2086  connect_msg.reserved = htonl (0);
2087  connect_msg.timestamp = GNUNET_TIME_absolute_hton (timestamp);
2088 
2089  if (GNUNET_SYSERR ==
2090  papi->send (papi->cls,
2091  session,
2092  (const char *) &connect_msg,
2093  sizeof (struct TransportSynMessage),
2094  UINT_MAX,
2096  &send_session_syn_ack_cont, NULL))
2097  {
2099  _("Failed to transmit SYN_ACK message to %s\n"),
2100  GST_plugins_a2s (address));
2101 
2102  n = lookup_neighbour (&address->peer);
2103  if (NULL == n)
2104  {
2105  GNUNET_break (0);
2106  return;
2107  }
2108  /* Remove address and request and additional one */
2114  return;
2115  }
2116 }
GNUNET_TRANSPORT_CreateSession get_session
Function that will be called tell the plugin to create a session object.
GNUNET_TRANSPORT_TransmitFunction send
Function that the transport service will use to transmit data to another peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
#define GNUNET_NO
Definition: gnunet_common.h:81
Received a SYN, asking ATS about address suggestions.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
Message a peer sends to another to indicate that it intends to setup a connection/session for data ex...
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...
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
void * cls
Closure for all of the callbacks.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK
Transport SYN_ACK message exchanged between transport services to indicate that a SYN message was acc...
Information about ongoing sessions of the transport client.
const char * transport_name
Name of the transport plugin enabling the communication using this address.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_ATS_Session * session
Active session for this address.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
struct GNUNET_TRANSPORT_PluginFunctions * GST_plugins_find(const char *name)
Obtain the plugin API based on a plugin name.
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_HELLO_Address * address
Network-level address information.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
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.
An address for communicating with a peer.
static void unset_primary_address(struct NeighbourMapEntry *n)
Clear the primary address of a neighbour since this address is not valid anymore and notify monitorin...
#define ATS_RESPONSE_TIMEOUT
How long are we willing to wait for a response from ATS before timing out?
#define GNUNET_log(kind,...)
enum GST_ACK_State ack_state
When a peer wants to connect we have to reply to the 1st SYN message with a SYN_ACK message...
The neighbour received a SYN message and has to send a SYN_ACK as reply.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:654
static char * address
GNS address for this phone.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GST_ats_new_session(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Notify ATS about a new session now existing for the given address.
#define gettext_noop(String)
Definition: gettext.h:69
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
clsthe struct NeighbourMapEntry to update calculations for

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

References NeighbourAddress::address, GNUNET_TRANSPORT_PluginFunctions::cls, 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().

2129 {
2130  struct NeighbourMapEntry *n = cls;
2131  struct GNUNET_TRANSPORT_PluginFunctions *papi;
2132  struct GNUNET_TIME_Relative delay;
2133  int do_forward;
2134 
2135  if (NULL == n->primary_address.address)
2136  return; /* not active, ignore */
2138  GNUNET_assert (NULL != papi);
2139  if (NULL == papi->update_inbound_delay)
2140  return;
2142  0,
2143  &do_forward);
2145  "New inbound delay for peer `%s' is %llu ms\n",
2146  GNUNET_i2s (&n->id),
2147  (unsigned long long) delay.rel_value_us / 1000LL);
2148  if (NULL == n->primary_address.session)
2149  return;
2150  papi->update_inbound_delay (papi->cls,
2151  &n->id,
2153  delay);
2154 }
uint64_t rel_value_us
The actual value.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
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.
void * cls
Closure for all of the callbacks.
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
const char * transport_name
Name of the transport plugin enabling the communication using this address.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_ATS_Session * session
Active session for this address.
GNUNET_TRANSPORT_UpdateInboundDelay update_inbound_delay
Function that will be called whenever the transport service wants to notify the plugin that the inbou...
struct GNUNET_TRANSPORT_PluginFunctions * GST_plugins_find(const char *name)
Obtain the plugin API based on a plugin name.
struct GNUNET_HELLO_Address * address
Network-level address information.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
#define GNUNET_log(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Time for relative time used by GNUnet, in microseconds.
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
peerpeer to create an entry for
Returns
new neighbour map entry

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

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, peer, set_state_and_timeout(), NeighbourMapEntry::suggest_handle, and NeighbourMapEntry::task.

Referenced by GST_neighbours_handle_session_syn(), and switch_address_bl_check_cont().

2165 {
2166  struct NeighbourMapEntry *n;
2167 
2168  if (0 ==
2169  memcmp (&GST_my_identity,
2170  peer,
2171  sizeof (struct GNUNET_PeerIdentity)))
2172  {
2174  "Cowardly refusing to consider myself my neighbour!\n");
2175  return NULL;
2176  }
2178  "Creating new neighbour entry for `%s'\n",
2179  GNUNET_i2s (peer));
2180  n = GNUNET_new (struct NeighbourMapEntry);
2181  n->id = *peer;
2182  n->ack_state = ACK_UNDEFINED;
2187  n,
2196  &n->id,
2197  n,
2200  peer,
2201  0);
2202 
2203  return n;
2204 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
static struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Hash map from peer identities to the respective struct NeighbourMapEntry.
void GNUNET_BANDWIDTH_tracker_init(struct GNUNET_BANDWIDTH_Tracker *av, GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, void *update_cb_cls, struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, uint32_t max_carry_s)
Initialize bandwidth tracker.
Definition: bandwidth.c:302
We did not receive a SYN message for this neighbour.
struct GNUNET_BANDWIDTH_Tracker in_tracker
Tracker for inbound bandwidth.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT
Bandwidth (in/out) to assume initially (before either peer has communicated any particular preference...
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
struct GNUNET_ATS_ConnectivitySuggestHandle * GNUNET_ATS_connectivity_suggest(struct GNUNET_ATS_ConnectivityHandle *ch, const struct GNUNET_PeerIdentity *peer, uint32_t strength)
We would like to receive address suggestions for a peer.
Fresh peer or completely disconnected.
struct GNUNET_ATS_ConnectivitySuggestHandle * suggest_handle
ATS address suggest handle.
static void inbound_bw_tracker_update(void *cls)
Function called by the bandwidth tracker for a peer whenever the tracker&#39;s state changed such that we...
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_SCHEDULER_Task * task
Main task that drives this peer (timeouts, keepalives, etc.).
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
#define MAX_BANDWIDTH_CARRY_S
Number of seconds that available bandwidth carries over (can accumulate).
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
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.
struct GNUNET_ATS_ConnectivityHandle * GST_ats_connect
ATS connectivity handle.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
The identity of the host (wraps the signing key of the peer).
#define GNUNET_log(kind,...)
enum GST_ACK_State ack_state
When a peer wants to connect we have to reply to the 1st SYN message with a SYN_ACK message...
struct GNUNET_BANDWIDTH_Value32NBO neighbour_receive_quota
Latest quota the other peer send us in bytes per second.
static void master_task(void *cls)
Master task run for every neighbour.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_TIME_Absolute last_util_transmission
Date of last utilization transmission.
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
messagepossibly a struct TransportSynMessage (check format)
peeridentity of the peer to switch the address for
Returns
GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

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

References _, ACK_SEND_ACK, ACK_SEND_SYN_ACK, NeighbourMapEntry::ack_state, NeighbourAddress::address, ATS_RESPONSE_TIMEOUT, NeighbourMapEntry::connect_ack_timestamp, free_neighbour(), gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_ps2s(), GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TRANSPORT_PS_DISCONNECT, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TRANSPORT_PS_RECONNECT_ATS, GNUNET_TRANSPORT_PS_RECONNECT_SENT, GNUNET_TRANSPORT_PS_SWITCH_SYN_SENT, GNUNET_TRANSPORT_PS_SYN_RECV_ACK, GNUNET_TRANSPORT_PS_SYN_RECV_ATS, GNUNET_TRANSPORT_PS_SYN_SENT, GST_my_identity, GST_stats, lookup_neighbour(), NeighbourMapEntry::primary_address, print_ack_state(), TransportSynMessage::reserved, send_syn_ack_message(), NeighbourAddress::session, set_state_and_timeout(), setup_neighbour(), GNUNET_MessageHeader::size, NeighbourMapEntry::state, and TransportSynMessage::timestamp.

Referenced by connect_bl_check_cont().

2250 {
2251  const struct TransportSynMessage *scm;
2252  struct NeighbourMapEntry *n;
2253  struct GNUNET_TIME_Absolute ts;
2254 
2255  if (ntohs (message->size) != sizeof (struct TransportSynMessage))
2256  {
2257  GNUNET_break_op (0);
2258  return GNUNET_SYSERR;
2259  }
2261  gettext_noop
2262  ("# SYN messages received"),
2263  1, GNUNET_NO);
2264  if (NULL == neighbours)
2265  {
2267  _("SYN request from peer `%s' ignored due impending shutdown\n"),
2268  GNUNET_i2s (peer));
2269  return GNUNET_OK; /* we're shutting down */
2270  }
2271  scm = (const struct TransportSynMessage *) message;
2272  GNUNET_break_op (0 == ntohl (scm->reserved));
2274  if (0 ==
2275  memcmp (&GST_my_identity,
2276  peer,
2277  sizeof (struct GNUNET_PeerIdentity)))
2278  {
2279  /* loopback connection-to-self, ignore */
2280  return GNUNET_SYSERR;
2281  }
2282  n = lookup_neighbour (peer);
2283  if (NULL == n)
2284  {
2285  /* This is a new neighbour and set to not connected */
2286  n = setup_neighbour (peer);
2287  GNUNET_assert (NULL != n);
2288  }
2289 
2290  /* Remember this SYN message in neighbour */
2292  n->connect_ack_timestamp = ts;
2293 
2295  "Received SYN for peer `%s' in state %s/%s\n",
2296  GNUNET_i2s (peer),
2298  print_ack_state (n->ack_state));
2299 
2300  switch (n->state)
2301  {
2303  /* Request an address from ATS to send SYN_ACK to this peer */
2307  break;
2309  /* SYN message takes priority over us asking ATS for address:
2310  * Wait for ATS to suggest an address and send SYN_ACK */
2314  break;
2316  /* We already wait for an address to send an SYN_ACK */
2317  break;
2320  /* Send ACK immediately */
2321  n->ack_state = ACK_SEND_ACK;
2323  ts);
2324  break;
2326  /* we are already connected and can thus send the ACK immediately */
2327  GNUNET_assert (NULL != n->primary_address.address);
2328  GNUNET_assert (NULL != n->primary_address.session);
2329  n->ack_state = ACK_SEND_ACK;
2331  ts);
2332  break;
2334  /* We wait for ATS address suggestion */
2335  break;
2337  /* We received a SYN message while waiting for a SYN_ACK in fast
2338  * reconnect. Send SYN_ACK immediately */
2339  n->ack_state = ACK_SEND_ACK;
2342  break;
2344  /* We are already connected and can thus send the ACK immediately;
2345  still, it can never hurt to have an alternative address, so also
2346  tell ATS about it */
2347  GNUNET_assert (NULL != n->primary_address.address);
2348  GNUNET_assert (NULL != n->primary_address.session);
2349  n->ack_state = ACK_SEND_ACK;
2351  ts);
2352  break;
2354  /* Get rid of remains and re-try */
2355  free_neighbour (n);
2356  n = setup_neighbour (peer);
2357  GNUNET_assert (NULL != n);
2358  /* Remember the SYN time stamp for ACK message */
2360  n->connect_ack_timestamp = ts;
2361  /* Request an address for the peer */
2365  break;
2367  /* should not be possible */
2368  GNUNET_assert (0);
2369  break;
2370  default:
2372  "Unhandled state `%s'\n",
2374  GNUNET_break (0);
2375  return GNUNET_SYSERR;
2376  }
2377  return GNUNET_OK;
2378 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
static struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Hash map from peer identities to the respective struct NeighbourMapEntry.
Connection got into trouble, rest of the system still believes it to be up, but we&#39;re getting a new a...
We have some primary connection, but ATS suggested we switch to some alternative; we now sent a SYN m...
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:670
Sent SYN over new address (either by ATS telling us to switch addresses or from RECONNECT_ATS); if th...
We&#39;re finished with the disconnect; and are cleaning up the state now! We put the struct into this st...
struct GNUNET_TIME_AbsoluteNBO timestamp
Absolute time at the sender.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TIME_Absolute connect_ack_timestamp
Timestamp we should include in our next SYN_ACK message.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
Received a SYN, asking ATS about address suggestions.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static char * print_ack_state(enum GST_ACK_State s)
Convert the given ACK state to a string.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
Message a peer sends to another to indicate that it intends to setup a connection/session for data ex...
static void free_neighbour(struct NeighbourMapEntry *n)
Free a neighbour map entry.
Fresh peer or completely disconnected.
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct NeighbourAddress primary_address
Primary address we currently use to communicate with the neighbour.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_ATS_Session * session
Active session for this address.
Asked to initiate connection, trying to get address from ATS.
static struct NeighbourMapEntry * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup a neighbour entry in the neighbours hash map.
const char * GNUNET_TRANSPORT_ps2s(enum GNUNET_TRANSPORT_PeerState state)
Convert a transport state to a human readable string.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_HELLO_Address * address
Network-level address information.
Sent SYN message to other peer, waiting for SYN_ACK.
enum GNUNET_TRANSPORT_PeerState state
The current state of the peer.
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.
The neighbour sent a SYN_ACK message and has to send a ACK as reply.
The identity of the host (wraps the signing key of the peer).
static void send_syn_ack_message(struct NeighbourAddress *na, struct GNUNET_TIME_Absolute timestamp)
Send a SYN_ACK message via the given address.
Disconnect in progress (we&#39;re sending the DISCONNECT message to the other peer; after that is finishe...
#define ATS_RESPONSE_TIMEOUT
How long are we willing to wait for a response from ATS before timing out?
#define GNUNET_log(kind,...)
enum GST_ACK_State ack_state
When a peer wants to connect we have to reply to the 1st SYN message with a SYN_ACK message...
static struct NeighbourMapEntry * setup_neighbour(const struct GNUNET_PeerIdentity *peer)
Create a fresh entry in the neighbour map for the given peer.
Time for absolute times used by GNUnet, in microseconds.
The neighbour received a SYN message and has to send a SYN_ACK as reply.
Got our SYN_ACK/ACK, connection is up.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
SYN request from other peer was SYN_ACK&#39;ed, waiting for ACK.
#define gettext_noop(String)
Definition: gettext.h:69
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
addressaddress of the other peer,
sessionsession to use or NULL if transport should initiate a session
bandwidth_ininbound quota to be used when connection is up, 0 to disconnect from peer
bandwidth_outoutbound 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 2398 of file gnunet-service-transport_neighbours.c.

References 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(), GNUNET_HELLO_Address::peer, 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().

2402 {
2403  struct NeighbourMapEntry *n;
2404 
2405  n = lookup_neighbour (&address->peer);
2406  if ( (NULL == n) ||
2407  (NULL == n->primary_address.address) ||
2408  (0 != GNUNET_HELLO_address_cmp (address,
2409  n->primary_address.address)) )
2410  return GNUNET_NO;
2411  /* We are not really switching addresses, but merely adjusting
2412  session and/or bandwidth, can do fast ATS update! */
2413  if (session != n->primary_address.session)
2414  {
2415  /* switch to a different session, but keeping same address; could
2416  happen if there is a 2nd inbound connection */