gnunet-service-transport.h File Reference

globals More...

#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_ats_service.h"
#include "gnunet_transport_service.h"

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

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

Go to the source code of this file.

Macros
#define	VERBOSE_VALIDATION   GNUNET_YES

Typedefs
typedef void(*	GNUNET_TRANSPORT_NeighbourChangeCallback) (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 to call when a peer's address has changed. More...
typedef void(*	GST_BlacklistTestContinuation) (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, int result)
	Continuation called from a blacklist test. More...

Functions
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...
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_abort_matching (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Abort blacklist if address and session match. More...
void	GST_blacklist_test_cancel (struct GST_BlacklistCheck *bc)
	Cancel a blacklist check. 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...
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...
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...

Variables
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 handle. More...
struct GNUNET_ATS_ConnectivityHandle *	GST_ats_connect
	ATS connectivity handle. More...
struct GNUNET_NT_InterfaceScanner *	GST_is
	Interface scanner determines our LAN address range(s). More...

Detailed Description

globals

Author

Christian Grothoff

Definition in file gnunet-service-transport.h.

Macro Definition Documentation

VERBOSE_VALIDATION

#define VERBOSE_VALIDATION   GNUNET_YES

Definition at line 34 of file gnunet-service-transport.h.

Typedef Documentation

GNUNET_TRANSPORT_NeighbourChangeCallback

typedef void(* GNUNET_TRANSPORT_NeighbourChangeCallback) (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 to call when a peer's address has changed.

Parameters

cls	closure
peer	peer this update is about,
address	address, NULL for disconnect notification

Definition at line 84 of file gnunet-service-transport.h.

GST_BlacklistTestContinuation

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

Continuation called from a blacklist test.

Parameters

cls	closure
peer	identity of peer that was tested
address	address associated with the request
session	session associated with the request
result	GNUNET_OK if the connection is allowed, GNUNET_NO if not, GNUNET_SYSERR if operation was aborted

Definition at line 111 of file gnunet-service-transport.h.

Function Documentation

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

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:

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
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, NULL if we only care about learning about the delay until we should receive again

Returns

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

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;
}

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:

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:

Variable Documentation

GST_stats

struct GNUNET_STATISTICS_Handle* GST_stats

extern

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

extern

Configuration handle.

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

Referenced by run().

GST_my_identity

struct GNUNET_PeerIdentity GST_my_identity

extern

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

extern

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

extern

Our private key.

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

Referenced by run().

GST_ats

struct GNUNET_ATS_SchedulingHandle* GST_ats

extern

ATS 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

extern

ATS connectivity handle.

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

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

GST_is

struct GNUNET_NT_InterfaceScanner* GST_is

extern

Interface scanner determines our LAN address range(s).

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

Referenced by run(), and shutdown_task().