Transport Next Generation service

Low-level communication with other peers. More...

Collaboration diagram for Transport Next Generation service:

Data Structures
struct	GNUNET_TRANSPORT_MonitorInformation
	Information about another peer's address. More...

Macros
#define	GNUNET_TRANSPORT_COMMUNICATION_VERSION   0x00000000
	Version number of the transport communication API. More...
#define	GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED   UINT64_MAX
	Queue length. More...
#define	GNUNET_TRANSPORT_CORE_VERSION   0x00000000
	Version number of the transport API. More...
#define	GNUNET_TRANSPORT_MONITOR_VERSION   0x00000000
	Version number of the transport API. More...

Typedefs
typedef int(*	GNUNET_TRANSPORT_CommunicatorMqInit) (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
	Function called by the transport service to initialize a message queue given address information about another peer. More...
typedef void(*	GNUNET_TRANSPORT_CommunicatorNotify) (void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
	Function called when the transport service has received a backchannel message for this communicator (!) via a different return path. More...
typedef void(*	GNUNET_TRANSPORT_MessageCompletedCallback) (void *cls, int success)
	Function called to notify communicator that we have received and processed the message. More...
typedef void *(*	GNUNET_TRANSPORT_NotifyConnect) (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Function called to notify transport users that another peer connected to us. More...
typedef void(*	GNUNET_TRANSPORT_NotifyDisconnect) (void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
	Function called to notify transport users that another peer disconnected from us. More...
typedef void(*	GNUNET_TRANSPORT_MonitorCallback) (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_TRANSPORT_MonitorInformation *mi)
	Function to call with information about a peer. More...

Enumerations
enum	GNUNET_TRANSPORT_CommunicatorCharacteristics { GNUNET_TRANSPORT_CC_UNKNOWN = 0 , GNUNET_TRANSPORT_CC_RELIABLE = 1 , GNUNET_TRANSPORT_CC_UNRELIABLE = 2 }
	What characteristics does this communicator have? More...
enum	GNUNET_TRANSPORT_ConnectionStatus { GNUNET_TRANSPORT_CS_DOWN = -1 , GNUNET_TRANSPORT_CS_OUTBOUND = 0 , GNUNET_TRANSPORT_CS_INBOUND = 1 }
	Possible states of a connection. More...

Functions
struct GNUNET_TRANSPORT_ApplicationHandle *	GNUNET_TRANSPORT_application_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Initialize the TRANSPORT application client handle. More...
void	GNUNET_TRANSPORT_application_done (struct GNUNET_TRANSPORT_ApplicationHandle *ch)
	Shutdown TRANSPORT application client. More...
struct GNUNET_TRANSPORT_ApplicationSuggestHandle *	GNUNET_TRANSPORT_application_suggest (struct GNUNET_TRANSPORT_ApplicationHandle *ch, const struct GNUNET_PeerIdentity *peer, enum GNUNET_MQ_PriorityPreferences pk, struct GNUNET_BANDWIDTH_Value32NBO bw)
	An application would like TRANSPORT to connect to a peer. More...
void	GNUNET_TRANSPORT_application_suggest_cancel (struct GNUNET_TRANSPORT_ApplicationSuggestHandle *sh)
	We no longer care about being connected to a peer. More...
void	GNUNET_TRANSPORT_application_validate (struct GNUNET_TRANSPORT_ApplicationHandle *ch, const struct GNUNET_PeerIdentity *peer, enum GNUNET_NetworkType nt, const char *addr)
	An application (or a communicator) has received a HELLO (or other address data of another peer) and wants TRANSPORT to validate that the address is correct. More...
struct GNUNET_TRANSPORT_CommunicatorHandle *	GNUNET_TRANSPORT_communicator_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section_name, const char *addr_prefix, enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc, GNUNET_TRANSPORT_CommunicatorMqInit mq_init, void *mq_init_cls, GNUNET_TRANSPORT_CommunicatorNotify notify_cb, void *notify_cb_cls)
	Connect to the transport service. More...
void	GNUNET_TRANSPORT_communicator_disconnect (struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
	Disconnect from the transport service. More...
int	GNUNET_TRANSPORT_communicator_receive (struct GNUNET_TRANSPORT_CommunicatorHandle *handle, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg, struct GNUNET_TIME_Relative expected_addr_validity, GNUNET_TRANSPORT_MessageCompletedCallback cb, void *cb_cls)
	Notify transport service that the communicator has received a message. More...
struct GNUNET_TRANSPORT_QueueHandle *	GNUNET_TRANSPORT_communicator_mq_add (struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *peer, const char *address, uint32_t mtu, uint64_t q_len, uint32_t priority, enum GNUNET_NetworkType nt, enum GNUNET_TRANSPORT_ConnectionStatus cs, struct GNUNET_MQ_Handle *mq)
	Notify transport service that a MQ became available due to an "inbound" connection or because the communicator discovered the presence of another peer. More...
void	GNUNET_TRANSPORT_communicator_mq_update (struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_TRANSPORT_QueueHandle *u_qh, uint64_t q_len, uint32_t priority)
	Notify transport service that an MQ was updated. More...
void	GNUNET_TRANSPORT_communicator_mq_del (struct GNUNET_TRANSPORT_QueueHandle *qh)
	Notify transport service that an MQ became unavailable due to a disconnect or timeout. More...
struct GNUNET_TRANSPORT_AddressIdentifier *	GNUNET_TRANSPORT_communicator_address_add (struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const char *address, enum GNUNET_NetworkType nt, struct GNUNET_TIME_Relative expiration)
	Notify transport service about an address that this communicator provides for this peer. More...
void	GNUNET_TRANSPORT_communicator_address_remove (struct GNUNET_TRANSPORT_AddressIdentifier *ai)
	Notify transport service about an address that this communicator no longer provides for this peer. More...
void	GNUNET_TRANSPORT_communicator_address_remove_all (struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
	Notify transport service that this communicator no longer provides all its addresses for this peer. More...
void	GNUNET_TRANSPORT_communicator_notify (struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *pid, const char *comm, const struct GNUNET_MessageHeader *header)
	The communicator asks the transport service to route a message via a different path to another communicator service at another peer. More...
struct GNUNET_TRANSPORT_CoreHandle *	GNUNET_TRANSPORT_core_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *self, const struct GNUNET_MQ_MessageHandler *handlers, void *cls, GNUNET_TRANSPORT_NotifyConnect nc, GNUNET_TRANSPORT_NotifyDisconnect nd)
	Connect to the transport service. More...
void	GNUNET_TRANSPORT_core_disconnect (struct GNUNET_TRANSPORT_CoreHandle *handle)
	Disconnect from the transport service. More...
struct GNUNET_TRANSPORT_MonitorContext *	GNUNET_TRANSPORT_monitor (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *peer, int one_shot, GNUNET_TRANSPORT_MonitorCallback cb, void *cb_cls)
	Return information about a specific peer or all peers currently known to transport service once or in monitoring mode. More...
void	GNUNET_TRANSPORT_monitor_cancel (struct GNUNET_TRANSPORT_MonitorContext *mc)
	Cancel request to monitor peers. More...

Detailed Description

Low-level communication with other peers.

Communication with other peers.

See also

Documentation

Macro Definition Documentation

GNUNET_TRANSPORT_COMMUNICATION_VERSION

#define GNUNET_TRANSPORT_COMMUNICATION_VERSION   0x00000000

Version number of the transport communication API.

Definition at line 55 of file gnunet_transport_communication_service.h.

GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED

#define GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED   UINT64_MAX

Queue length.

Definition at line 60 of file gnunet_transport_communication_service.h.

GNUNET_TRANSPORT_CORE_VERSION

#define GNUNET_TRANSPORT_CORE_VERSION   0x00000000

Version number of the transport API.

Definition at line 52 of file gnunet_transport_core_service.h.

GNUNET_TRANSPORT_MONITOR_VERSION

#define GNUNET_TRANSPORT_MONITOR_VERSION   0x00000000

Version number of the transport API.

Definition at line 57 of file gnunet_transport_monitor_service.h.

Typedef Documentation

GNUNET_TRANSPORT_CommunicatorMqInit

typedef int(* GNUNET_TRANSPORT_CommunicatorMqInit) (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)

Function called by the transport service to initialize a message queue given address information about another peer.

If and when the communication channel is established, the communicator must call GNUNET_TRANSPORT_communicator_mq_add() to notify the service that the channel is now up. It is the responsibility of the communicator to manage sane retries and timeouts for any peer/address combination provided by the transport service. Timeouts and retries do not need to be signalled to the transport service.

Parameters

cls	closure
peer	identity of the other peer
address	where to send the message, human-readable communicator-specific format, 0-terminated, UTF-8

Returns

GNUNET_OK on success, GNUNET_SYSERR if the provided address is invalid

Definition at line 80 of file gnunet_transport_communication_service.h.

GNUNET_TRANSPORT_CommunicatorNotify

typedef void(* GNUNET_TRANSPORT_CommunicatorNotify) (void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)

Function called when the transport service has received a backchannel message for this communicator (!) via a different return path.

Typically used to receive messages of type GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_FC_LIMITS or GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_KX_CONFIRMATION as well as communicator-specific messages to assist with NAT traversal.

Parameters

cls	closure
sender	which peer sent the notification
msg	payload

Definition at line 132 of file gnunet_transport_communication_service.h.

GNUNET_TRANSPORT_MessageCompletedCallback

typedef void(* GNUNET_TRANSPORT_MessageCompletedCallback) (void *cls, int success)

Function called to notify communicator that we have received and processed the message.

Used for flow control (if supported by the communicator).

Parameters

cls	closure
success	GNUNET_SYSERR on failure (try to disconnect/reset connection) GNUNET_OK on success

Definition at line 188 of file gnunet_transport_communication_service.h.

GNUNET_TRANSPORT_NotifyConnect

typedef void*(* GNUNET_TRANSPORT_NotifyConnect) (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)

Function called to notify transport users that another peer connected to us.

Parameters

cls	closure
peer	the identity of the peer that connected; this pointer will remain valid until the disconnect, hence applications do not necessarily have to make a copy of the value if they only need it until disconnect
mq	message queue to use to transmit to peer

Returns

closure to use in MQ handlers

Definition at line 73 of file gnunet_transport_core_service.h.

GNUNET_TRANSPORT_NotifyDisconnect

typedef void(* GNUNET_TRANSPORT_NotifyDisconnect) (void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)

Function called to notify transport users that another peer disconnected from us.

The message queue that was given to the connect notification will be destroyed and must not be used henceforth.

Parameters

cls	closure from GNUNET_TRANSPORT_core_connect
peer	the peer that disconnected
handlers_cls	closure of the handlers, was returned from the connect notification callback

Definition at line 90 of file gnunet_transport_core_service.h.

GNUNET_TRANSPORT_MonitorCallback

typedef void(* GNUNET_TRANSPORT_MonitorCallback) (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_TRANSPORT_MonitorInformation *mi)

Function to call with information about a peer.

If one_shot was set to GNUNET_YES to iterate over all peers once, a final call with NULL for peer and address will follow when done. In this case state and timeout do not contain valid values.

The GNUNET_TRANSPORT_monitor_peers_cancel() call MUST not be called from within this function!

Parameters

cls	closure
peer	peer this update is about, NULL if this is the final last callback for a iteration operation
mi	monitoring data on the peer

Definition at line 128 of file gnunet_transport_monitor_service.h.

Enumeration Type Documentation

GNUNET_TRANSPORT_CommunicatorCharacteristics

enum GNUNET_TRANSPORT_CommunicatorCharacteristics

What characteristics does this communicator have?

FIXME: may want to distinguish bi-directional as well, should we define a bit for that? Needed in DV logic (handle_dv_learn)!

Enumerator
GNUNET_TRANSPORT_CC_UNKNOWN	Characteristics are unknown (e.g. DV).
GNUNET_TRANSPORT_CC_RELIABLE	Transmission is reliabile (with ACKs), e.g. TCP/HTTP/HTTPS.
GNUNET_TRANSPORT_CC_UNRELIABLE	Transmission is unreliable (e.g. UDP)

Definition at line 98 of file gnunet_transport_communication_service.h.

{
  GNUNET_TRANSPORT_CC_UNKNOWN = 0,
 
  GNUNET_TRANSPORT_CC_RELIABLE = 1,
 
  GNUNET_TRANSPORT_CC_UNRELIABLE = 2
};

GNUNET_TRANSPORT_ConnectionStatus

enum GNUNET_TRANSPORT_ConnectionStatus

Possible states of a connection.

Enumerator
GNUNET_TRANSPORT_CS_DOWN	Connection is down.
GNUNET_TRANSPORT_CS_OUTBOUND	this is an outbound connection (transport initiated)
GNUNET_TRANSPORT_CS_INBOUND	this is an inbound connection (communicator initiated)

Definition at line 235 of file gnunet_transport_communication_service.h.

{
  GNUNET_TRANSPORT_CS_DOWN = -1,
 
  GNUNET_TRANSPORT_CS_OUTBOUND = 0,
 
  GNUNET_TRANSPORT_CS_INBOUND = 1
};

Function Documentation

GNUNET_TRANSPORT_application_init()

struct GNUNET_TRANSPORT_ApplicationHandle* GNUNET_TRANSPORT_application_init

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Initialize the TRANSPORT application client handle.

Parameters

cfg	configuration to use

Returns

ats application handle, NULL on error

Initialize the TRANSPORT application client handle.

Parameters

cfg	configuration to use

Returns

transport application handle, NULL on error

Definition at line 219 of file transport_api2_application.c.

{
  struct GNUNET_TRANSPORT_ApplicationHandle *ch;
 
  ch = GNUNET_new (struct GNUNET_TRANSPORT_ApplicationHandle);
  ch->cfg = cfg;
  ch->sug_requests = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
  reconnect (ch);
  return ch;
}

References cfg, ch, GNUNET_CONTAINER_multipeermap_create(), GNUNET_new, GNUNET_YES, and reconnect().

Referenced by GNUNET_TRANSPORT_TESTING_start_peer(), run(), and start_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_application_done()

void GNUNET_TRANSPORT_application_done

(

struct GNUNET_TRANSPORT_ApplicationHandle *

ch

)

Shutdown TRANSPORT application client.

Parameters

ch	handle to destroy

Shutdown TRANSPORT application client.

Parameters

ch	handle to release

Definition at line 257 of file transport_api2_application.c.

{
  if (NULL != ch->mq)
  {
    GNUNET_MQ_destroy (ch->mq);
    ch->mq = NULL;
  }
  if (NULL != ch->task)
  {
    GNUNET_SCHEDULER_cancel (ch->task);
    ch->task = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
                                         &free_sug_handle,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (ch->sug_requests);
  GNUNET_free (ch);
}

References ch, free_sug_handle(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), and GNUNET_CADET_Channel::mq.

Referenced by do_shutdown(), GNUNET_TRANSPORT_TESTING_stop_peer(), and stop_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_application_suggest()

struct GNUNET_TRANSPORT_ApplicationSuggestHandle* GNUNET_TRANSPORT_application_suggest	(	struct GNUNET_TRANSPORT_ApplicationHandle *	ch,
		const struct GNUNET_PeerIdentity *	peer,
		enum GNUNET_MQ_PriorityPreferences	pk,
		struct GNUNET_BANDWIDTH_Value32NBO	bw
	)

An application would like TRANSPORT to connect to a peer.

Parameters

ch	handle
peer	identity of the peer we need an address for
pk	what kind of application will the application require (can be GNUNET_MQ_PRIO_BACKGROUND, we will still try to connect)
bw	desired bandwidth, can be zero (we will still try to connect)

Returns

suggest handle, NULL if a request is already pending

Definition at line 289 of file transport_api2_application.c.

{
  struct GNUNET_TRANSPORT_ApplicationSuggestHandle *s;
 
  s = GNUNET_new (struct GNUNET_TRANSPORT_ApplicationSuggestHandle);
  s->ch = ch;
  s->id = *peer;
  s->pk = pk;
  s->bw = bw;
  (void) GNUNET_CONTAINER_multipeermap_put (
    ch->sug_requests,
    &s->id,
    s,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Requesting TRANSPORT to suggest address for `%s'\n",
       GNUNET_i2s (peer));
  if (NULL == ch->mq)
    return s;
  GNUNET_assert (GNUNET_OK == transmit_suggestion (ch, &s->id, s));
  return s;
}

References bw, GNUNET_TRANSPORT_ApplicationSuggestHandle::bw, ch, GNUNET_TRANSPORT_ApplicationSuggestHandle::ch, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_new, GNUNET_OK, GNUNET_TRANSPORT_ApplicationSuggestHandle::id, LOG, GNUNET_CADET_Channel::mq, peer, pk, GNUNET_TRANSPORT_ApplicationSuggestHandle::pk, and transmit_suggestion().

Here is the call graph for this function:

GNUNET_TRANSPORT_application_suggest_cancel()

void GNUNET_TRANSPORT_application_suggest_cancel

(

struct GNUNET_TRANSPORT_ApplicationSuggestHandle *

sh

)

We no longer care about being connected to a peer.

Parameters

sh	handle to stop

Definition at line 323 of file transport_api2_application.c.

{
  struct GNUNET_TRANSPORT_ApplicationHandle *ch = sh->ch;
  struct GNUNET_MQ_Envelope *ev;
  struct ExpressPreferenceMessage *m;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Telling TRANSPORT we no longer care for an address for `%s'\n",
       GNUNET_i2s (&sh->id));
  GNUNET_assert (
    GNUNET_OK ==
    GNUNET_CONTAINER_multipeermap_remove (ch->sug_requests, &sh->id, sh));
  if (NULL == ch->mq)
  {
    GNUNET_free (sh);
    return;
  }
  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL);
  m->pk = htonl ((uint32_t) sh->pk);
  m->bw = sh->bw;
  m->peer = sh->id;
  GNUNET_MQ_send (ch->mq, ev);
  GNUNET_free (sh);
}

References ch, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_OK, LOG, m, GNUNET_CADET_Channel::mq, and sh.

Here is the call graph for this function:

GNUNET_TRANSPORT_application_validate()

void GNUNET_TRANSPORT_application_validate	(	struct GNUNET_TRANSPORT_ApplicationHandle *	ch,
		const struct GNUNET_PeerIdentity *	peer,
		enum GNUNET_NetworkType	nt,
		const char *	addr
	)

An application (or a communicator) has received a HELLO (or other address data of another peer) and wants TRANSPORT to validate that the address is correct.

The result is NOT returned, in fact TRANSPORT may do nothing (i.e. if it has too many active validations or recently tried this one already). If the addr validates, TRANSPORT will persist the address with PEERSTORE.

Parameters

ch	handle
peer	identity of the peer we have an address for
nt	network type of addr (as claimed by the other peer); used by TRANSPORT to avoid trying addr's that really cannot work due to network type mismatches
addr	address to validate

Definition at line 366 of file transport_api2_application.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct RequestHelloValidationMessage *m;
  size_t alen;
 
  if (NULL == ch->mq)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      "Address validation for %s:%s skipped as transport is not connected\n",
      GNUNET_i2s (peer),
      addr);
    return;
  }
  alen = strlen (addr) + 1;
  ev =
    GNUNET_MQ_msg_extra (m,
                         alen,
                         GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION);
  m->peer = *peer;
  m->nt = htonl ((uint32_t) nt);
  memcpy (&m[1], addr, alen);
  GNUNET_MQ_send (ch->mq, ev);
}

Referenced by connect_peers_run(), offer_hello(), and sock_read().

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_connect()

struct GNUNET_TRANSPORT_CommunicatorHandle* GNUNET_TRANSPORT_communicator_connect	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	config_section_name,
		const char *	addr_prefix,
		enum GNUNET_TRANSPORT_CommunicatorCharacteristics	cc,
		GNUNET_TRANSPORT_CommunicatorMqInit	mq_init,
		void *	mq_init_cls,
		GNUNET_TRANSPORT_CommunicatorNotify	notify_cb,
		void *	notify_cb_cls
	)

Connect to the transport service.

Parameters

cfg	configuration to use
config_section_name	section of the configuration to use for options
addr_prefix	address prefix for addresses supported by this communicator, could be NULL for incoming-only communicators
cc	what characteristics does the communicator have?
mq_init	function to call to initialize a message queue given the address of another peer, can be NULL if the communicator only supports receiving messages
mq_init_cls	closure for mq_init
notify_cb	function to pass backchannel messages to communicator
notify_cb_cls	closure for notify_cb

Returns

NULL on error

Definition at line 816 of file transport_api2_communication.c.

{
  struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
 
  ch = GNUNET_new (struct GNUNET_TRANSPORT_CommunicatorHandle);
  ch->cfg = cfg;
  ch->config_section = config_section;
  ch->addr_prefix = addr_prefix;
  ch->mq_init = mq_init;
  ch->mq_init_cls = mq_init_cls;
  ch->notify_cb = notify_cb;
  ch->notify_cb_cls = notify_cb_cls;
  ch->cc = cc;
  reconnect (ch);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             config_section,
                                             "MAX_QUEUE_LENGTH",
                                             &ch->max_queue_length))
    ch->max_queue_length = DEFAULT_MAX_QUEUE_LENGTH;
  if (NULL == ch->mq)
  {
    GNUNET_free (ch);
    return NULL;
  }
  return ch;
}

References GNUNET_TRANSPORT_CommunicatorHandle::addr_prefix, GNUNET_TRANSPORT_CommunicatorHandle::cc, cfg, ch, GNUNET_TRANSPORT_CommunicatorHandle::config_section, DEFAULT_MAX_QUEUE_LENGTH, GNUNET_CONFIGURATION_get_value_number(), GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_CADET_Channel::mq, mq_init(), GNUNET_TRANSPORT_CommunicatorHandle::mq_init_cls, GNUNET_TRANSPORT_CommunicatorHandle::notify_cb, GNUNET_TRANSPORT_CommunicatorHandle::notify_cb_cls, and reconnect().

Referenced by init_socket(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_disconnect()

void GNUNET_TRANSPORT_communicator_disconnect

(

struct GNUNET_TRANSPORT_CommunicatorHandle *

ch

)

Disconnect from the transport service.

Parameters

ch	handle returned from connect

Definition at line 859 of file transport_api2_communication.c.

{
  disconnect (ch);
  while (NULL != ch->ai_head)
  {
    GNUNET_break (0);  /* communicator forgot to remove address, warn! */
    GNUNET_TRANSPORT_communicator_address_remove (ch->ai_head);
  }
  GNUNET_free (ch);
}

References ch, disconnect(), GNUNET_break, GNUNET_free, and GNUNET_TRANSPORT_communicator_address_remove().

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_receive()

int GNUNET_TRANSPORT_communicator_receive	(	struct GNUNET_TRANSPORT_CommunicatorHandle *	handle,
		const struct GNUNET_PeerIdentity *	sender,
		const struct GNUNET_MessageHeader *	msg,
		struct GNUNET_TIME_Relative	expected_addr_validity,
		GNUNET_TRANSPORT_MessageCompletedCallback	cb,
		void *	cb_cls
	)

Notify transport service that the communicator has received a message.

Parameters

handle	connection to transport service
sender	presumed sender of the message (details to be checked by higher layers)
msg	the message
expected_addr_validity	how long does the communicator believe it will continue to be able to receive messages from the same address on which it received this message?
cb	function to call once handling the message is done, NULL if flow control is not supported by this communicator
cb_cls	closure for cb

Returns

GNUNET_OK if all is well, GNUNET_NO if the message was immediately dropped due to memory limitations (communicator should try to apply back pressure), GNUNET_SYSERR if the message could not be delivered because the transport service is not yet up

Definition at line 876 of file transport_api2_communication.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_IncomingMessage *im;
  uint16_t msize;
 
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "communicator receive\n");
 
  if (NULL == ch->mq)
    return GNUNET_SYSERR;
  if ((NULL == cb) && (GNUNET_MQ_get_length (ch->mq) >= ch->max_queue_length))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      "Dropping message: transport is too slow, queue length %llu exceeded\n",
      ch->max_queue_length);
    return GNUNET_NO;
  }
 
  msize = ntohs (msg->size);
  env =
    GNUNET_MQ_msg_extra (im, msize, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG);
  if (NULL == env)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  im->expected_address_validity =
    GNUNET_TIME_relative_hton (expected_addr_validity);
  im->sender = *sender;
  // FIXME: this is expensive, would be better if we would
  // re-design the API to allow us to create the envelope first,
  // and then have the application fill in the body so we do
  // not have to memcpy()
  memcpy (&im[1], msg, msize);
  im->fc_on = htonl (GNUNET_NO);
  if (NULL != cb)
  {
    struct FlowControl *fc;
 
    im->fc_on = htonl (GNUNET_YES);
    im->fc_id = ch->fc_gen++;
    fc = GNUNET_new (struct FlowControl);
    fc->sender = *sender;
    fc->id = im->fc_id;
    fc->cb = cb;
    fc->cb_cls = cb_cls;
    GNUNET_CONTAINER_DLL_insert (ch->fc_head, ch->fc_tail, fc);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Created flow control id %" PRIu64 " for sender %s\n",
                fc->id,
                GNUNET_i2s (&fc->sender));
  }
  GNUNET_MQ_send (ch->mq, env);
  return GNUNET_OK;
}

References FlowControl::cb, FlowControl::cb_cls, ch, env, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG, GNUNET_MQ_get_length(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_relative_hton(), GNUNET_YES, FlowControl::id, GNUNET_CADET_Channel::mq, msg, FlowControl::sender, and GNUNET_MessageHeader::size.

Referenced by pass_plaintext_to_core(), and select_read_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_mq_add()

struct GNUNET_TRANSPORT_QueueHandle* GNUNET_TRANSPORT_communicator_mq_add	(	struct GNUNET_TRANSPORT_CommunicatorHandle *	ch,
		const struct GNUNET_PeerIdentity *	peer,
		const char *	address,
		uint32_t	mtu,
		uint64_t	q_len,
		uint32_t	priority,
		enum GNUNET_NetworkType	nt,
		enum GNUNET_TRANSPORT_ConnectionStatus	cs,
		struct GNUNET_MQ_Handle *	mq
	)

Notify transport service that a MQ became available due to an "inbound" connection or because the communicator discovered the presence of another peer.

Parameters

ch	connection to transport service
peer	peer with which we can now communicate
address	address in human-readable format, 0-terminated, UTF-8
mtu	maximum message size supported by queue, 0 if sending is not supported, SIZE_MAX for no MTU
q_len	number of messages that can be send through this queue
priority	queue priority. Queues with highest priority should be used
nt	which network type does the address belong to?
cs	what is the connection status of the queue?
mq	message queue of the peer

Returns

API handle identifying the new MQ

Definition at line 946 of file transport_api2_communication.c.

{
  struct GNUNET_TRANSPORT_QueueHandle *qh;
 
  // Do not notify the service if there is no intial capacity.
  GNUNET_assert (0 < q_len);
 
  qh = GNUNET_new (struct GNUNET_TRANSPORT_QueueHandle);
  qh->ch = ch;
  qh->peer = *peer;
  qh->address = GNUNET_strdup (address);
  qh->nt = nt;
  qh->mtu = mtu;
  qh->q_len = q_len;
  qh->priority = priority;
  qh->cs = cs;
  qh->mq = mq;
  qh->queue_id = ch->queue_gen++;
  GNUNET_CONTAINER_DLL_insert (ch->queue_head, ch->queue_tail, qh);
  send_add_queue (qh);
  return qh;
}

References address, GNUNET_TRANSPORT_QueueHandle::address, ch, GNUNET_TRANSPORT_QueueHandle::ch, GNUNET_TRANSPORT_QueueHandle::cs, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_strdup, mq, GNUNET_TRANSPORT_QueueHandle::mq, GNUNET_TRANSPORT_QueueHandle::mtu, nt, GNUNET_TRANSPORT_QueueHandle::nt, peer, GNUNET_TRANSPORT_QueueHandle::peer, GNUNET_TRANSPORT_QueueHandle::priority, GNUNET_TRANSPORT_QueueHandle::q_len, GNUNET_TRANSPORT_QueueHandle::queue_id, and send_add_queue().

Referenced by add_acks(), setup_queue(), setup_receiver_mq(), and try_handle_plaintext().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_mq_update()

void GNUNET_TRANSPORT_communicator_mq_update	(	struct GNUNET_TRANSPORT_CommunicatorHandle *	ch,
		const struct GNUNET_TRANSPORT_QueueHandle *	u_qh,
		uint64_t	q_len,
		uint32_t	priority
	)

Notify transport service that an MQ was updated.

Parameters

ch	connection to transport service
u_qh	the queue to update
q_len	number of messages that can be send through this queue
priority	queue priority. Queues with highest priority should be used

Definition at line 980 of file transport_api2_communication.c.

{
  struct GNUNET_TRANSPORT_QueueHandle *qh;
 
  for (qh = ch->queue_head; NULL != qh; qh = qh->next)
  {
    if (u_qh == qh)
      break;
  }
  GNUNET_assert (NULL != qh);
  qh->q_len = q_len;
  qh->priority = priority;
  send_update_queue (qh);
}

References ch, GNUNET_assert, GNUNET_TRANSPORT_QueueHandle::next, GNUNET_TRANSPORT_QueueHandle::priority, GNUNET_TRANSPORT_QueueHandle::q_len, and send_update_queue().

Referenced by add_acks().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_mq_del()

void GNUNET_TRANSPORT_communicator_mq_del

(

struct GNUNET_TRANSPORT_QueueHandle *

qh

)

Notify transport service that an MQ became unavailable due to a disconnect or timeout.

Parameters

qh	handle for the queue that must be invalidated

Definition at line 1007 of file transport_api2_communication.c.

{
  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = qh->ch;
 
  send_del_queue (qh);
  GNUNET_CONTAINER_DLL_remove (ch->queue_head, ch->queue_tail, qh);
  GNUNET_MQ_destroy (qh->mq);
  GNUNET_free (qh->address);
  GNUNET_free (qh);
}

References GNUNET_TRANSPORT_QueueHandle::address, ch, GNUNET_TRANSPORT_QueueHandle::ch, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_TRANSPORT_QueueHandle::mq, and send_del_queue().

Referenced by queue_destroy(), and receiver_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_address_add()

struct GNUNET_TRANSPORT_AddressIdentifier* GNUNET_TRANSPORT_communicator_address_add	(	struct GNUNET_TRANSPORT_CommunicatorHandle *	ch,
		const char *	address,
		enum GNUNET_NetworkType	nt,
		struct GNUNET_TIME_Relative	expiration
	)

Notify transport service about an address that this communicator provides for this peer.

Parameters

ch	connection to transport service
address	our address in human-readable format, 0-terminated, UTF-8
nt	which network type does the address belong to?
expiration	when does the communicator forsee this address expiring?

Definition at line 1029 of file transport_api2_communication.c.

{
  struct GNUNET_TRANSPORT_AddressIdentifier *ai;
 
  ai = GNUNET_new (struct GNUNET_TRANSPORT_AddressIdentifier);
  ai->ch = ch;
  ai->address = GNUNET_strdup (address);
  ai->nt = nt;
  ai->expiration = expiration;
  ai->aid = ch->aid_gen++;
  GNUNET_CONTAINER_DLL_insert (ch->ai_head, ch->ai_tail, ai);
  send_add_address (ai);
  return ai;
}

References address, GNUNET_TRANSPORT_AddressIdentifier::address, ai, GNUNET_TRANSPORT_AddressIdentifier::aid, ch, GNUNET_TRANSPORT_AddressIdentifier::ch, expiration, GNUNET_TRANSPORT_AddressIdentifier::expiration, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_strdup, nt, GNUNET_TRANSPORT_AddressIdentifier::nt, and send_add_address().

Referenced by nat_address_cb(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_address_remove()

void GNUNET_TRANSPORT_communicator_address_remove

(

struct GNUNET_TRANSPORT_AddressIdentifier *

ai

)

Notify transport service about an address that this communicator no longer provides for this peer.

Parameters

ai	address that is no longer provided

Definition at line 1056 of file transport_api2_communication.c.

{
  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = ai->ch;
 
  send_del_address (ai);
  GNUNET_CONTAINER_DLL_remove (ch->ai_head, ch->ai_tail, ai);
  GNUNET_free (ai->address);
  GNUNET_free (ai);
  ai = NULL;
}

References GNUNET_TRANSPORT_AddressIdentifier::address, ai, ch, GNUNET_TRANSPORT_AddressIdentifier::ch, GNUNET_CONTAINER_DLL_remove, GNUNET_free, and send_del_address().

Referenced by do_shutdown(), GNUNET_TRANSPORT_communicator_address_remove_all(), GNUNET_TRANSPORT_communicator_disconnect(), and nat_address_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_address_remove_all()

void GNUNET_TRANSPORT_communicator_address_remove_all

(

struct GNUNET_TRANSPORT_CommunicatorHandle *

ch

)

Notify transport service that this communicator no longer provides all its addresses for this peer.

Parameters

ch	The communicator handle.

Definition at line 1075 of file transport_api2_communication.c.

{
  struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head;
  while (NULL != ai)
  {
    struct GNUNET_TRANSPORT_AddressIdentifier *ai_next = ai->next;
    GNUNET_TRANSPORT_communicator_address_remove (ai);
    ai = ai_next;
  }
}

References ai, ch, GNUNET_TRANSPORT_communicator_address_remove(), and GNUNET_TRANSPORT_AddressIdentifier::next.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_communicator_notify()

void GNUNET_TRANSPORT_communicator_notify	(	struct GNUNET_TRANSPORT_CommunicatorHandle *	ch,
		const struct GNUNET_PeerIdentity *	pid,
		const char *	comm,
		const struct GNUNET_MessageHeader *	header
	)

The communicator asks the transport service to route a message via a different path to another communicator service at another peer.

This must only be done for special control traffic (as there is no flow control for this API), such as acknowledgements, and generally only be done if the communicator is uni-directional (i.e. cannot send the message back itself).

While backchannel messages are signed and encrypted, communicators must protect against replay attacks when using this backchannel communication!

Parameters

ch	handle of this communicator
pid	peer to send the message to
comm	name of the communicator to send the message to
header	header of the message to transmit and pass via the notify-API to pid's communicator comm

Definition at line 1092 of file transport_api2_communication.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb;
  size_t slen = strlen (comm) + 1;
  uint16_t mlen = ntohs (header->size);
 
  GNUNET_assert (mlen + slen + sizeof(*cb) < UINT16_MAX);
  env =
    GNUNET_MQ_msg_extra (cb,
                         slen + mlen,
                         GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL);
  cb->pid = *pid;
  memcpy (&cb[1], header, mlen);
  memcpy (((char *) &cb[1]) + mlen, comm, slen);
  GNUNET_MQ_send (ch->mq, env);
}

References ch, env, GNUNET_assert, GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_CADET_Channel::mq, pid, and GNUNET_MessageHeader::size.

Referenced by consider_ss_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_core_connect()

struct GNUNET_TRANSPORT_CoreHandle* GNUNET_TRANSPORT_core_connect	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_PeerIdentity *	self,
		const struct GNUNET_MQ_MessageHandler *	handlers,
		void *	cls,
		GNUNET_TRANSPORT_NotifyConnect	nc,
		GNUNET_TRANSPORT_NotifyDisconnect	nd
	)

Connect to the transport service.

Note that the connection may complete (or fail) asynchronously.

Parameters

cfg	configuration to use
self	our own identity (API should check that it matches the identity found by transport), or NULL (no check)
handlers	array of message handlers; note that the closures provided will be ignored and replaced with the respective return value from nc
handlers	array with handlers to call when we receive messages, or NULL
cls	closure for the nc, nd and neb callbacks
nc	function to call on connect events, or NULL
nd	function to call on disconnect events, or NULL
neb	function to call if we have excess bandwidth to a peer, or NULL

Returns

NULL on error

Referenced by GNUNET_TRANSPORT_TESTING_restart_peer(), GNUNET_TRANSPORT_TESTING_start_peer(), GSC_KX_init(), opstart_get_handle_transport(), run(), and start_peer_run().

Here is the caller graph for this function:

GNUNET_TRANSPORT_core_disconnect()

void GNUNET_TRANSPORT_core_disconnect

(

struct GNUNET_TRANSPORT_CoreHandle *

handle

)

Disconnect from the transport service.

Parameters

handle	handle returned from connect
handle	handle to the service as returned from GNUNET_TRANSPORT_core_connect()

Definition at line 912 of file transport_api_core.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
  /* this disconnects all neighbours... */
  if (NULL == handle->reconnect_task)
    disconnect_and_schedule_reconnect (handle);
  /* and now we stop trying to connect again... */
  if (NULL != handle->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
    handle->reconnect_task = NULL;
  }
  GNUNET_CONTAINER_multipeermap_destroy (handle->neighbours);
  handle->neighbours = NULL;
  GNUNET_free (handle->handlers);
  handle->handlers = NULL;
  GNUNET_free (handle);
}

References disconnect_and_schedule_reconnect(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SCHEDULER_cancel(), handle, LOG, and GNUNET_DNS_Handle::reconnect_task.

Referenced by GNUNET_TRANSPORT_TESTING_restart_peer(), GNUNET_TRANSPORT_TESTING_stop_peer(), GSC_KX_done(), oprelease_get_handle_transport(), shutdown_task(), and stop_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_monitor()

struct GNUNET_TRANSPORT_MonitorContext* GNUNET_TRANSPORT_monitor	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_PeerIdentity *	peer,
		int	one_shot,
		GNUNET_TRANSPORT_MonitorCallback	cb,
		void *	cb_cls
	)

Return information about a specific peer or all peers currently known to transport service once or in monitoring mode.

To obtain information about a specific peer, a peer identity can be passed. To obtain information about all peers currently known to transport service, NULL can be passed as peer identity.

For each peer, the callback is called with information about the address used to communicate with this peer, the state this peer is currently in and the the current timeout for this state.

Upon completion, the GNUNET_TRANSPORT_PeerIterateCallback is called one more time with NULL. After this, the operation must no longer be explicitly canceled.

The GNUNET_TRANSPORT_monitor_peers_cancel call MUST not be called in the the peer_callback!

Parameters

cfg	configuration to use
peer	a specific peer identity to obtain information for, NULL for all peers
one_shot	GNUNET_YES to return the current state and then end (with NULL+NULL), GNUNET_NO to monitor peers continuously
cb	function to call with the results
cb_cls	closure for mc

Definition at line 254 of file transport_api2_monitor.c.

{
  struct GNUNET_TRANSPORT_MonitorContext *mc;
 
  mc = GNUNET_new (struct GNUNET_TRANSPORT_MonitorContext);
  mc->cfg = cfg;
  if (NULL != peer)
    mc->peer = *peer;
  mc->one_shot = one_shot;
  mc->cb = cb;
  mc->cb_cls = cb_cls;
  reconnect (mc);
  if (NULL == mc->mq)
  {
    GNUNET_free (mc);
    return NULL;
  }
  return mc;
}

References GNUNET_TRANSPORT_MonitorContext::cb, GNUNET_TRANSPORT_MonitorContext::cb_cls, cfg, GNUNET_TESTBED_Controller::cfg, GNUNET_free, GNUNET_new, mc, GNUNET_TESTBED_Controller::mq, GNUNET_TRANSPORT_MonitorContext::one_shot, peer, and reconnect().

Here is the call graph for this function:

GNUNET_TRANSPORT_monitor_cancel()

void GNUNET_TRANSPORT_monitor_cancel

(

struct GNUNET_TRANSPORT_MonitorContext *

mc

)

Cancel request to monitor peers.

Parameters

mc	handle for the request to cancel
pmc	handle for the request to cancel

Definition at line 285 of file transport_api2_monitor.c.

{
  disconnect (mc);
  GNUNET_free (mc);
}

References disconnect(), GNUNET_free, and mc.

Referenced by handle_monitor_end().

Here is the call graph for this function:

Here is the caller graph for this function: