gnunet-service-transport.c File Reference

main for gnunet-service-transport More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_peerinfo_service.h"
#include "gnunet_ats_service.h"
#include "gnunet-service-transport.h"
#include "gnunet-service-transport_ats.h"
#include "gnunet-service-transport_hello.h"
#include "gnunet-service-transport_neighbours.h"
#include "gnunet-service-transport_plugins.h"
#include "gnunet-service-transport_validation.h"
#include "gnunet-service-transport_manipulation.h"
#include "transport.h"

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

Go to the source code of this file.

Data Structures
struct	GNUNET_ATS_SessionKiller
	Information we need for an asynchronous session kill. More...
struct	TransportClient
	Client connected to the transport service. More...
struct	GST_BlacklistCheck
	Context we use when performing a blacklist check. More...
struct	AddressToStringContext
	Context for address to string operations. More...
struct	SendTransmitContinuationContext
	Closure for handle_send_transmit_continuation() More...
struct	IterationContext
	Closure for call_iterator(). More...
struct	TestConnectionContext
	Closure for test_connection_ok(). More...

Macros
#define	TRANSPORT_BLACKLIST_HT_SIZE   64
	Size of the blacklist hash map. More...
#define	MAX_PENDING   (128 * 1024)
	How many messages can we have pending for a given client process before we start to drop incoming messages? We typically should have only one client and so this would be the primary buffer for messages, so the number should be chosen rather generously. More...

Enumerations
enum	ClientType {   CT_NONE = 0 , CT_CORE = 1 , CT_MONITOR = 2 , CT_COMMUNICATOR = 3 ,   CT_APPLICATION = 4 , CT_NONE = 0 , CT_CORE = 1 , CT_MONITOR = 2 ,   CT_BLACKLIST = 3 , CT_CORE_NO_HANDLERS = 4 }
	What type of client is the struct TransportClient about? More...

Functions
static void	unicast (struct TransportClient *tc, const struct GNUNET_MessageHeader *msg, int may_drop)
	Queue the given message for transmission to the given client. More...
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Called whenever a client connects. More...
static void	do_blacklist_check (void *cls)
	Perform next action in the blacklist check. More...
static int	mark_match_down (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
	Mark the peer as down so we don't call the continuation context in the future. More...
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	Called whenever a client is disconnected. More...
static void	notify_client_about_neighbour (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 of our connected neighbours. More...
static void	handle_client_start (void *cls, const struct StartMessage *start)
	Initialize a normal client. More...
static int	check_client_hello (void *cls, const struct GNUNET_MessageHeader *message)
	Client sent us a HELLO. More...
static void	handle_client_hello (void *cls, const struct GNUNET_MessageHeader *message)
	Client sent us a HELLO. More...
static void	handle_send_transmit_continuation (void *cls, int success, size_t bytes_payload, size_t bytes_on_wire)
	Function called after the transmission is done. More...
static int	check_client_send (void *cls, const struct OutboundMessage *obm)
	Client asked for transmission to a peer. More...
static void	handle_client_send (void *cls, const struct OutboundMessage *obm)
	Client asked for transmission to a peer. More...
static void	transmit_address_to_client (void *cls, const char *buf, int res)
	Take the given address and append it to the set of results sent back to the client. More...
static int	check_client_address_to_string (void *cls, const struct AddressLookupMessage *alum)
	Client asked to resolve an address. More...
static void	handle_client_address_to_string (void *cls, const struct AddressLookupMessage *alum)
	Client asked to resolve an address. More...
static struct PeerIterateResponseMessage *	compose_address_iterate_response_message (const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address)
	Compose PeerIterateResponseMessage using the given peer and address. More...
static void	send_peer_information (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)
	Output information of neighbours to the given client. More...
static void	handle_client_monitor_peers (void *cls, const struct PeerMonitorMessage *msg)
	Client asked to obtain information about a specific or all peers Process the request. More...
static void	plugin_session_info_cb (void *cls, struct GNUNET_ATS_Session *session, const struct GNUNET_TRANSPORT_SessionInfo *info)
	Function called by the plugin with information about the current sessions managed by the plugin (for monitoring). More...
static void	handle_client_monitor_plugins (void *cls, const struct GNUNET_MessageHeader *message)
	Client asked to obtain information about all plugin connections. More...
void	GST_clients_broadcast (const struct GNUNET_MessageHeader *msg, int may_drop)
	Broadcast the given message to all of our clients. More...
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. More...
static int	mark_peer_down (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
	Mark the peer as down so we don't call the continuation context in the future. More...
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. More...
static void	transmit_our_hello (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)
	Transmit our HELLO message to the given (connected) neighbour. More...
static void	process_hello_update (void *cls, const struct GNUNET_MessageHeader *hello)
	My HELLO has changed. More...
static struct GNUNET_TIME_Relative	process_payload (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_MessageHeader *message)
	We received some payload. More...
static void	kill_session_task (void *cls)
	Task to asynchronously terminate a session. More...
static void	kill_session (const char *plugin_name, struct GNUNET_ATS_Session *session)
	Force plugin to terminate session due to communication issue. More...
static void	connect_bl_check_cont (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, int result)
	Black list check result for try_connect call If connection to the peer is allowed request address and ??? More...
struct GNUNET_TIME_Relative	GST_receive_callback (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_MessageHeader *message)
	Function called by the transport for each received message. More...
static void	plugin_env_address_change_notification (void *cls, int add_remove, const struct GNUNET_HELLO_Address *address)
	Function that will be called for each address the transport is aware that it might be reachable under. More...
static void	plugin_env_session_end (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Function that will be called whenever the plugin internally cleans up a session pointer and hence the service needs to discard all of those sessions as well. More...
static void	plugin_env_session_start_bl_check_cont (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, int result)
	Black list check result from blacklist check triggered when a plugin gave us a new session in plugin_env_session_start(). More...
static void	plugin_env_session_start (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, enum GNUNET_NetworkType scope)
	Plugin tells transport service about a new inbound session. More...
static void	ats_request_address_change (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
	Function called by ATS to notify the callee that the assigned bandwidth or address for a given peer was changed. More...
static void	confirm_or_drop_neighbour (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, int allowed)
	Got the result about an existing connection from a new blacklister. More...
static void	test_connection_ok (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)
	Test if an existing connection is still acceptable given a new blacklisting client. More...
static void	handle_client_blacklist_init (void *cls, const struct GNUNET_MessageHeader *message)
	Initialize a blacklisting client. More...
static int	free_blacklist_entry (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Free the given entry in the blacklist. More...
static void	handle_client_set_metric (void *cls, const struct TrafficMetricMessage *tm)
	Set traffic metric to manipulate. More...
static void	shutdown_task (void *cls)
	Function called when the service shuts down. More...
static void	handle_client_blacklist_reply (void *cls, const struct BlacklistMessage *msg)
	A blacklisting client has sent us reply. More...
void	GST_blacklist_add_peer (const struct GNUNET_PeerIdentity *peer, const char *transport_name)
	Add the given peer to the blacklist (for the given transport). More...
void	GST_blacklist_abort_matching (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Abort blacklist if address and session match. More...
static int	test_blacklisted (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Test if the given blacklist entry matches. More...
struct GST_BlacklistCheck *	GST_blacklist_test_allowed (const struct GNUNET_PeerIdentity *peer, const char *transport_name, GST_BlacklistTestContinuation cont, void *cont_cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Test if a peer/transport combination is blacklisted. More...
void	GST_blacklist_test_cancel (struct GST_BlacklistCheck *bc)
	Cancel a blacklist check. More...
static void	blacklist_cfg_iter (void *cls, const char *section, const char *option, const char *value)
	Function to iterate over options in the blacklisting section for a peer. More...
static void	read_blacklist_configuration (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *my_id)
	Read blacklist configuration. More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Initiate transport service. More...
	GNUNET_SERVICE_MAIN ("transport", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(client_start, GNUNET_MESSAGE_TYPE_TRANSPORT_START, struct StartMessage, NULL), GNUNET_MQ_hd_var_size(client_hello, GNUNET_MESSAGE_TYPE_HELLO, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_var_size(client_send, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, struct OutboundMessage, NULL), GNUNET_MQ_hd_var_size(client_address_to_string, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING, struct AddressLookupMessage, NULL), GNUNET_MQ_hd_fixed_size(client_monitor_peers, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST, struct PeerMonitorMessage, NULL), GNUNET_MQ_hd_fixed_size(client_blacklist_init, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(client_blacklist_reply, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY, struct BlacklistMessage, NULL), GNUNET_MQ_hd_fixed_size(client_set_metric, GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC, struct TrafficMetricMessage, NULL), GNUNET_MQ_hd_fixed_size(client_monitor_plugins, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_START, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static struct TransportClient *	clients_head
	Head of linked list of all clients to this service. More...
static struct TransportClient *	clients_tail
	Tail of linked list of all clients to this service. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	active_stccs
	Map of peer identities to active send transmit continuation contexts. More...
static struct AddressToStringContext *	a2s_head
	Head of linked list of all pending address iterations. More...
static struct AddressToStringContext *	a2s_tail
	Tail of linked list of all pending address iterations. More...
static struct GST_BlacklistCheck *	bc_head
	Head of DLL of active blacklisting queries. More...
static struct GST_BlacklistCheck *	bc_tail
	Tail of DLL of active blacklisting queries. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	blacklist
	Hashmap of blacklisted peers. More...
static struct GNUNET_NotificationContext *	plugin_nc
	Notification context, to send updates on changes to active plugin connections. More...
static struct TransportClient *	sync_client
	Plugin monitoring client we are currently syncing, NULL if all monitoring clients are in sync. More...
static struct GNUNET_PeerIdentity	all_zeros
	Peer identity that is all zeros, used as a way to indicate "all peers". More...
struct GNUNET_STATISTICS_Handle *	GST_stats
	Statistics handle. More...
const struct GNUNET_CONFIGURATION_Handle *	GST_cfg
	Configuration handle. More...
struct GNUNET_PeerIdentity	GST_my_identity
	Configuration handle. More...
struct GNUNET_PEERINFO_Handle *	GST_peerinfo
	Handle to peerinfo service. More...
struct GNUNET_CRYPTO_EddsaPrivateKey	GST_my_private_key
	Our private key. More...
struct GNUNET_ATS_SchedulingHandle *	GST_ats
	ATS scheduling handle. More...
struct GNUNET_ATS_ConnectivityHandle *	GST_ats_connect
	ATS connectivity handle. More...
struct GNUNET_TIME_Relative	hello_expiration
	Hello address expiration. More...
static struct GNUNET_ATS_SessionKiller *	sk_head
	Head of DLL of asynchronous tasks to kill sessions. More...
static struct GNUNET_ATS_SessionKiller *	sk_tail
	Tail of DLL of asynchronous tasks to kill sessions. More...
struct GNUNET_NT_InterfaceScanner *	GST_is
	Interface scanner determines our LAN address range(s). More...

Detailed Description

main for gnunet-service-transport

Author

Christian Grothoff

Definition in file gnunet-service-transport.c.

Macro Definition Documentation

TRANSPORT_BLACKLIST_HT_SIZE

#define TRANSPORT_BLACKLIST_HT_SIZE   64

Size of the blacklist hash map.

Definition at line 44 of file gnunet-service-transport.c.

MAX_PENDING

#define MAX_PENDING   (128 * 1024)

How many messages can we have pending for a given client process before we start to drop incoming messages? We typically should have only one client and so this would be the primary buffer for messages, so the number should be chosen rather generously.

The expectation here is that most of the time the queue is large enough so that a drop is virtually never required. Note that this value must be about as large as 'TOTAL_MSGS' in the 'test_transport_api_reliability.c', otherwise that testcase may fail.

Definition at line 58 of file gnunet-service-transport.c.

Enumeration Type Documentation

ClientType

enum ClientType

What type of client is the struct TransportClient about?

Enumerator
CT_NONE	We do not know yet (client is fresh).
CT_CORE	Is the CORE service, we need to forward traffic to it.
CT_MONITOR	It is a monitor, forward monitor data.
CT_COMMUNICATOR	It is a communicator, use for communication.
CT_APPLICATION	"Application" telling us where to connect (i.e. TOPOLOGY, DHT or CADET).
CT_NONE	We do not know yet (client is fresh).
CT_CORE	Is the CORE service, we need to forward traffic to it.
CT_MONITOR	It is a monitor, forward monitor data.
CT_BLACKLIST	It is a blacklist, query about allowed connections.
CT_CORE_NO_HANDLERS	CORE client without any handlers.

Definition at line 96 of file gnunet-service-transport.c.

{
  CT_NONE = 0,
 
  CT_CORE = 1,
 
  CT_MONITOR = 2,
 
  CT_BLACKLIST = 3,
 
  CT_CORE_NO_HANDLERS = 4
};

Function Documentation

unicast()

static void unicast ( struct TransportClient *  tc, const struct GNUNET_MessageHeader *  msg, int  may_drop  )

static

Queue the given message for transmission to the given client.

Parameters

tc	target of the message
msg	message to transmit
may_drop	GNUNET_YES if the message can be dropped

Definition at line 427 of file gnunet-service-transport.c.

{
  struct GNUNET_MQ_Envelope *env;
 
  if ((GNUNET_MQ_get_length (tc->mq) >= MAX_PENDING) &&
      (GNUNET_YES == may_drop))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "Dropping message of type %u and size %u, have %u/%u messages pending\n",
      ntohs (msg->type),
      ntohs (msg->size),
      GNUNET_MQ_get_length (tc->mq),
      MAX_PENDING);
    GNUNET_STATISTICS_update (GST_stats,
                              gettext_noop (
                                "# messages dropped due to slow client"),
                              1,
                              GNUNET_NO);
    return;
  }
  env = GNUNET_MQ_msg_copy (msg);
  GNUNET_MQ_send (tc->mq, env);
}

References env, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_get_length(), GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GST_stats, MAX_PENDING, msg, GNUNET_MessageHeader::size, tc, and GNUNET_MessageHeader::type.

Referenced by broadcast_status(), GST_clients_broadcast(), handle_client_start(), handle_send_transmit_continuation(), and notify_client_about_neighbour().

Here is the call graph for this function:

Here is the caller graph for this function:

client_connect_cb()

static void* client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, struct GNUNET_MQ_Handle *  mq  )

static

Called whenever a client connects.

Allocates our data structures associated with that client.

Parameters

cls	closure, NULL
client	identification of the client
mq	message queue for the client

Returns

our struct TransportClient

Definition at line 465 of file gnunet-service-transport.c.

{
  struct TransportClient *tc;
 
  tc = GNUNET_new (struct TransportClient);
  tc->client = client;
  tc->mq = mq;
  GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", tc);
  return tc;
}

References TransportClient::client, clients_head, clients_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, mq, and tc.

do_blacklist_check()

static void do_blacklist_check ( void *  cls )

static

Perform next action in the blacklist check.

Parameters

cls	the struct GST_BlacklistCheck *

Definition at line 2193 of file gnunet-service-transport.c.

{
  struct GST_BlacklistCheck *bc = cls;
  struct TransportClient *tc;
  struct GNUNET_MQ_Envelope *env;
  struct BlacklistMessage *bm;
 
  bc->task = NULL;
  while (NULL != (tc = bc->bl_pos))
  {
    if (CT_BLACKLIST == tc->type)
      break;
    bc->bl_pos = tc->next;
  }
  if (NULL == tc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No other blacklist clients active, will allow neighbour `%s'\n",
                GNUNET_i2s (&bc->peer));
 
    bc->cont (bc->cont_cls, &bc->peer, bc->address, bc->session, GNUNET_OK);
    GST_blacklist_test_cancel (bc);
    return;
  }
  if ((NULL != tc->details.blacklist.bc) ||
      (GNUNET_NO != tc->details.blacklist.waiting_for_reply))
    return; /* someone else busy with this client */
  tc->details.blacklist.bc = bc;
  env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY);
  bm->is_allowed = htonl (0);
  bm->peer = bc->peer;
  GNUNET_MQ_send (tc->mq, env);
  if (GNUNET_YES == tc->details.blacklist.call_receive_done)
  {
    tc->details.blacklist.call_receive_done = GNUNET_NO;
    GNUNET_SERVICE_client_continue (tc->client);
  }
  tc->details.blacklist.waiting_for_reply = GNUNET_YES;
}

References GST_BlacklistCheck::address, GST_BlacklistCheck::bl_pos, GST_BlacklistCheck::cont, GST_BlacklistCheck::cont_cls, CT_BLACKLIST, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_YES, GST_blacklist_test_cancel(), BlacklistMessage::is_allowed, GST_BlacklistCheck::peer, BlacklistMessage::peer, GST_BlacklistCheck::session, GST_BlacklistCheck::task, and tc.

Referenced by client_disconnect_cb(), GST_blacklist_test_allowed(), handle_client_blacklist_reply(), and test_connection_ok().

Here is the call graph for this function:

Here is the caller graph for this function:

mark_match_down()

static int mark_match_down ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  value  )

static

Mark the peer as down so we don't call the continuation context in the future.

Parameters

cls	a struct TransportClient
peer	a peer we are sending to
value	a struct SendTransmitContinuationContext to mark

Returns

GNUNET_OK (continue to iterate)

Definition at line 499 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
  struct SendTransmitContinuationContext *stcc = value;
 
  if (tc == stcc->tc)
  {
    stcc->down = GNUNET_YES;
    stcc->tc = NULL;
  }
  return GNUNET_OK;
}

References SendTransmitContinuationContext::down, GNUNET_OK, GNUNET_YES, SendTransmitContinuationContext::tc, tc, and value.

Referenced by client_disconnect_cb().

Here is the caller graph for this function:

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, void *  app_ctx  )

static

Called whenever a client is disconnected.

Frees our resources associated with that client.

Parameters

cls	closure, NULL
client	identification of the client
app_ctx	our struct TransportClient

Definition at line 522 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = app_ctx;
  struct GST_BlacklistCheck *bc;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p disconnected, cleaning up.\n",
              tc);
  if (NULL != active_stccs)
    GNUNET_CONTAINER_multipeermap_iterate (active_stccs,
                                           &mark_match_down,
                                           tc);
  for (struct AddressToStringContext *cur = a2s_head; NULL != cur;
       cur = cur->next)
  {
    if (cur->tc == tc)
      cur->tc = NULL;
  }
  GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, tc);
  switch (tc->type)
  {
  case CT_NONE:
    break;
 
  case CT_CORE:
    break;
 
  case CT_MONITOR:
    break;
 
  case CT_BLACKLIST:
    for (bc = bc_head; NULL != bc; bc = bc->next)
    {
      if (bc->bl_pos != tc)
        continue;
      bc->bl_pos = tc->next;
      if (NULL == bc->task)
        bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
    }
    break;
 
  case CT_CORE_NO_HANDLERS:
    break;
  }
  GNUNET_free (tc);
}

References a2s_head, active_stccs, bc_head, GST_BlacklistCheck::bl_pos, clients_head, clients_tail, CT_BLACKLIST, CT_CORE, CT_CORE_NO_HANDLERS, CT_MONITOR, CT_NONE, do_blacklist_check(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_add_now(), mark_match_down(), GST_BlacklistCheck::next, AddressToStringContext::next, GST_BlacklistCheck::task, and tc.

Here is the call graph for this function:

notify_client_about_neighbour()

static void notify_client_about_neighbour ( 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  )

static

Function called for each of our connected neighbours.

Notify the client about the existing neighbour.

Parameters

cls	the struct TransportClient * to notify
peer	identity of the neighbour
address	the address
state	the current state of the peer
state_timeout	the time out for the state
bandwidth_in	inbound bandwidth in NBO
bandwidth_out	outbound bandwidth in NBO

Definition at line 585 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
  struct ConnectInfoMessage cim;
 
  if (GNUNET_NO == GST_neighbours_test_connected (peer))
    return;
  cim.header.size = htons (sizeof(struct ConnectInfoMessage));
  cim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
  cim.id = *peer;
  cim.quota_out = bandwidth_out;
  unicast (tc, &cim.header, GNUNET_NO);
}

References GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT, GNUNET_NO, GST_neighbours_test_connected(), ConnectInfoMessage::header, ConnectInfoMessage::id, peer, ConnectInfoMessage::quota_out, GNUNET_MessageHeader::size, tc, GNUNET_MessageHeader::type, and unicast().

Referenced by handle_client_start().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_client_start()

static void handle_client_start ( void *  cls, const struct StartMessage *  start  )

static

Initialize a normal client.

We got a start message from this client, add it to the list of clients for broadcasting of inbound messages.

Parameters

cls	the client
start	the start message that was sent

Definition at line 615 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
  const struct GNUNET_MessageHeader *hello;
  uint32_t options;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p sent START\n", tc);
  options = ntohl (start->options);
  if ((0 != (1 & options)) &&
      (0 != memcmp (&start->self,
                    &GST_my_identity,
                    sizeof(struct GNUNET_PeerIdentity))))
  {
    /* client thinks this is a different peer, reject */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  if (0 != (2 & options))
    tc->type = CT_CORE;
  else
    tc->type = CT_CORE_NO_HANDLERS;
  hello = GST_hello_get ();
  if (NULL != hello)
    unicast (tc, hello, GNUNET_NO);
  GST_neighbours_iterate (&notify_client_about_neighbour, tc);
  GNUNET_SERVICE_client_continue (tc->client);
}

References CT_CORE, CT_CORE_NO_HANDLERS, CT_NONE, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GST_hello_get(), GST_my_identity, GST_neighbours_iterate(), notify_client_about_neighbour(), options, start, tc, and unicast().

Here is the call graph for this function:

check_client_hello()

static int check_client_hello ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Client sent us a HELLO.

Check the request.

Parameters

cls	the client
message	the HELLO message

Definition at line 658 of file gnunet-service-transport.c.

{
  return GNUNET_OK; /* FIXME: check here? */
}

References GNUNET_OK.

handle_client_hello()

static void handle_client_hello ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Client sent us a HELLO.

Process the request.

Parameters

cls	the client
message	the HELLO message

Definition at line 671 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Received HELLO message\n");
  GST_validation_handle_hello (message);
  GNUNET_SERVICE_client_continue (tc->client);
}

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SERVICE_client_continue(), GST_validation_handle_hello(), and tc.

Here is the call graph for this function:

handle_send_transmit_continuation()

static void handle_send_transmit_continuation ( void *  cls, int  success, size_t  bytes_payload, size_t  bytes_on_wire  )

static

Function called after the transmission is done.

Notify the client that it is OK to send the next message.

Parameters

cls	closure
success	GNUNET_OK on success, GNUNET_NO on failure, GNUNET_SYSERR if we're not connected
bytes_payload	bytes payload sent
bytes_on_wire	bytes sent on wire

Definition at line 691 of file gnunet-service-transport.c.

{
  struct SendTransmitContinuationContext *stcc = cls;
  struct SendOkMessage send_ok_msg;
#ifdef ENABLE_TTD
  struct GNUNET_TIME_Relative delay;
  const struct GNUNET_HELLO_Address *addr;
 
  delay = GNUNET_TIME_absolute_get_duration (stcc->send_time);
  addr = GST_neighbour_get_current_address (&stcc->target);
 
  if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "It took us %s to send %u/%u bytes to %s (%d, %s)\n",
                GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
                (unsigned int) bytes_payload,
                (unsigned int) bytes_on_wire,
                GNUNET_i2s (&stcc->target),
                success,
                (NULL != addr) ? addr->transport_name : "%");
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "It took us %s to send %u/%u bytes to %s (%d, %s)\n",
                GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
                (unsigned int) bytes_payload,
                (unsigned int) bytes_on_wire,
                GNUNET_i2s (&stcc->target),
                success,
                (NULL != addr) ? addr->transport_name : "%");
#endif
 
  if (GNUNET_NO == stcc->down)
  {
    /* Only send confirmation if we are still connected */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending SEND_OK for transmission request %llu\n",
                stcc->uuid);
    send_ok_msg.header.size = htons (sizeof(send_ok_msg));
    send_ok_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
    send_ok_msg.bytes_msg = htons (bytes_payload);
    send_ok_msg.bytes_physical = htonl (bytes_on_wire);
    send_ok_msg.success = htons (success);
    send_ok_msg.peer = stcc->target;
    unicast (stcc->tc, &send_ok_msg.header, GNUNET_NO);
  }
  GNUNET_assert (
    GNUNET_OK ==
    GNUNET_CONTAINER_multipeermap_remove (active_stccs, &stcc->target, stcc));
  GNUNET_free (stcc);
}

References active_stccs, SendOkMessage::bytes_msg, SendOkMessage::bytes_physical, delay, SendTransmitContinuationContext::down, GNUNET_assert, GNUNET_CONSTANTS_LATENCY_WARN, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, GST_neighbour_get_current_address(), SendOkMessage::header, SendOkMessage::peer, GNUNET_TIME_Relative::rel_value_us, SendTransmitContinuationContext::send_time, GNUNET_MessageHeader::size, SendOkMessage::success, SendTransmitContinuationContext::target, SendTransmitContinuationContext::tc, GNUNET_HELLO_Address::transport_name, GNUNET_MessageHeader::type, unicast(), and SendTransmitContinuationContext::uuid.

Referenced by handle_client_send().

Here is the call graph for this function:

Here is the caller graph for this function:

check_client_send()

static int check_client_send ( void *  cls, const struct OutboundMessage *  obm  )

static

Client asked for transmission to a peer.

Process the request.

Parameters

cls	the client
obm	the send message that was sent

Definition at line 753 of file gnunet-service-transport.c.

{
  uint16_t size;
  const struct GNUNET_MessageHeader *obmm;
 
  size = ntohs (obm->header.size) - sizeof(struct OutboundMessage);
  if (size < sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
  if (size != ntohs (obmm->size))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, OutboundMessage::header, GNUNET_MessageHeader::size, and size.

handle_client_send()

static void handle_client_send ( void *  cls, const struct OutboundMessage *  obm  )

static

Client asked for transmission to a peer.

Process the request.

Parameters

cls	the client
obm	the send message that was sent

Definition at line 781 of file gnunet-service-transport.c.

{
  static unsigned long long uuid_gen;
  struct TransportClient *tc = cls;
  const struct GNUNET_MessageHeader *obmm;
  struct SendTransmitContinuationContext *stcc;
 
  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
  if (GNUNET_NO == GST_neighbours_test_connected (&obm->peer))
  {
    /* not connected, not allowed to send; can happen due to asynchronous operations */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Could not send message to peer `%s': not connected\n",
                GNUNET_i2s (&obm->peer));
    GNUNET_STATISTICS_update (
      GST_stats,
      gettext_noop ("# bytes payload dropped (other peer was not connected)"),
      ntohs (obmm->size),
      GNUNET_NO);
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Received SEND request %llu for `%s' and first message of type %u and total size %u\n",
    uuid_gen,
    GNUNET_i2s (&obm->peer),
    ntohs (obmm->type),
    ntohs (obmm->size));
  GNUNET_SERVICE_client_continue (tc->client);
 
  stcc = GNUNET_new (struct SendTransmitContinuationContext);
  stcc->target = obm->peer;
  stcc->tc = tc;
  stcc->send_time = GNUNET_TIME_absolute_get ();
  stcc->uuid = uuid_gen++;
  (void) GNUNET_CONTAINER_multipeermap_put (
    active_stccs,
    &stcc->target,
    stcc,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  GST_manipulation_send (&obm->peer,
                         obmm,
                         ntohs (obmm->size),
                         GNUNET_TIME_relative_ntoh (obm->timeout),
                         &handle_send_transmit_continuation,
                         stcc);
}

References active_stccs, gettext_noop, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_ntoh(), GST_manipulation_send(), GST_neighbours_test_connected(), GST_stats, handle_send_transmit_continuation(), OutboundMessage::peer, SendTransmitContinuationContext::send_time, GNUNET_MessageHeader::size, SendTransmitContinuationContext::target, SendTransmitContinuationContext::tc, tc, OutboundMessage::timeout, GNUNET_MessageHeader::type, and SendTransmitContinuationContext::uuid.

Here is the call graph for this function:

transmit_address_to_client()

static void transmit_address_to_client ( void *  cls, const char *  buf, int  res  )

static

Take the given address and append it to the set of results sent back to the client.

This function may be called several times for a single conversion. The last invocation will be with a address of NULL and a res of GNUNET_OK. Thus, to indicate conversion errors, the callback might be called first with address NULL and res being GNUNET_SYSERR. In that case, there will still be a subsequent call later with address NULL and res GNUNET_OK.

Parameters

cls	the struct AddressToStringContext
buf	text to transmit (contains the human-readable address, or NULL)
res	GNUNET_OK if conversion was successful, GNUNET_SYSERR on error, never GNUNET_NO

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

{
  struct AddressToStringContext *actx = cls;
  struct GNUNET_MQ_Envelope *env;
  struct AddressToStringResultMessage *atsm;
  size_t slen;
 
  GNUNET_assert ((GNUNET_OK == res) || (GNUNET_SYSERR == res));
  if (NULL == actx->tc)
    return;
  if (NULL == buf)
  {
    env = GNUNET_MQ_msg (atsm,
                         GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
    if (GNUNET_OK == res)
    {
      /* this was the last call, transmit */
      atsm->res = htonl (GNUNET_OK);
      atsm->addr_len = htonl (0);
      GNUNET_MQ_send (actx->tc->mq, env);
      GNUNET_CONTAINER_DLL_remove (a2s_head, a2s_tail, actx);
      GNUNET_free (actx);
      return;
    }
    if (GNUNET_SYSERR == res)
    {
      /* address conversion failed, but there will be more callbacks */
      atsm->res = htonl (GNUNET_SYSERR);
      atsm->addr_len = htonl (0);
      GNUNET_MQ_send (actx->tc->mq, env);
      return;
    }
  }
  GNUNET_assert (GNUNET_OK == res);
  /* successful conversion, append*/
  slen = strlen (buf) + 1;
  env =
    GNUNET_MQ_msg_extra (atsm,
                         slen,
                         GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
  atsm->res = htonl (GNUNET_YES);
  atsm->addr_len = htonl (slen);
  GNUNET_memcpy (&atsm[1], buf, slen);
  GNUNET_MQ_send (actx->tc->mq, env);
}

References a2s_head, a2s_tail, AddressToStringResultMessage::addr_len, buf, env, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY, GNUNET_MQ_msg, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, TransportClient::mq, res, AddressToStringResultMessage::res, and AddressToStringContext::tc.

Referenced by handle_client_address_to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

check_client_address_to_string()

static int check_client_address_to_string ( void *  cls, const struct AddressLookupMessage *  alum  )

static

Client asked to resolve an address.

Check the request.

Parameters

cls	the client
alum	the resolution request

Returns

GNUNET_OK if alum is well-formed

Definition at line 901 of file gnunet-service-transport.c.

{
  const char *plugin_name;
  const char *address;
  uint32_t address_len;
  uint16_t size;
 
  size = ntohs (alum->header.size);
  address_len = ntohs (alum->addrlen);
  if (size <= sizeof(struct AddressLookupMessage) + address_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  address = (const char *) &alum[1];
  plugin_name = (const char *) &address[address_len];
  if ('\0' != plugin_name[size - sizeof(struct AddressLookupMessage)
                          - address_len - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References address, AddressLookupMessage::addrlen, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, AddressLookupMessage::header, plugin_name, GNUNET_MessageHeader::size, and size.

handle_client_address_to_string()

static void handle_client_address_to_string ( void *  cls, const struct AddressLookupMessage *  alum  )

static

Client asked to resolve an address.

Process the request.

Parameters

cls	the client
alum	the resolution request

Definition at line 935 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
  struct GNUNET_TRANSPORT_PluginFunctions *papi;
  const char *plugin_name;
  const char *address;
  uint32_t address_len;
  struct AddressToStringContext *actx;
  struct GNUNET_MQ_Envelope *env;
  struct AddressToStringResultMessage *atsm;
  struct GNUNET_TIME_Relative rtimeout;
  int32_t numeric;
 
  address_len = ntohs (alum->addrlen);
  address = (const char *) &alum[1];
  plugin_name = (const char *) &address[address_len];
  rtimeout = GNUNET_TIME_relative_ntoh (alum->timeout);
  numeric = ntohs (alum->numeric_only);
  papi = GST_plugins_printer_find (plugin_name);
  if (NULL == papi)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Failed to find plugin `%s'\n",
                plugin_name);
    env = GNUNET_MQ_msg (atsm,
                         GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
    atsm->res = htonl (GNUNET_SYSERR);
    atsm->addr_len = htonl (0);
    GNUNET_MQ_send (tc->mq, env);
    env = GNUNET_MQ_msg (atsm,
                         GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
    atsm->res = htonl (GNUNET_OK);
    atsm->addr_len = htonl (0);
    GNUNET_MQ_send (tc->mq, env);
    return;
  }
  actx = GNUNET_new (struct AddressToStringContext);
  actx->tc = tc;
  GNUNET_CONTAINER_DLL_insert (a2s_head, a2s_tail, actx);
  GNUNET_SERVICE_client_disable_continue_warning (tc->client);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Pretty-printing address of %u bytes using plugin `%s'\n",
              address_len,
              plugin_name);
  papi->address_pretty_printer (papi->cls,
                                plugin_name,
                                address,
                                address_len,
                                numeric,
                                rtimeout,
                                &transmit_address_to_client,
                                actx);
}

References a2s_head, a2s_tail, AddressToStringResultMessage::addr_len, address, GNUNET_TRANSPORT_PluginFunctions::address_pretty_printer, AddressLookupMessage::addrlen, GNUNET_TRANSPORT_PluginFunctions::cls, env, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_OK, GNUNET_SERVICE_client_disable_continue_warning(), GNUNET_SYSERR, GNUNET_TIME_relative_ntoh(), GST_plugins_printer_find(), numeric, AddressLookupMessage::numeric_only, plugin_name, AddressToStringResultMessage::res, AddressToStringContext::tc, tc, AddressLookupMessage::timeout, and transmit_address_to_client().

Here is the call graph for this function:

compose_address_iterate_response_message()

static struct PeerIterateResponseMessage* compose_address_iterate_response_message ( const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_HELLO_Address *  address  )

static

Compose PeerIterateResponseMessage using the given peer and address.

Parameters

peer	identity of the peer
address	the address, NULL on disconnect

Returns

composed message

Definition at line 999 of file gnunet-service-transport.c.

{
  struct PeerIterateResponseMessage *msg;
  size_t size;
  size_t tlen;
  size_t alen;
  char *addr;
 
  GNUNET_assert (NULL != peer);
  if (NULL != address)
  {
    tlen = strlen (address->transport_name) + 1;
    alen = address->address_length;
  }
  else
  {
    tlen = 0;
    alen = 0;
  }
  size = (sizeof(struct PeerIterateResponseMessage) + alen + tlen);
  msg = GNUNET_malloc (size);
  msg->header.size = htons (size);
  msg->header.type =
    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE);
  msg->reserved = htonl (0);
  msg->peer = *peer;
  msg->addrlen = htonl (alen);
  msg->pluginlen = htonl (tlen);
 
  if (NULL != address)
  {
    msg->local_address_info = htonl ((uint32_t) address->local_info);
    addr = (char *) &msg[1];
    GNUNET_memcpy (addr, address->address, alen);
    GNUNET_memcpy (&addr[alen], address->transport_name, tlen);
  }
  return msg;
}

References address, GNUNET_assert, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE, msg, peer, GNUNET_MessageHeader::size, size, and GNUNET_MessageHeader::type.

Referenced by GST_clients_broadcast_peer_notification(), and send_peer_information().

Here is the caller graph for this function:

send_peer_information()

static void send_peer_information ( 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  )

static

Output information of neighbours to the given client.

Parameters

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

Definition at line 1076 of file gnunet-service-transport.c.

{
  struct IterationContext *pc = cls;
  struct GNUNET_MQ_Envelope *env;
  struct PeerIterateResponseMessage *msg;
 
  if ((GNUNET_YES != pc->all) && (0 != memcmp (peer, &pc->id, sizeof(pc->id))))
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending information about `%s' using address `%s' in state `%s'\n",
              GNUNET_i2s (peer),
              (NULL != address) ? GST_plugins_a2s (address) : "<none>",
              GNUNET_TRANSPORT_ps2s (state));
  msg = compose_address_iterate_response_message (peer, address);
  msg->state = htonl (state);
  msg->state_timeout = GNUNET_TIME_absolute_hton (state_timeout);
  env = GNUNET_MQ_msg_copy (&msg->header);
  GNUNET_free (msg);
  GNUNET_MQ_send (pc->tc->mq, env);
}

References address, compose_address_iterate_response_message(), env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_TIME_absolute_hton(), GNUNET_TRANSPORT_ps2s(), GNUNET_YES, GST_plugins_a2s(), GNUNET_FS_PublishContext::mq, msg, pc, peer, state, and PeerIterateResponseMessage::state_timeout.

Referenced by handle_client_monitor_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_client_monitor_peers()

static void handle_client_monitor_peers ( void *  cls, const struct PeerMonitorMessage *  msg  )

static

Client asked to obtain information about a specific or all peers Process the request.

Parameters

cls	the client
msg	the peer address information request

Definition at line 1112 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
  struct IterationContext pc;
 
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  GNUNET_SERVICE_client_disable_continue_warning (tc->client);
  GNUNET_SERVICE_client_mark_monitor (tc->client);
 
  /* Send initial list */
  pc.tc = tc;
  if (0 == memcmp (&msg->peer, &all_zeros, sizeof(struct GNUNET_PeerIdentity)))
  {
    /* iterate over all neighbours */
    pc.all = GNUNET_YES;
    pc.id = msg->peer;
  }
  else
  {
    /* just return one neighbour */
    pc.all = GNUNET_NO;
    pc.id = msg->peer;
  }
  GST_neighbours_iterate (&send_peer_information, &pc);
 
  if (GNUNET_YES != ntohl (msg->one_shot))
  {
    tc->details.monitor_peer = msg->peer;
    tc->type = CT_MONITOR;
    if (0 !=
        memcmp (&msg->peer, &all_zeros, sizeof(struct GNUNET_PeerIdentity)))
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Client %p started monitoring of the peer `%s'\n",
                  tc,
                  GNUNET_i2s (&msg->peer));
    else
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Client %p started monitoring all peers\n",
                  tc);
  }
  else
  {
    struct GNUNET_MessageHeader *msg;
    struct GNUNET_MQ_Envelope *env;
 
    env =
      GNUNET_MQ_msg (msg,
                     GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END);
    GNUNET_MQ_send (tc->mq, env);
  }
}

References all_zeros, CT_MONITOR, CT_NONE, env, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_disable_continue_warning(), GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_mark_monitor(), GNUNET_YES, GST_neighbours_iterate(), msg, pc, send_peer_information(), and tc.

Here is the call graph for this function:

plugin_session_info_cb()

static void plugin_session_info_cb ( void *  cls, struct GNUNET_ATS_Session *  session, const struct GNUNET_TRANSPORT_SessionInfo *  info  )

static

Function called by the plugin with information about the current sessions managed by the plugin (for monitoring).

Parameters

cls	closure
session	session handle this information is about, NULL to indicate that we are "in sync" (initial iteration complete)
info	information about the state of the session, NULL if session is also NULL and we are merely signalling that the initial iteration is over

Definition at line 1183 of file gnunet-service-transport.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct TransportPluginMonitorMessage *msg;
  struct GNUNET_MessageHeader *sync;
  size_t size;
  size_t slen;
  uint16_t alen;
  char *name;
  char *addr;
 
  if (0 == GNUNET_notification_context_get_size (plugin_nc))
  {
    GST_plugins_monitor_subscribe (NULL, NULL);
    return;
  }
  if ((NULL == info) && (NULL == session))
  {
    /* end of initial iteration */
    if (NULL != sync_client)
    {
      env =
        GNUNET_MQ_msg (sync, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_SYNC);
      GNUNET_MQ_send (sync_client->mq, env);
      sync_client = NULL;
    }
    return;
  }
  GNUNET_assert (NULL != info);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Plugin event for peer %s on transport %s\n",
              GNUNET_i2s (&info->address->peer),
              info->address->transport_name);
  slen = strlen (info->address->transport_name) + 1;
  alen = info->address->address_length;
  size = sizeof(struct TransportPluginMonitorMessage) + slen + alen;
  if (size > UINT16_MAX)
  {
    GNUNET_break (0);
    return;
  }
  msg = GNUNET_malloc (size);
  msg->header.size = htons (size);
  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT);
  msg->session_state = htons ((uint16_t) info->state);
  msg->is_inbound = htons ((int16_t) info->is_inbound);
  msg->msgs_pending = htonl (info->num_msg_pending);
  msg->bytes_pending = htonl (info->num_bytes_pending);
  msg->timeout = GNUNET_TIME_absolute_hton (info->session_timeout);
  msg->delay = GNUNET_TIME_absolute_hton (info->receive_delay);
  msg->peer = info->address->peer;
  msg->session_id = (uint64_t) (intptr_t) session;
  msg->plugin_name_len = htons (slen);
  msg->plugin_address_len = htons (alen);
  name = (char *) &msg[1];
  GNUNET_memcpy (name, info->address->transport_name, slen);
  addr = &name[slen];
  GNUNET_memcpy (addr, info->address->address, alen);
  if (NULL != sync_client)
  {
    struct GNUNET_MQ_Envelope *env;
 
    env = GNUNET_MQ_msg_copy (&msg->header);
    GNUNET_MQ_send (sync_client->mq, env);
  }
  else
  {
    GNUNET_notification_context_broadcast (plugin_nc, &msg->header, GNUNET_NO);
  }
  GNUNET_free (msg);
}

References env, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_SYNC, GNUNET_MQ_msg, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_notification_context_broadcast(), GNUNET_notification_context_get_size(), GNUNET_TIME_absolute_hton(), GST_plugins_monitor_subscribe(), info, TransportClient::mq, msg, name, plugin_nc, GNUNET_MessageHeader::size, size, sync_client, and GNUNET_MessageHeader::type.

Referenced by handle_client_monitor_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_client_monitor_plugins()

static void handle_client_monitor_plugins ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Client asked to obtain information about all plugin connections.

Parameters

cls	the client
message	the peer address information request

Definition at line 1265 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
 
  GNUNET_SERVICE_client_mark_monitor (tc->client);
  GNUNET_SERVICE_client_disable_continue_warning (tc->client);
  GNUNET_notification_context_add (plugin_nc, tc->mq);
  GNUNET_assert (NULL == sync_client);
  sync_client = tc;
  GST_plugins_monitor_subscribe (&plugin_session_info_cb, NULL);
}

References GNUNET_assert, GNUNET_notification_context_add(), GNUNET_SERVICE_client_disable_continue_warning(), GNUNET_SERVICE_client_mark_monitor(), GST_plugins_monitor_subscribe(), plugin_nc, plugin_session_info_cb(), sync_client, and tc.

Here is the call graph for this function:

GST_clients_broadcast()

void GST_clients_broadcast	(	const struct GNUNET_MessageHeader *	msg,
		int	may_drop
	)

Broadcast the given message to all of our clients.

Parameters

msg	message to broadcast
may_drop	GNUNET_YES if the message can be dropped / is payload

Definition at line 1286 of file gnunet-service-transport.c.

{
  int done;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Asked to broadcast message of type %u with %u bytes\n",
              (unsigned int) ntohs (msg->type),
              (unsigned int) ntohs (msg->size));
  done = GNUNET_NO;
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_NONE == tc->type)
      continue;   /* client not yet ready */
    if ((GNUNET_YES == may_drop) && (CT_CORE != tc->type))
      continue;   /* skip, this client does not care about payload */
    unicast (tc, msg, may_drop);
    done = GNUNET_YES;
  }
  if (GNUNET_NO == done)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Message of type %u not delivered, is CORE service up?\n",
                ntohs (msg->type));
}

References clients_head, CT_CORE, CT_NONE, done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_YES, msg, GNUNET_MessageHeader::size, tc, GNUNET_MessageHeader::type, and unicast().

Referenced by GST_clients_broadcast_disconnect(), neighbours_connect_notification(), process_hello_update(), and send_outbound_quota_to_clients().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_clients_broadcast_peer_notification()

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.

Parameters

peer	peer this update is about (never NULL)
address	address, NULL on disconnect
state	the current state of the peer
state_timeout	the time out for the state

Definition at line 1320 of file gnunet-service-transport.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct PeerIterateResponseMessage *msg;
 
  msg = compose_address_iterate_response_message (peer, address);
  msg->state = htonl (state);
  msg->state_timeout = GNUNET_TIME_absolute_hton (state_timeout);
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_MONITOR != tc->type)
      continue;
    if ((0 == memcmp (&tc->details.monitor_peer,
                      &all_zeros,
                      sizeof(struct GNUNET_PeerIdentity))) ||
        (0 == memcmp (&tc->details.monitor_peer,
                      peer,
                      sizeof(struct GNUNET_PeerIdentity))))
    {
      env = GNUNET_MQ_msg_copy (&msg->header);
      GNUNET_MQ_send (tc->mq, env);
    }
  }
  GNUNET_free (msg);
}

References address, all_zeros, clients_head, compose_address_iterate_response_message(), CT_MONITOR, env, GNUNET_free, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_TIME_absolute_hton(), msg, peer, state, PeerIterateResponseMessage::state_timeout, and tc.

Referenced by neighbours_changed_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

mark_peer_down()

static int mark_peer_down ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  value  )

static

Mark the peer as down so we don't call the continuation context in the future.

Parameters

cls	NULL
peer	peer that got disconnected
value	a struct SendTransmitContinuationContext to mark

Returns

GNUNET_OK (continue to iterate)

Definition at line 1361 of file gnunet-service-transport.c.

{
  struct SendTransmitContinuationContext *stcc = value;
 
  stcc->down = GNUNET_YES;
  return GNUNET_OK;
}

References SendTransmitContinuationContext::down, GNUNET_OK, GNUNET_YES, and value.

Referenced by GST_clients_broadcast_disconnect().

Here is the caller graph for this function:

GST_clients_broadcast_disconnect()

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.

Parameters

peer	peer that disconnected

Definition at line 1377 of file gnunet-service-transport.c.

{
  struct DisconnectInfoMessage disconnect_msg;
 
  GNUNET_CONTAINER_multipeermap_get_multiple (active_stccs,
                                              peer,
                                              &mark_peer_down,
                                              NULL);
  disconnect_msg.header.size = htons (sizeof(struct DisconnectInfoMessage));
  disconnect_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
  disconnect_msg.reserved = htonl (0);
  disconnect_msg.peer = *peer;
  GST_clients_broadcast (&disconnect_msg.header, GNUNET_NO);
}

References active_stccs, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT, GNUNET_NO, GST_clients_broadcast(), DisconnectInfoMessage::header, mark_peer_down(), peer, DisconnectInfoMessage::peer, DisconnectInfoMessage::reserved, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by neighbours_disconnect_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_our_hello()

static void transmit_our_hello ( 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  )

static

Transmit our HELLO message to the given (connected) neighbour.

Parameters

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

Definition at line 1405 of file gnunet-service-transport.c.

{
  const struct GNUNET_MessageHeader *hello = cls;
 
  if (0 == memcmp (peer, &GST_my_identity, sizeof(struct GNUNET_PeerIdentity)))
    return; /* not to ourselves */
  if (GNUNET_NO == GST_neighbours_test_connected (peer))
    return;
 
  GST_neighbours_send (peer,
                       hello,
                       ntohs (hello->size),
                       hello_expiration,
                       NULL,
                       NULL);
}

References GNUNET_NO, GST_my_identity, GST_neighbours_send(), GST_neighbours_test_connected(), hello_expiration, peer, and GNUNET_MessageHeader::size.

Referenced by process_hello_update().

Here is the call graph for this function:

Here is the caller graph for this function:

process_hello_update()

static void process_hello_update ( void *  cls, const struct GNUNET_MessageHeader *  hello  )

static

My HELLO has changed.

Tell everyone who should know.

Parameters

cls	unused
hello	new HELLO

Definition at line 1436 of file gnunet-service-transport.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Broadcasting HELLO to clients\n");
  GST_clients_broadcast (hello, GNUNET_NO);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Broadcasting HELLO to neighbours\n");
  GST_neighbours_iterate (&transmit_our_hello, (void *) hello);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GST_clients_broadcast(), GST_neighbours_iterate(), and transmit_our_hello().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

process_payload()

static struct GNUNET_TIME_Relative process_payload ( const struct GNUNET_HELLO_Address *  address, struct GNUNET_ATS_Session *  session, const struct GNUNET_MessageHeader *  message  )

static

We received some payload.

Prepare to pass it on to our clients.

Parameters

address	address and (claimed) identity of the other peer
session	identifier used for this session (NULL for plugins that do not offer bi-directional communication to the sender using the same "connection")
message	the message to process

Returns

how long the plugin should wait until receiving more data

Definition at line 1436 of file gnunet-service-transport.c.

{
  struct GNUNET_TIME_Relative ret;
  int do_forward;
  struct InboundMessage *im;
  size_t msg_size = ntohs (message->size);
  size_t size = sizeof(struct InboundMessage) + msg_size;
  char buf[size] GNUNET_ALIGN;
 
  do_forward = GNUNET_SYSERR;
  ret = GST_neighbours_calculate_receive_delay (&address->peer,
                                                msg_size,
                                                &do_forward);
  if (! GST_neighbours_test_connected (&address->peer))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Discarded %u bytes type %u payload from peer `%s'\n",
                (unsigned int) msg_size,
                ntohs (message->type),
                GNUNET_i2s (&address->peer));
    GNUNET_STATISTICS_update (
      GST_stats,
      gettext_noop ("# bytes payload discarded due to not connected peer"),
      msg_size,
      GNUNET_NO);
    return ret;
  }
 
  if (GNUNET_YES != do_forward)
    return ret;
  im = (struct InboundMessage *) buf;
  im->header.size = htons (size);
  im->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
  im->peer = address->peer;
  GNUNET_memcpy (&im[1], message, ntohs (message->size));
  GST_clients_broadcast (&im->header, GNUNET_YES);
  return ret;
}

kill_session_task()

static void kill_session_task ( void *  cls )

static

Task to asynchronously terminate a session.

Parameters

cls	the struct GNUNET_ATS_SessionKiller with the information for the kill

Definition at line 1504 of file gnunet-service-transport.c.

{
  struct GNUNET_ATS_SessionKiller *sk = cls;
 
  sk->task = NULL;
  GNUNET_CONTAINER_DLL_remove (sk_head, sk_tail, sk);
  sk->plugin->disconnect_session (sk->plugin->cls, sk->session);
  GNUNET_free (sk);
}

References GNUNET_TRANSPORT_PluginFunctions::cls, GNUNET_TRANSPORT_PluginFunctions::disconnect_session, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_ATS_SessionKiller::plugin, GNUNET_ATS_SessionKiller::session, sk_head, sk_tail, and GNUNET_ATS_SessionKiller::task.

Referenced by kill_session().

Here is the caller graph for this function:

kill_session()

static void kill_session ( const char *  plugin_name, struct GNUNET_ATS_Session *  session  )

static

Force plugin to terminate session due to communication issue.

Parameters

plugin_name	name of the plugin
session	session to termiante

Definition at line 1523 of file gnunet-service-transport.c.

{
  struct GNUNET_TRANSPORT_PluginFunctions *plugin;
  struct GNUNET_ATS_SessionKiller *sk;
 
  for (sk = sk_head; NULL != sk; sk = sk->next)
    if (sk->session == session)
      return;
  plugin = GST_plugins_find (plugin_name);
  if (NULL == plugin)
  {
    GNUNET_break (0);
    return;
  }
  /* need to issue disconnect asynchronously */
  sk = GNUNET_new (struct GNUNET_ATS_SessionKiller);
  sk->session = session;
  sk->plugin = plugin;
  sk->task = GNUNET_SCHEDULER_add_now (&kill_session_task, sk);
  GNUNET_CONTAINER_DLL_insert (sk_head, sk_tail, sk);
}

References GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_SCHEDULER_add_now(), GST_plugins_find(), kill_session_task(), GNUNET_ATS_SessionKiller::next, plugin, GNUNET_ATS_SessionKiller::plugin, plugin_name, GNUNET_ATS_SessionKiller::session, sk_head, sk_tail, and GNUNET_ATS_SessionKiller::task.

Referenced by connect_bl_check_cont(), and plugin_env_session_start_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_bl_check_cont()

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

static

Black list check result for try_connect call If connection to the peer is allowed request address and ???

Parameters

cls	the message
peer	the peer
address	the address
session	the session
result	the result

Definition at line 1557 of file gnunet-service-transport.c.

{
  struct GNUNET_MessageHeader *msg = cls;
 
  if (GNUNET_OK == result)
  {
    /* Blacklist allows to speak to this peer, forward SYN to neighbours  */
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Received SYN message from peer `%s' at `%s'\n",
                GNUNET_i2s (peer),
                GST_plugins_a2s (address));
    if (GNUNET_OK != GST_neighbours_handle_session_syn (msg, peer))
    {
      GST_blacklist_abort_matching (address, session);
      kill_session (address->transport_name, session);
    }
    GNUNET_free (msg);
    return;
  }
  GNUNET_free (msg);
  if (GNUNET_SYSERR == result)
    return; /* check was aborted, session destroyed */
  /* Blacklist denies to speak to this peer */
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Discarding SYN message from `%s' due to denied blacklist check\n",
              GNUNET_i2s (peer));
  kill_session (address->transport_name, session);
}

References address, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_SYSERR, GST_blacklist_abort_matching(), GST_neighbours_handle_session_syn(), GST_plugins_a2s(), kill_session(), msg, peer, and result.

Here is the call graph for this function:

GST_receive_callback()

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

Function called by the transport for each received message.

Parameters

cls	closure, const char* with the name of the plugin we received the message from
address	address and (claimed) identity of the other peer
message	the message, NULL if we only care about learning about the delay until we should receive again
session	identifier used for this session (NULL for plugins that do not offer bi-directional communication to the sender using the same "connection")

Returns

how long the plugin should wait until receiving more data (plugins that do not support this, can ignore the return value)

Definition at line 1557 of file gnunet-service-transport.c.

{
  const char *plugin_name = cls;
  struct GNUNET_TIME_Relative ret;
  uint16_t type;
 
  ret = GNUNET_TIME_UNIT_ZERO;
  if (NULL == message)
    goto end;
  type = ntohs (message->type);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received message with type %u from peer `%s' at %s\n",
              type,
              GNUNET_i2s (&address->peer),
              GST_plugins_a2s (address));
 
  GNUNET_STATISTICS_update (GST_stats,
                            gettext_noop ("# bytes total received"),
                            ntohs (message->size),
                            GNUNET_NO);
  GST_neighbours_notify_data_recv (address, message);
  switch (type)
  {
  case GNUNET_MESSAGE_TYPE_HELLO_URI:
    /* Future HELLO message, discard  */
    return ret;
 
  case GNUNET_MESSAGE_TYPE_HELLO:
    if (GNUNET_OK != GST_validation_handle_hello (message))
    {
      GNUNET_break_op (0);
      GST_blacklist_abort_matching (address, session);
    }
    return ret;
 
  case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Processing PING from `%s'\n",
                GST_plugins_a2s (address));
    if (GNUNET_OK !=
        GST_validation_handle_ping (&address->peer, message, address, session))
    {
      GST_blacklist_abort_matching (address, session);
      kill_session (plugin_name, session);
    }
    break;
 
  case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Processing PONG from `%s'\n",
                GST_plugins_a2s (address));
    if (GNUNET_OK != GST_validation_handle_pong (&address->peer, message))
    {
      GNUNET_break_op (0);
      GST_blacklist_abort_matching (address, session);
      kill_session (plugin_name, session);
    }
    break;
 
  case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN:
    /* Do blacklist check if communication with this peer is allowed */
    (void) GST_blacklist_test_allowed (&address->peer,
                                       NULL,
                                       &connect_bl_check_cont,
                                       GNUNET_copy_message (message),
                                       address,
                                       session);
    break;
 
  case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK:
    if (GNUNET_OK !=
        GST_neighbours_handle_session_syn_ack (message, address, session))
    {
      GST_blacklist_abort_matching (address, session);
      kill_session (plugin_name, session);
    }
    break;
 
  case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_ACK:
    if (GNUNET_OK !=
        GST_neighbours_handle_session_ack (message, address, session))
    {
      GNUNET_break_op (0);
      GST_blacklist_abort_matching (address, session);
      kill_session (plugin_name, session);
    }
    break;
 
  case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT:
    GST_neighbours_handle_disconnect_message (&address->peer, message);
    break;
 
  case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_QUOTA:
    GST_neighbours_handle_quota_message (&address->peer, message);
    break;
 
  case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE:
    GST_neighbours_keepalive (&address->peer, message);
    break;
 
  case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE_RESPONSE:
    GST_neighbours_keepalive_response (&address->peer, message);
    break;
 
  default:
    /* should be payload */
    GNUNET_STATISTICS_update (GST_stats,
                              gettext_noop ("# bytes payload received"),
                              ntohs (message->size),
                              GNUNET_NO);
    ret = process_payload (address, session, message);
    break;
  }
end:
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Allowing receive from peer %s to continue in %s\n",
              GNUNET_i2s (&address->peer),
              GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
  return ret;
}

plugin_env_address_change_notification()

static void plugin_env_address_change_notification ( void *  cls, int  add_remove, const struct GNUNET_HELLO_Address *  address  )

static

Function that will be called for each address the transport is aware that it might be reachable under.

Update our HELLO.

Parameters

cls	name of the plugin (const char*)
add_remove	should the address added (YES) or removed (NO) from the set of valid addresses?
address	the address to add or remove

Definition at line 1740 of file gnunet-service-transport.c.

{
  static int addresses = 0;
 
  if (GNUNET_YES == add_remove)
  {
    addresses++;
    GNUNET_STATISTICS_update (GST_stats, "# transport addresses", 1, GNUNET_NO);
  }
  else if (GNUNET_NO == add_remove)
  {
    if (0 == addresses)
    {
      GNUNET_break (0);
    }
    else
    {
      addresses--;
      GNUNET_STATISTICS_update (GST_stats,
                                "# transport addresses",
                                -1,
                                GNUNET_NO);
    }
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Transport now has %u addresses to communicate\n",
              addresses);
  GST_hello_modify_addresses (add_remove, address);
}

References address, addresses, GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GST_hello_modify_addresses(), and GST_stats.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

plugin_env_session_end()

static void plugin_env_session_end ( void *  cls, const struct GNUNET_HELLO_Address *  address, struct GNUNET_ATS_Session *  session  )

static

Function that will be called whenever the plugin internally cleans up a session pointer and hence the service needs to discard all of those sessions as well.

Plugins that do not use sessions can simply omit calling this function and always use NULL wherever a session pointer is needed. This function should be called BEFORE a potential "TransmitContinuation" from the "TransmitFunction".

Parameters

cls	closure
address	which address was the session for
session	which session is being destroyed

Definition at line 1788 of file gnunet-service-transport.c.

{
  struct GNUNET_ATS_SessionKiller *sk;
 
  if (NULL == address)
  {
    GNUNET_break (0);
    return;
  }
  if (NULL == session)
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_assert (strlen (address->transport_name) > 0);
 
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Notification from plugin about terminated session %p from peer `%s' address `%s'\n",
    session,
    GNUNET_i2s (&address->peer),
    GST_plugins_a2s (address));
 
  GST_neighbours_session_terminated (&address->peer, session);
  GST_ats_del_session (address, session);
  GST_blacklist_abort_matching (address, session);
 
  for (sk = sk_head; NULL != sk; sk = sk->next)
  {
    if (sk->session == session)
    {
      GNUNET_CONTAINER_DLL_remove (sk_head, sk_tail, sk);
      GNUNET_SCHEDULER_cancel (sk->task);
      GNUNET_free (sk);
      break;
    }
  }
}

References address, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_cancel(), GST_ats_del_session(), GST_blacklist_abort_matching(), GST_neighbours_session_terminated(), GST_plugins_a2s(), GNUNET_ATS_SessionKiller::next, GNUNET_ATS_SessionKiller::session, sk_head, sk_tail, and GNUNET_ATS_SessionKiller::task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

plugin_env_session_start_bl_check_cont()

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

static

Black list check result from blacklist check triggered when a plugin gave us a new session in plugin_env_session_start().

If connection to the peer is disallowed, kill the session.

Parameters

cls	NULL
peer	the peer
address	address associated with the request
session	session associated with the request
result	the result

Definition at line 1842 of file gnunet-service-transport.c.

{
  if (GNUNET_OK != result)
  {
    kill_session (address->transport_name, session);
    return;
  }
  if (GNUNET_YES !=
      GNUNET_HELLO_address_check_option (address,
                                         GNUNET_HELLO_ADDRESS_INFO_INBOUND))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Informing verifier about inbound session's address `%s'\n",
                GST_plugins_a2s (address));
    GST_validation_handle_address (address);
  }
}

References address, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_log, GNUNET_OK, GNUNET_YES, GST_plugins_a2s(), GST_validation_handle_address(), kill_session(), result, and GNUNET_ATS_SessionKiller::session.

Referenced by plugin_env_session_start().

Here is the call graph for this function:

Here is the caller graph for this function:

plugin_env_session_start()

static void plugin_env_session_start ( void *  cls, const struct GNUNET_HELLO_Address *  address, struct GNUNET_ATS_Session *  session, enum GNUNET_NetworkType  scope  )

static

Plugin tells transport service about a new inbound session.

Parameters

cls	unused
address	the address
session	the new session
scope	network scope information

Definition at line 1875 of file gnunet-service-transport.c.

{
  struct GNUNET_ATS_Properties prop;
 
  if (NULL == address)
  {
    GNUNET_break (0);
    return;
  }
  if (NULL == session)
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_log (
    GNUNET_ERROR_TYPE_INFO,
    "Notification from plugin `%s' about new session from peer `%s' address `%s'\n",
    address->transport_name,
    GNUNET_i2s (&address->peer),
    GST_plugins_a2s (address));
  if (GNUNET_YES ==
      GNUNET_HELLO_address_check_option (address,
                                         GNUNET_HELLO_ADDRESS_INFO_INBOUND))
  {
    /* inbound is always new, but outbound MAY already be known, but
       for example for UNIX, we have symmetric connections and thus we
       may not know the address yet; add if necessary! */
    /* FIXME: maybe change API here so we just pass scope? */
    memset (&prop, 0, sizeof(prop));
    GNUNET_break (GNUNET_NT_UNSPECIFIED != scope);
    prop.scope = scope;
    GST_ats_add_inbound_address (address, session, &prop);
  }
  /* Do blacklist check if communication with this peer is allowed */
  (void) GST_blacklist_test_allowed (&address->peer,
                                     address->transport_name,
                                     &plugin_env_session_start_bl_check_cont,
                                     NULL,
                                     address,
                                     session);
}

References address, GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_i2s(), GNUNET_log, GNUNET_NT_UNSPECIFIED, GNUNET_YES, GST_ats_add_inbound_address(), GST_blacklist_test_allowed(), GST_plugins_a2s(), plugin_env_session_start_bl_check_cont(), GNUNET_ATS_Properties::scope, and scope.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

ats_request_address_change()

static void ats_request_address_change ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_HELLO_Address *  address, struct GNUNET_ATS_Session *  session, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_in  )

static

Function called by ATS to notify the callee that the assigned bandwidth or address for a given peer was changed.

If the callback is called with address/bandwidth assignments of zero, the ATS disconnect function will still be called once the disconnect actually happened.

Parameters

cls	closure
peer	the peer this address is intended for
address	address to use (for peer given in address)
session	session to use (if available)
bandwidth_out	assigned outbound bandwidth for the connection in NBO, 0 to disconnect from peer
bandwidth_in	assigned inbound bandwidth for the connection in NBO, 0 to disconnect from peer
ats	ATS information
ats_count	number of ats elements

Definition at line 1940 of file gnunet-service-transport.c.

{
  uint32_t bw_in = ntohl (bandwidth_in.value__);
  uint32_t bw_out = ntohl (bandwidth_out.value__);
 
  if (NULL == peer)
  {
    /* ATS service died, all suggestions become invalid!
       (but we'll keep using the allocations for a little
       while, to keep going while ATS restarts) */
    /* FIXME: We should drop all
       connections now, as ATS won't explicitly tell
       us and be unaware of ongoing resource allocations! */
    return;
  }
  /* ATS tells me to disconnect from peer */
  if ((0 == bw_in) && (0 == bw_out))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "ATS tells me to disconnect from peer `%s'\n",
                GNUNET_i2s (peer));
    GST_neighbours_force_disconnect (peer);
    return;
  }
  GNUNET_assert (NULL != address);
  GNUNET_STATISTICS_update (GST_stats,
                            "# ATS suggestions received",
                            1,
                            GNUNET_NO);
  GST_neighbours_switch_to_address (address,
                                    session,
                                    bandwidth_in,
                                    bandwidth_out);
}

References address, GNUNET_assert, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GST_neighbours_force_disconnect(), GST_neighbours_switch_to_address(), GST_stats, peer, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

confirm_or_drop_neighbour()

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

static

Got the result about an existing connection from a new blacklister.

Shutdown the neighbour if necessary.

Parameters

cls	unused
peer	the neighbour that was investigated
address	address associated with the request
session	session associated with the request
allowed	GNUNET_OK if we can keep it, GNUNET_NO if we must shutdown the connection

Definition at line 2010 of file gnunet-service-transport.c.

{
  if (GNUNET_OK == allowed)
    return; /* we're done */
  GNUNET_STATISTICS_update (GST_stats,
                            gettext_noop ("# disconnects due to blacklist"),
                            1,
                            GNUNET_NO);
  GST_neighbours_force_disconnect (peer);
}

References gettext_noop, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GST_neighbours_force_disconnect(), GST_stats, and peer.

Referenced by test_connection_ok().

Here is the call graph for this function:

Here is the caller graph for this function:

test_connection_ok()

static void test_connection_ok ( 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  )

static

Test if an existing connection is still acceptable given a new blacklisting client.

Parameters

cls	the struct TestConnectionContext *
peer	identity of the peer
address	the address
state	current state this peer is in
state_timeout	timeout for the current state of the peer
bandwidth_in	bandwidth assigned inbound
bandwidth_out	bandwidth assigned outbound

Definition at line 2039 of file gnunet-service-transport.c.

{
  struct TestConnectionContext *tcc = cls;
  struct GST_BlacklistCheck *bc;
 
  bc = GNUNET_new (struct GST_BlacklistCheck);
  GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
  bc->peer = *peer;
  bc->address = GNUNET_HELLO_address_copy (address);
  bc->cont = &confirm_or_drop_neighbour;
  bc->cont_cls = NULL;
  bc->bl_pos = tcc->tc;
  if (GNUNET_YES == tcc->first)
  {
    /* all would wait for the same client, no need to
     * create more than just the first task right now */
    bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
    tcc->first = GNUNET_NO;
  }
}

References address, GST_BlacklistCheck::address, bc_head, bc_tail, GST_BlacklistCheck::bl_pos, confirm_or_drop_neighbour(), GST_BlacklistCheck::cont, GST_BlacklistCheck::cont_cls, do_blacklist_check(), TestConnectionContext::first, GNUNET_CONTAINER_DLL_insert, GNUNET_HELLO_address_copy(), GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_YES, peer, GST_BlacklistCheck::peer, GST_BlacklistCheck::task, and TestConnectionContext::tc.

Referenced by handle_client_blacklist_init().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_client_blacklist_init()

static void handle_client_blacklist_init ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Initialize a blacklisting client.

We got a blacklist-init message from this client, add it to the list of clients to query for blacklisting.

Parameters

cls	the client
message	the blacklist-init message that was sent

Definition at line 2076 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
  struct TestConnectionContext tcc;
 
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  GNUNET_SERVICE_client_mark_monitor (tc->client);
  tc->type = CT_BLACKLIST;
  tc->details.blacklist.call_receive_done = GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New blacklist client %p\n", tc);
  /* confirm that all existing connections are OK! */
  tcc.tc = tc;
  tcc.first = GNUNET_YES;
  GST_neighbours_iterate (&test_connection_ok, &tcc);
}

References CT_BLACKLIST, CT_NONE, TestConnectionContext::first, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_mark_monitor(), GNUNET_YES, GST_neighbours_iterate(), TestConnectionContext::tc, tc, and test_connection_ok().

Here is the call graph for this function:

free_blacklist_entry()

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

static

Free the given entry in the blacklist.

Parameters

cls	unused
key	host identity (unused)
value	the blacklist entry

Returns

GNUNET_OK (continue to iterate)

Definition at line 2108 of file gnunet-service-transport.c.

{
  char *be = value;
 
  GNUNET_free (be);
  return GNUNET_OK;
}

References GNUNET_free, GNUNET_OK, and value.

Referenced by shutdown_task().

Here is the caller graph for this function:

handle_client_set_metric()

static void handle_client_set_metric ( void *  cls, const struct TrafficMetricMessage *  tm  )

static

Set traffic metric to manipulate.

Parameters

cls	closure
tm	message containing information

Definition at line 2126 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
 
  GST_manipulation_set_metric (tm);
  GNUNET_SERVICE_client_continue (tc->client);
}

References GNUNET_SERVICE_client_continue(), GST_manipulation_set_metric(), and tc.

Here is the call graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Function called when the service shuts down.

Unloads our plugins and cancels pending validations.

Parameters

cls	closure, unused

Definition at line 2142 of file gnunet-service-transport.c.

{
  struct AddressToStringContext *cur;
 
  GST_neighbours_stop ();
  GST_plugins_unload ();
  GST_validation_stop ();
  GST_ats_done ();
  GNUNET_ATS_scheduling_done (GST_ats);
  GST_ats = NULL;
  GNUNET_ATS_connectivity_done (GST_ats_connect);
  GST_ats_connect = NULL;
  GNUNET_NT_scanner_done (GST_is);
  GST_is = NULL;
  while (NULL != (cur = a2s_head))
  {
    GNUNET_CONTAINER_DLL_remove (a2s_head, a2s_tail, cur);
    GNUNET_free (cur);
  }
  if (NULL != plugin_nc)
  {
    GNUNET_notification_context_destroy (plugin_nc);
    plugin_nc = NULL;
  }
  GNUNET_CONTAINER_multipeermap_destroy (active_stccs);
  active_stccs = NULL;
  if (NULL != blacklist)
  {
    GNUNET_CONTAINER_multipeermap_iterate (blacklist,
                                           &free_blacklist_entry,
                                           NULL);
    GNUNET_CONTAINER_multipeermap_destroy (blacklist);
    blacklist = NULL;
  }
  GST_hello_stop ();
  GST_manipulation_stop ();
 
  if (NULL != GST_peerinfo)
  {
    GNUNET_PEERINFO_disconnect (GST_peerinfo);
    GST_peerinfo = NULL;
  }
  if (NULL != GST_stats)
  {
    GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
    GST_stats = NULL;
  }
}

References a2s_head, a2s_tail, active_stccs, blacklist, free_blacklist_entry(), GNUNET_ATS_connectivity_done(), GNUNET_ATS_scheduling_done(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_NO, GNUNET_notification_context_destroy(), GNUNET_NT_scanner_done(), GNUNET_PEERINFO_disconnect(), GNUNET_STATISTICS_destroy(), GST_ats, GST_ats_connect, GST_ats_done(), GST_hello_stop(), GST_is, GST_manipulation_stop(), GST_neighbours_stop(), GST_peerinfo, GST_plugins_unload(), GST_stats, GST_validation_stop(), and plugin_nc.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_client_blacklist_reply()

static void handle_client_blacklist_reply ( void *  cls, const struct BlacklistMessage *  msg  )

static

A blacklisting client has sent us reply.

Process it.

Parameters

cls	the client
msg	the blacklist-reply message that was sent

Definition at line 2241 of file gnunet-service-transport.c.

{
  struct TransportClient *tc = cls;
  struct GST_BlacklistCheck *bc;
 
  if (CT_BLACKLIST != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Blacklist client %p sent reply for `%s'\n",
              tc,
              GNUNET_i2s (&msg->peer));
  bc = tc->details.blacklist.bc;
  tc->details.blacklist.bc = NULL;
  tc->details.blacklist.waiting_for_reply = GNUNET_NO;
  tc->details.blacklist.call_receive_done = GNUNET_YES;
  if (NULL != bc)
  {
    /* only run this if the blacklist check has not been
     * cancelled in the meantime... */
    GNUNET_assert (bc->bl_pos == tc);
    if (ntohl (msg->is_allowed) == GNUNET_SYSERR)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Blacklist check failed, peer not allowed\n");
      /* For the duration of the continuation, make the ongoing
         check invisible (to avoid double-cancellation); then
         add it back again so we can re-use GST_blacklist_test_cancel() */
      GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
      bc->cont (bc->cont_cls, &bc->peer, bc->address, bc->session, GNUNET_NO);
      GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
      GST_blacklist_test_cancel (bc);
      tc->details.blacklist.call_receive_done = GNUNET_NO;
      GNUNET_SERVICE_client_continue (tc->client);
      return;
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Blacklist check succeeded, continuing with checks\n");
      tc->details.blacklist.call_receive_done = GNUNET_NO;
      GNUNET_SERVICE_client_continue (tc->client);
      bc->bl_pos = tc->next;
      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
    }
  }
  /* check if any other blacklist checks are waiting for this blacklister */
  for (bc = bc_head; bc != NULL; bc = bc->next)
    if ((bc->bl_pos == tc) && (NULL == bc->task))
    {
      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
      break;
    }
}

References GST_BlacklistCheck::address, bc_head, bc_tail, GST_BlacklistCheck::bl_pos, GST_BlacklistCheck::cont, GST_BlacklistCheck::cont_cls, CT_BLACKLIST, do_blacklist_check(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, GNUNET_YES, GST_blacklist_test_cancel(), msg, GST_BlacklistCheck::next, GST_BlacklistCheck::peer, GST_BlacklistCheck::session, GST_BlacklistCheck::task, and tc.

Here is the call graph for this function:

GST_blacklist_add_peer()

void GST_blacklist_add_peer	(	const struct GNUNET_PeerIdentity *	peer,
		const char *	transport_name
	)

Add the given peer to the blacklist (for the given transport).

Parameters

peer	peer to blacklist
transport_name	transport to blacklist for this peer, NULL for all

Definition at line 2307 of file gnunet-service-transport.c.

{
  char *transport = NULL;
 
  if (NULL != transport_name)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Adding peer `%s' with plugin `%s' to blacklist\n",
                GNUNET_i2s (peer),
                transport_name);
    transport = GNUNET_strdup (transport_name);
  }
  else
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Adding peer `%s' with all plugins to blacklist\n",
                GNUNET_i2s (peer));
  if (NULL == blacklist)
    blacklist =
      GNUNET_CONTAINER_multipeermap_create (TRANSPORT_BLACKLIST_HT_SIZE,
                                            GNUNET_NO);
 
  GNUNET_CONTAINER_multipeermap_put (blacklist,
                                     peer,
                                     transport,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
}

References blacklist, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_strdup, peer, transport, and TRANSPORT_BLACKLIST_HT_SIZE.

Referenced by blacklist_cfg_iter(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_blacklist_abort_matching()

void GST_blacklist_abort_matching	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session
	)

Abort blacklist if address and session match.

Parameters

address	address used to abort matching checks
session	session used to abort matching checks

Definition at line 2343 of file gnunet-service-transport.c.

{
  struct GST_BlacklistCheck *bc;
  struct GST_BlacklistCheck *n;
 
  n = bc_head;
  while (NULL != (bc = n))
  {
    n = bc->next;
    if ((bc->session == session) &&
        (0 == GNUNET_HELLO_address_cmp (bc->address, address)))
    {
      bc->cont (bc->cont_cls,
                &bc->peer,
                bc->address,
                bc->session,
                GNUNET_SYSERR);
      GST_blacklist_test_cancel (bc);
    }
  }
}

References address, GST_BlacklistCheck::address, bc_head, GST_BlacklistCheck::cont, GST_BlacklistCheck::cont_cls, GNUNET_HELLO_address_cmp(), GNUNET_SYSERR, GST_blacklist_test_cancel(), GST_BlacklistCheck::next, GST_BlacklistCheck::peer, and GST_BlacklistCheck::session.

Referenced by connect_bl_check_cont(), and plugin_env_session_end().

Here is the call graph for this function:

Here is the caller graph for this function:

test_blacklisted()

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

static

Test if the given blacklist entry matches.

If so, abort the iteration.

Parameters

cls	the transport name to match (const char*)
key	the key (unused)
value	the 'char *' (name of a blacklisted transport)

Returns

GNUNET_OK if the entry does not match, GNUNET_NO if it matches

Definition at line 2377 of file gnunet-service-transport.c.

{
  const char *transport_name = cls;
  char *be = value;
 
  /* Blacklist entry be:
   *  (NULL == be): peer is blacklisted with all plugins
   *  (NULL != be): peer is blacklisted for a specific plugin
   *
   * If (NULL != transport_name) we look for a transport specific entry:
   *  if (transport_name == be) forbidden
   *
   */GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Comparing BL request for peer `%4s':`%s' with BL entry: `%s'\n",
              GNUNET_i2s (key),
              (NULL == transport_name) ? "unspecified" : transport_name,
              (NULL == be) ? "all plugins" : be);
  /* all plugins for this peer were blacklisted: disallow */
  if (NULL == value)
    return GNUNET_NO;
 
  /* blacklist check for specific transport */
  if ((NULL != transport_name) && (NULL != value))
  {
    if (0 == strcmp (transport_name, be))
      return GNUNET_NO;   /* plugin is blacklisted! */
  }
  return GNUNET_OK;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, key, and value.

Referenced by GST_blacklist_test_allowed().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_blacklist_test_allowed()

struct GST_BlacklistCheck* GST_blacklist_test_allowed	(	const struct GNUNET_PeerIdentity *	peer,
		const char *	transport_name,
		GST_BlacklistTestContinuation	cont,
		void *	cont_cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session
	)

Test if a peer/transport combination is blacklisted.

Parameters

peer	the identity of the peer to test
transport_name	name of the transport to test, never NULL
cont	function to call with result
cont_cls	closure for cont
address	address to pass back to cont, can be NULL
session	session to pass back to cont, can be NULL

Returns

handle to the blacklist check, NULL if the decision was made instantly and cont was already called

Definition at line 2421 of file gnunet-service-transport.c.

{
  struct GST_BlacklistCheck *bc;
  struct TransportClient *tc;
 
  GNUNET_assert (NULL != peer);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Blacklist check for peer `%s':%s\n",
              GNUNET_i2s (peer),
              (NULL != transport_name) ? transport_name : "unspecified");
 
  /* Check local blacklist by iterating over hashmap
   * If iteration is aborted, we found a matching blacklist entry */
  if ((NULL != blacklist) &&
      (GNUNET_SYSERR ==
       GNUNET_CONTAINER_multipeermap_get_multiple (blacklist,
                                                   peer,
                                                   &test_blacklisted,
                                                   (void *) transport_name)))
  {
    /* Disallowed by config, disapprove instantly */
    GNUNET_STATISTICS_update (GST_stats,
                              gettext_noop ("# disconnects due to blacklist"),
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Disallowing connection to peer `%s' on transport %s\n"),
                GNUNET_i2s (peer),
                (NULL != transport_name) ? transport_name : "unspecified");
    if (NULL != cont)
      cont (cont_cls, peer, address, session, GNUNET_NO);
    return NULL;
  }
 
  for (tc = clients_head; NULL != tc; tc = tc->next)
    if (CT_BLACKLIST == tc->type)
      break;
  if (NULL == tc)
  {
    /* no blacklist clients, approve instantly */
    if (NULL != cont)
      cont (cont_cls, peer, address, session, GNUNET_OK);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Allowing connection to peer `%s' %s\n",
                GNUNET_i2s (peer),
                (NULL != transport_name) ? transport_name : "");
    return NULL;
  }
 
  /* need to query blacklist clients */
  bc = GNUNET_new (struct GST_BlacklistCheck);
  GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
  bc->peer = *peer;
  bc->address = GNUNET_HELLO_address_copy (address);
  bc->session = session;
  bc->cont = cont;
  bc->cont_cls = cont_cls;
  bc->bl_pos = tc;
  bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
  return bc;
}

References _, address, GST_BlacklistCheck::address, TransportClient::bc, bc_head, bc_tail, GST_BlacklistCheck::bl_pos, blacklist, clients_head, GST_BlacklistCheck::cont, GST_BlacklistCheck::cont_cls, CT_BLACKLIST, do_blacklist_check(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_address_copy(), GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GST_stats, peer, GST_BlacklistCheck::peer, GST_BlacklistCheck::session, GST_BlacklistCheck::task, tc, and test_blacklisted().

Referenced by GST_neighbours_switch_to_address(), plugin_env_session_start(), and revalidate_address().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_blacklist_test_cancel()

void GST_blacklist_test_cancel

(

struct GST_BlacklistCheck *

bc

)

Cancel a blacklist check.

Parameters

bc	check to cancel

Definition at line 2490 of file gnunet-service-transport.c.

{
  GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
  if (NULL != bc->bl_pos)
  {
    if ((CT_BLACKLIST == bc->bl_pos->type) &&
        (bc->bl_pos->details.blacklist.bc == bc))
    {
      /* we're at the head of the queue, remove us! */
      bc->bl_pos->details.blacklist.bc = NULL;
    }
  }
  if (NULL != bc->task)
  {
    GNUNET_SCHEDULER_cancel (bc->task);
    bc->task = NULL;
  }
  GNUNET_free (bc->address);
  GNUNET_free (bc);
}

References GST_BlacklistCheck::address, TransportClient::bc, bc_head, bc_tail, GST_BlacklistCheck::bl_pos, TransportClient::blacklist, CT_BLACKLIST, TransportClient::details, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GST_BlacklistCheck::task, and TransportClient::type.

Referenced by cleanup_validation_entry(), do_blacklist_check(), GST_blacklist_abort_matching(), handle_client_blacklist_reply(), and revalidate_address().

Here is the call graph for this function:

Here is the caller graph for this function:

blacklist_cfg_iter()

static void blacklist_cfg_iter ( void *  cls, const char *  section, const char *  option, const char *  value  )

static

Function to iterate over options in the blacklisting section for a peer.

Parameters

cls	closure
section	name of the section
option	name of the option
value	value of the option

Definition at line 2521 of file gnunet-service-transport.c.

{
  unsigned int *res = cls;
  struct GNUNET_PeerIdentity peer;
  char *plugs;
  char *pos;
 
  if (GNUNET_OK !=
      GNUNET_CRYPTO_eddsa_public_key_from_string (option,
                                                  strlen (option),
                                                  &peer.public_key))
    return;
 
  if ((NULL == value) || (0 == strcmp (value, "")))
  {
    /* Blacklist whole peer */
    GST_blacklist_add_peer (&peer, NULL);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Adding blacklisting entry for peer `%s'\n"),
                GNUNET_i2s (&peer));
  }
  else
  {
    plugs = GNUNET_strdup (value);
    for (pos = strtok (plugs, " "); pos != NULL; pos = strtok (NULL, " "))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  _ ("Adding blacklisting entry for peer `%s':`%s'\n"),
                  GNUNET_i2s (&peer),
                  pos);
      GST_blacklist_add_peer (&peer, pos);
    }
    GNUNET_free (plugs);
  }
  (*res)++;
}

References _, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_strdup, GST_blacklist_add_peer(), peer, res, and value.

Referenced by read_blacklist_configuration().

Here is the call graph for this function:

Here is the caller graph for this function:

read_blacklist_configuration()

static void read_blacklist_configuration ( const struct GNUNET_CONFIGURATION_Handle *  cfg, const struct GNUNET_PeerIdentity *  my_id  )

static

Read blacklist configuration.

Parameters

cfg	the configuration handle
my_id	my peer identity

Definition at line 2569 of file gnunet-service-transport.c.

{
  char cfg_sect[512];
  unsigned int res = 0;
 
  GNUNET_snprintf (cfg_sect,
                   sizeof(cfg_sect),
                   "transport-blacklist-%s",
                   GNUNET_i2s_full (my_id));
  GNUNET_CONFIGURATION_iterate_section_values (cfg,
                                               cfg_sect,
                                               &blacklist_cfg_iter,
                                               &res);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Loaded %u blacklisting entries from configuration\n",
              res);
}

References blacklist_cfg_iter(), cfg, GNUNET_CONFIGURATION_iterate_section_values(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s_full(), GNUNET_log, GNUNET_snprintf(), and res.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  c, struct GNUNET_SERVICE_Handle *  service  )

static

Initiate transport service.

Parameters

cls	closure
c	configuration to use
service	the initialized service

Definition at line 2597 of file gnunet-service-transport.c.

{
  char *keyfile;
  long long unsigned int max_fd_cfg;
  int max_fd_rlimit;
  int max_fd;
  int friend_only;
 
  /* setup globals */
  GST_cfg = c;
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c,
                                                            "PEER",
                                                            "PRIVATE_KEY",
                                                            &keyfile))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_ERROR,
      _ (
        "Transport service is lacking key configuration settings. Exiting.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (c,
                                                        "transport",
                                                        "HELLO_EXPIRATION",
                                                        &hello_expiration))
  {
    hello_expiration = GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION;
  }
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_eddsa_key_from_file (keyfile,
                                         GNUNET_YES,
                                         &GST_my_private_key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup peer's private key\n");
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (keyfile);
    return;
  }
  GNUNET_free (keyfile);
  GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
  GST_peerinfo = GNUNET_PEERINFO_connect (GST_cfg);
  GNUNET_CRYPTO_eddsa_key_get_public (&GST_my_private_key,
                                      &GST_my_identity.public_key);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "My identity is `%s'\n",
              GNUNET_i2s_full (&GST_my_identity));
 
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  if (NULL == GST_peerinfo)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Could not access PEERINFO service.  Exiting.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  max_fd_rlimit = 0;
#if HAVE_GETRLIMIT
  {
    struct rlimit r_file;
 
    if (0 == getrlimit (RLIMIT_NOFILE, &r_file))
    {
      max_fd_rlimit = r_file.rlim_cur;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Maximum number of open files was: %u/%u\n",
                  (unsigned int) r_file.rlim_cur,
                  (unsigned int) r_file.rlim_max);
    }
    max_fd_rlimit =
      (9 * max_fd_rlimit) / 10; /* Keep 10% for rest of transport */
  }
#endif
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (GST_cfg,
                                                          "transport",
                                                          "MAX_FD",
                                                          &max_fd_cfg))
    max_fd_cfg = max_fd_rlimit;
 
  if (max_fd_cfg > max_fd_rlimit)
    max_fd = max_fd_cfg;
  else
    max_fd = max_fd_rlimit;
  if (max_fd < DEFAULT_MAX_FDS)
    max_fd = DEFAULT_MAX_FDS;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Limiting number of sockets to %u: validation %u, neighbors: %u\n",
              max_fd,
              (max_fd / 3),
              (max_fd / 3) * 2);
 
  friend_only =
    GNUNET_CONFIGURATION_get_value_yesno (GST_cfg, "topology", "FRIENDS-ONLY");
  if (GNUNET_SYSERR == friend_only)
    friend_only = GNUNET_NO; /* According to topology defaults */
  /* start subsystems */
  /* Disable DSTJ peer */
  {
    struct GNUNET_PeerIdentity dstj;
    const char *ds = "DSTJBRRKZ8TBW3FGK6B0M5QXWT9WYNZ45H5MCV4HY7ST64Q8T9F0";
 
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_CRYPTO_eddsa_public_key_from_string (ds,
                                                  strlen (ds),
                                                  &dstj.public_key));
    GST_blacklist_add_peer (&dstj, NULL);
  }
  read_blacklist_configuration (GST_cfg, &GST_my_identity);
  GST_is = GNUNET_NT_scanner_init ();
  GST_ats_connect = GNUNET_ATS_connectivity_init (GST_cfg);
  GST_ats =
    GNUNET_ATS_scheduling_init (GST_cfg, &ats_request_address_change, NULL);
  GST_ats_init ();
  GST_manipulation_init ();
  GST_plugins_load (&GST_manipulation_recv,
                    &plugin_env_address_change_notification,
                    &plugin_env_session_start,
                    &plugin_env_session_end);
  GST_hello_start (friend_only, &process_hello_update, NULL);
  GST_neighbours_start ((max_fd / 3) * 2);
  active_stccs = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
  plugin_nc = GNUNET_notification_context_create (0);
  GST_validation_start ((max_fd / 3));
}

References _, active_stccs, ats_request_address_change(), DEFAULT_MAX_FDS, ds, GNUNET_assert, GNUNET_ATS_connectivity_init(), GNUNET_ATS_scheduling_init(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CRYPTO_eddsa_key_from_file(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s_full(), GNUNET_log, GNUNET_NO, GNUNET_notification_context_create(), GNUNET_NT_scanner_init(), GNUNET_OK, GNUNET_PEERINFO_connect(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_SYSERR, GNUNET_YES, GST_ats, GST_ats_connect, GST_ats_init(), GST_blacklist_add_peer(), GST_cfg, GST_hello_start(), GST_is, GST_manipulation_init(), GST_manipulation_recv(), GST_my_identity, GST_my_private_key, GST_neighbours_start(), GST_peerinfo, GST_plugins_load(), GST_stats, GST_validation_start(), hello_expiration, plugin_env_address_change_notification(), plugin_env_session_end(), plugin_env_session_start(), plugin_nc, process_hello_update(), GNUNET_PeerIdentity::public_key, read_blacklist_configuration(), and shutdown_task().

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"transport"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_fixed_size(client_start, GNUNET_MESSAGE_TYPE_TRANSPORT_START, struct StartMessage, NULL)	,
		GNUNET_MQ_hd_var_size(client_hello, GNUNET_MESSAGE_TYPE_HELLO, struct GNUNET_MessageHeader, NULL)	,
		GNUNET_MQ_hd_var_size(client_send, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, struct OutboundMessage, NULL)	,
		GNUNET_MQ_hd_var_size(client_address_to_string, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING, struct AddressLookupMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_monitor_peers, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST, struct PeerMonitorMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_blacklist_init, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT, struct GNUNET_MessageHeader, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_blacklist_reply, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY, struct BlacklistMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_set_metric, GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC, struct TrafficMetricMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_monitor_plugins, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_START, struct GNUNET_MessageHeader, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

clients_head

struct TransportClient* clients_head

static

Head of linked list of all clients to this service.

Definition at line 305 of file gnunet-service-transport.c.

Referenced by client_connect_cb(), client_disconnect_cb(), GST_blacklist_test_allowed(), GST_clients_broadcast(), and GST_clients_broadcast_peer_notification().

clients_tail

struct TransportClient* clients_tail

static

Tail of linked list of all clients to this service.

Definition at line 310 of file gnunet-service-transport.c.

Referenced by client_connect_cb(), and client_disconnect_cb().

active_stccs

struct GNUNET_CONTAINER_MultiPeerMap* active_stccs

static

Map of peer identities to active send transmit continuation contexts.

Used to flag contexts as 'dead' when a connection goes down. Values are of type struct SendTransmitContinuationContext *.

Definition at line 318 of file gnunet-service-transport.c.

Referenced by client_disconnect_cb(), GST_clients_broadcast_disconnect(), handle_client_send(), handle_send_transmit_continuation(), run(), and shutdown_task().

a2s_head

struct AddressToStringContext* a2s_head

static

Head of linked list of all pending address iterations.

Definition at line 323 of file gnunet-service-transport.c.

Referenced by client_disconnect_cb(), handle_client_address_to_string(), shutdown_task(), and transmit_address_to_client().

a2s_tail

struct AddressToStringContext* a2s_tail

static

Tail of linked list of all pending address iterations.

Definition at line 328 of file gnunet-service-transport.c.

Referenced by handle_client_address_to_string(), shutdown_task(), and transmit_address_to_client().

bc_head

struct GST_BlacklistCheck* bc_head

static

Head of DLL of active blacklisting queries.

Definition at line 333 of file gnunet-service-transport.c.

Referenced by client_disconnect_cb(), GST_blacklist_abort_matching(), GST_blacklist_test_allowed(), GST_blacklist_test_cancel(), handle_client_blacklist_reply(), and test_connection_ok().

bc_tail

struct GST_BlacklistCheck* bc_tail

static

Tail of DLL of active blacklisting queries.

Definition at line 338 of file gnunet-service-transport.c.

Referenced by GST_blacklist_test_allowed(), GST_blacklist_test_cancel(), handle_client_blacklist_reply(), and test_connection_ok().

blacklist

struct GNUNET_CONTAINER_MultiPeerMap* blacklist

static

Hashmap of blacklisted peers.

Values are of type 'char *' (transport names), can be NULL if we have no static blacklist.

Definition at line 344 of file gnunet-service-transport.c.

Referenced by GST_blacklist_add_peer(), GST_blacklist_test_allowed(), and shutdown_task().

plugin_nc

struct GNUNET_NotificationContext* plugin_nc

static

Notification context, to send updates on changes to active plugin connections.

Definition at line 350 of file gnunet-service-transport.c.

Referenced by handle_client_monitor_plugins(), plugin_session_info_cb(), run(), and shutdown_task().

sync_client

struct TransportClient* sync_client

static

Plugin monitoring client we are currently syncing, NULL if all monitoring clients are in sync.

Definition at line 356 of file gnunet-service-transport.c.

Referenced by handle_client_monitor_plugins(), and plugin_session_info_cb().

all_zeros

struct GNUNET_PeerIdentity all_zeros

static

Peer identity that is all zeros, used as a way to indicate "all peers".

Used for comparisons.

Definition at line 356 of file gnunet-service-transport.c.

Referenced by GST_clients_broadcast_peer_notification(), handle_client_monitor_peers(), handle_client_start_search(), and mac_test().

GST_stats

struct GNUNET_STATISTICS_Handle* GST_stats

Statistics handle.

Definition at line 367 of file gnunet-service-transport.c.

Referenced by ats_request_address_change(), confirm_or_drop_neighbour(), GST_blacklist_test_allowed(), handle_client_send(), plugin_env_address_change_notification(), run(), shutdown_task(), and unicast().

GST_cfg

const struct GNUNET_CONFIGURATION_Handle* GST_cfg

Configuration handle.

Definition at line 372 of file gnunet-service-transport.c.

Referenced by run().

GST_my_identity

struct GNUNET_PeerIdentity GST_my_identity

Configuration handle.

Definition at line 372 of file gnunet-service-transport.c.

Referenced by handle_client_start(), run(), and transmit_our_hello().

GST_peerinfo

struct GNUNET_PEERINFO_Handle* GST_peerinfo

Handle to peerinfo service.

Definition at line 382 of file gnunet-service-transport.c.

Referenced by GST_validation_handle_pong(), refresh_hello_task(), run(), and shutdown_task().

GST_my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey GST_my_private_key

Our private key.

Definition at line 382 of file gnunet-service-transport.c.

Referenced by run().

GST_ats

struct GNUNET_ATS_SchedulingHandle* GST_ats

ATS scheduling handle.

ATS handle.

Definition at line 392 of file gnunet-service-transport.c.

Referenced by GST_ats_add_address(), GST_ats_add_inbound_address(), run(), shutdown_task(), and unblock_address().

GST_ats_connect

struct GNUNET_ATS_ConnectivityHandle* GST_ats_connect

ATS connectivity handle.

Definition at line 397 of file gnunet-service-transport.c.

Referenced by run(), setup_neighbour(), and shutdown_task().

hello_expiration

struct GNUNET_TIME_Relative hello_expiration

Hello address expiration.

Definition at line 397 of file gnunet-service-transport.c.

Referenced by refresh_hello_task(), run(), and transmit_our_hello().

sk_head

struct GNUNET_ATS_SessionKiller* sk_head

static

Head of DLL of asynchronous tasks to kill sessions.

Definition at line 407 of file gnunet-service-transport.c.

Referenced by kill_session(), kill_session_task(), and plugin_env_session_end().

sk_tail

struct GNUNET_ATS_SessionKiller* sk_tail

static

Tail of DLL of asynchronous tasks to kill sessions.

Definition at line 412 of file gnunet-service-transport.c.

Referenced by kill_session(), kill_session_task(), and plugin_env_session_end().

GST_is

struct GNUNET_NT_InterfaceScanner* GST_is

Interface scanner determines our LAN address range(s).

Definition at line 417 of file gnunet-service-transport.c.

Referenced by run(), and shutdown_task().