gnunet-service-transport_neighbours.h File Reference

neighbour manipulation API, allows manipulation of performance metrics (delay and towards ATS) More...

#include "gnunet_statistics_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_transport_plugin.h"
#include "gnunet-service-transport.h"
#include "transport.h"
#include "gnunet_util_lib.h"

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

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

Go to the source code of this file.

Typedefs
typedef void(*	GST_NeighbourSendContinuation) (void *cls, int success, size_t bytes_payload, size_t bytes_on_wire)
	Function called after the transmission is done. More...
typedef void(*	GST_NeighbourIterator) (void *cls, 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)
	Function called for each neighbour. More...

Functions
void	GST_neighbours_start (unsigned int max_fds)
	Initialize the neighbours subsystem. More...
void	GST_neighbours_stop (void)
	Cleanup the neighbours subsystem. More...
int	GST_neighbours_test_connected (const struct GNUNET_PeerIdentity *target)
	Test if we're connected to the given peer. 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...
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_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...
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...
void	GST_neighbours_iterate (GST_NeighbourIterator cb, void *cb_cls)
	Iterate over all connected neighbours. More...
int	GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *session)
	A session was terminated. 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...
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 an existing neighbour record, set the active connection to use the given address. More...
int	GST_neighbours_handle_session_syn (const struct GNUNET_MessageHeader *message, const struct GNUNET_PeerIdentity *peer)
	We received a 'SESSION_CONNECT' message from the other peer. 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_CONNECT_ACK' message from the other peer. 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 'SESSION_ACK' message from the other peer. More...
const struct GNUNET_HELLO_Address *	GST_neighbour_get_current_address (const struct GNUNET_PeerIdentity *peer)
	Obtain current address information for the given neighbour. More...
void	GST_neighbours_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...

Detailed Description

neighbour manipulation API, allows manipulation of performance metrics (delay and towards ATS)

neighbour management API

Author

Christian Grothoff

Definition in file gnunet-service-transport_neighbours.h.

Typedef Documentation

GST_NeighbourSendContinuation

typedef void(* GST_NeighbourSendContinuation) (void *cls, int success, size_t bytes_payload, size_t bytes_on_wire)

Function called after the transmission is done.

Parameters

cls	closure
success	GNUNET_OK on success, GNUNET_NO on failure, GNUNET_SYSERR if we're not connected
bytes_payload	how much payload was transmitted
bytes_on_wire	how many bytes were used on the wire

Definition at line 71 of file gnunet-service-transport_neighbours.h.

GST_NeighbourIterator

typedef void(* GST_NeighbourIterator) (void *cls, 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)

Function called for each neighbour.

Parameters

cls	closure
peer	identity of the neighbour
address	the address of the neighbour
state	current state the peer is in
state_timeout	timeout for this state
bandwidth_in	inbound quota in NBO
bandwidth_out	outbound quota in NBO

Definition at line 159 of file gnunet-service-transport_neighbours.h.

Function Documentation

GST_neighbours_start()

void GST_neighbours_start

(

unsigned int

max_fds

)

Initialize the neighbours subsystem.

Parameters

max_fds

maximum number of fds to use

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

{
  (void) max_fds;
  neighbours = GNUNET_CONTAINER_multipeermap_create (NEIGHBOUR_TABLE_SIZE,
                                                     GNUNET_NO);
  util_transmission_tk = GNUNET_SCHEDULER_add_delayed (
    UTIL_TRANSMISSION_INTERVAL,
    &utilization_transmission,
    NULL);
}

References GNUNET_CONTAINER_multipeermap_create(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), NEIGHBOUR_TABLE_SIZE, neighbours, UTIL_TRANSMISSION_INTERVAL, util_transmission_tk, and utilization_transmission().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_stop()

void GST_neighbours_stop

(

void

)

Cleanup the neighbours subsystem.

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

{
  if (NULL == neighbours)
    return;
  if (NULL != util_transmission_tk)
  {
    GNUNET_SCHEDULER_cancel (util_transmission_tk);
    util_transmission_tk = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                         &disconnect_all_neighbours,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (neighbours);
  neighbours = NULL;
}

Referenced by shutdown_task().

Here is the caller graph for this function:

GST_neighbours_test_connected()

int GST_neighbours_test_connected

(

const struct GNUNET_PeerIdentity *

target

)

Test if we're connected to the given peer.

Parameters

target

peer to test

Returns

GNUNET_YES if we are connected, GNUNET_NO if not

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

{
  return test_connected (lookup_neighbour (target));
}

References lookup_neighbour(), and test_connected().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_send()

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

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

Parameters

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

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

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_calculate_receive_delay()

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

We have received a message from the given sender.

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

Parameters

sender	sender of the message
size	size of the message
do_forward	set to GNUNET_YES if the message should be forwarded to clients GNUNET_NO if the neighbour is not connected or violates the quota

Returns

how long to wait before reading more from this sender

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

Parameters

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

Returns

how long to wait before reading more from this sender

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

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

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

Referenced by inbound_bw_tracker_update().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_keepalive()

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

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

Parameters

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

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

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

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

Here is the call graph for this function:

GST_neighbours_keepalive_response()

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

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

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

Parameters

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

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

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

GST_neighbours_force_disconnect()

void GST_neighbours_force_disconnect

(

const struct GNUNET_PeerIdentity *

target

)

If we have an active connection to the given target, it must be shutdown.

Parameters

target

peer to disconnect from

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

{
  struct NeighbourMapEntry *n;
 
  if (NULL == (n = lookup_neighbour (target)))
    return;  /* not active */
  if (GNUNET_YES == test_connected (n))
    GNUNET_STATISTICS_update (GST_stats,
                              gettext_noop (
                                "# disconnected from peer upon explicit request"),
                              1,
                              GNUNET_NO);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Forced disconnect from peer %s\n",
              GNUNET_i2s (target));
  disconnect_neighbour (n);
}

References disconnect_neighbour(), gettext_noop, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GST_stats, lookup_neighbour(), and test_connected().

Referenced by ats_request_address_change(), and confirm_or_drop_neighbour().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_iterate()

void GST_neighbours_iterate	(	GST_NeighbourIterator	cb,
		void *	cb_cls
	)

Iterate over all connected neighbours.

Parameters

cb	function to call
cb_cls	closure for cb

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

{
  struct IteratorContext ic;
 
  if (NULL == neighbours)
    return; /* can happen during shutdown */
  ic.cb = cb;
  ic.cb_cls = cb_cls;
  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                         &neighbours_iterate,
                                         &ic);
}

References IteratorContext::cb, IteratorContext::cb_cls, GNUNET_CONTAINER_multipeermap_iterate(), neighbours, and neighbours_iterate().

Referenced by handle_client_blacklist_init(), handle_client_monitor_peers(), handle_client_start(), and process_hello_update().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_session_terminated()

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

A session was terminated.

Take note.

Parameters

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

Returns

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

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

Parameters

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

Returns

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

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

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

References NeighbourAddress::address, NeighbourMapEntry::alternative_address, ATS_RESPONSE_TIMEOUT, NeighbourMapEntry::expect_latency_response, FAST_RECONNECT_TIMEOUT, 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_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), 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, GST_ats_is_known(), GST_plugins_a2s(), lookup_neighbour(), master_task(), peer, NeighbourMapEntry::primary_address, NeighbourAddress::session, set_state_and_timeout(), NeighbourMapEntry::state, NeighbourMapEntry::task, NeighbourMapEntry::timeout, and unset_primary_address().

Referenced by plugin_env_session_end().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_notify_data_recv()

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

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

Parameters

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

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

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

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

Here is the call graph for this function:

GST_neighbours_notify_data_sent()

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

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

Parameters

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

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

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_switch_to_address()

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

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

Parameters

address	address of the other peer to start using
session	session to use (or NULL)
bandwidth_in	inbound quota to be used when connection is up
bandwidth_out	outbound quota to be used when connection is up

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

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

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

Parameters

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

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

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

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

Referenced by ats_request_address_change().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_handle_session_syn()

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

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

Consider switching to it.

Parameters

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

Returns

GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

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

Consider switching to it.

Parameters

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

Returns

GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_handle_session_syn_ack()

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

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

Consider switching to it.

Parameters

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

Returns

GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

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

Consider switching to it.

Parameters

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

Returns

GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

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

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

References GNUNET_TIME_Absolute::abs_value_us, NeighbourMapEntry::ack_state, address, NeighbourAddress::address, NeighbourMapEntry::alternative_address, NeighbourAddress::ats_active, NeighbourAddress::bandwidth_in, NeighbourAddress::bandwidth_out, NeighbourAddress::connect_timestamp, free_neighbour(), gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_address_free, 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_stats, lookup_neighbour(), NeighbourMapEntry::primary_address, print_ack_state(), TransportSynMessage::reserved, send_session_ack_message(), NeighbourAddress::session, set_primary_address(), set_state_and_timeout(), GNUNET_MessageHeader::size, NeighbourMapEntry::state, and TransportSynMessage::timestamp.

Here is the call graph for this function:

GST_neighbours_handle_session_ack()

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

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

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

Parameters

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

Returns

GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

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

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

Parameters

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

Returns

GNUNET_OK if the message was fine, GNUNET_SYSERR on serious error

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

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

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

Here is the call graph for this function:

GST_neighbour_get_current_address()

const struct GNUNET_HELLO_Address* GST_neighbour_get_current_address

(

const struct GNUNET_PeerIdentity *

peer

)

Obtain current address information for the given neighbour.

Parameters

peer

Returns

address currently used

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

{
  struct NeighbourMapEntry *n;
 
  n = lookup_neighbour (peer);
  if (NULL == n)
    return NULL;
  return n->primary_address.address;
}

References NeighbourAddress::address, lookup_neighbour(), peer, and NeighbourMapEntry::primary_address.

Referenced by handle_send_transmit_continuation().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbours_handle_quota_message()

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.

Parameters

peer	sender of the message
msg	the quota message

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

{
  struct NeighbourMapEntry *n;
  const struct GNUNET_ATS_SessionQuotaMessage *sqm;
  struct GNUNET_BANDWIDTH_Value32NBO last;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received QUOTA message from peer `%s'\n",
              GNUNET_i2s (peer));
  if (ntohs (msg->size) != sizeof(struct GNUNET_ATS_SessionQuotaMessage))
  {
    GNUNET_break_op (0);
    GNUNET_STATISTICS_update (GST_stats,
                              gettext_noop (
                                "# quota messages ignored (malformed)"),
                              1,
                              GNUNET_NO);
    return;
  }
  GNUNET_STATISTICS_update (GST_stats,
                            gettext_noop
                              ("# QUOTA messages received"),
                            1, GNUNET_NO);
  sqm = (const struct GNUNET_ATS_SessionQuotaMessage *) msg;
  if (NULL == (n = lookup_neighbour (peer)))
  {
    /* gone already */
    return;
  }
  last = GNUNET_BANDWIDTH_value_max (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
                                     GNUNET_BANDWIDTH_value_init (ntohl (
                                                                    sqm->quota)));
  if (last.value__ != n->neighbour_receive_quota.value__)
  {
    n->neighbour_receive_quota = last;
    send_outbound_quota_to_clients (n);
  }
}

References gettext_noop, GNUNET_BANDWIDTH_value_init(), GNUNET_BANDWIDTH_value_max(), GNUNET_break_op, GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GST_stats, lookup_neighbour(), msg, NeighbourMapEntry::neighbour_receive_quota, peer, GNUNET_ATS_SessionQuotaMessage::quota, send_outbound_quota_to_clients(), GNUNET_MessageHeader::size, and GNUNET_BANDWIDTH_Value32NBO::value__.

Here is the call graph for this function:

GST_neighbours_handle_disconnect_message()

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.

Parameters

peer	sender of the message
msg	the disconnect message

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

{
  struct NeighbourMapEntry *n;
  const struct GNUNET_ATS_SessionDisconnectMessage *sdm;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received DISCONNECT message from peer `%s'\n",
              GNUNET_i2s (peer));
  if (ntohs (msg->size) != sizeof(struct GNUNET_ATS_SessionDisconnectMessage))
  {
    GNUNET_break_op (0);
    GNUNET_STATISTICS_update (GST_stats,
                              gettext_noop
                                ("# disconnect messages ignored (malformed)"),
                              1,
                              GNUNET_NO);
    return;
  }
  GNUNET_STATISTICS_update (GST_stats,
                            gettext_noop
                              ("# DISCONNECT messages received"),
                            1, GNUNET_NO);
  sdm = (const struct GNUNET_ATS_SessionDisconnectMessage *) msg;
  if (NULL == (n = lookup_neighbour (peer)))
  {
    /* gone already */
    return;
  }
  if (GNUNET_TIME_absolute_ntoh (sdm->timestamp).abs_value_us <=
      n->connect_ack_timestamp.abs_value_us)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              gettext_noop (
                                "# disconnect messages ignored (timestamp)"),
                              1,
                              GNUNET_NO);
    return;
  }
  if (0 != memcmp (peer,
                   &sdm->public_key,
                   sizeof(struct GNUNET_PeerIdentity)))
  {
    GNUNET_break_op (0);
    return;
  }
  if (ntohl (sdm->purpose.size) !=
      sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
      + sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
      + sizeof(struct GNUNET_TIME_AbsoluteNBO))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "DISCONNECT message from peer `%s' has invalid size\n",
                GNUNET_i2s (peer));
    GNUNET_break_op (0);
    return;
  }
  if (GNUNET_OK !=
      GNUNET_CRYPTO_eddsa_verify_ (
        GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT,
        &sdm->purpose,
        &sdm->signature,
        &sdm->public_key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "DISCONNECT message from peer `%s' cannot be verified \n",
                GNUNET_i2s (peer));
    GNUNET_break_op (0);
    return;
  }
  if (NULL == n->delayed_disconnect_task)
  {
    n->delayed_disconnect_task = GNUNET_SCHEDULER_add_now (&delayed_disconnect,
                                                           n);
  }
}

References GNUNET_TIME_Absolute::abs_value_us, NeighbourMapEntry::connect_ack_timestamp, delayed_disconnect(), NeighbourMapEntry::delayed_disconnect_task, gettext_noop, GNUNET_break_op, GNUNET_CRYPTO_eddsa_verify_(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_ntoh(), GST_stats, lookup_neighbour(), msg, peer, GNUNET_ATS_SessionDisconnectMessage::public_key, GNUNET_ATS_SessionDisconnectMessage::purpose, GNUNET_ATS_SessionDisconnectMessage::signature, GNUNET_MessageHeader::size, GNUNET_CRYPTO_EccSignaturePurpose::size, and GNUNET_ATS_SessionDisconnectMessage::timestamp.

Here is the call graph for this function: