library to access the transport service for message exchange More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_arm_service.h"
#include "gnunet_protocols.h"
#include "gnunet_transport_core_service.h"
#include "transport.h"

Include dependency graph for transport_api_core.c:

Data Structures
struct	Neighbour
	A neighbour that at least one communicator is connected to. More...

struct	GNUNET_TRANSPORT_CoreHandle
	Handle for the transport service (includes all of the state for the transport service). More...

Macros
#define	LOG(kind, ...) GNUNET_log_from (kind, "transport-api-core", __VA_ARGS__)

#define	STARTING_NEIGHBOURS_SIZE 16
	How large to start with for the hashmap of neighbours. More...

#define	SEND_WINDOW_SIZE 4
	Window size. More...

Functions
static void	disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h)
	Function that will schedule the job that will try to connect us again to the client. More...

static struct Neighbour *	neighbour_find (struct GNUNET_TRANSPORT_CoreHandle h, const struct GNUNET_PeerIdentity peer)
	Get the neighbour list entry for the given peer. More...

static int	neighbour_delete (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Iterator over hash map entries, for deleting state of a neighbour. More...

static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...

static void	notify_send_done (void *cls)
	A message from the handler's message queue to a neighbour was transmitted. More...

static void	do_send (struct Neighbour *n)
	We have an envelope waiting for transmission at n, and our transmission window is positive. More...

static void	mq_send_impl (struct GNUNET_MQ_Handle mq, const struct GNUNET_MessageHeader msg, void *impl_state)
	Implement sending functionality of a message queue. More...

static void	mq_destroy_impl (struct GNUNET_MQ_Handle mq, void impl_state)
	Handle destruction of a message queue. More...

static void	mq_cancel_impl (struct GNUNET_MQ_Handle mq, void impl_state)
	Implementation function that cancels the currently sent message. More...

static void	peer_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	We had an error processing a message we forwarded from a peer to the CORE service. More...

static void	handle_connect (void cls, const struct ConnectInfoMessage cim)
	Function we use for handling incoming connect messages. More...

static void	handle_disconnect (void cls, const struct DisconnectInfoMessage dim)
	Function we use for handling incoming disconnect messages. More...

static void	handle_send_ok (void cls, const struct SendOkMessage okm)
	Function we use for handling incoming send-ok messages. More...

static int	check_recv (void cls, const struct InboundMessage im)
	Function we use for checking incoming "inbound" messages. More...

static void	handle_recv (void cls, const struct InboundMessage im)
	Function we use for handling incoming messages. More...

static void	reconnect (void *cls)
	Try again to connect to transport service. More...

static void	disconnect (struct GNUNET_TRANSPORT_CoreHandle *h)
	Disconnect from the transport service. More...

struct GNUNET_MQ_Handle *	GNUNET_TRANSPORT_core_get_mq (struct GNUNET_TRANSPORT_CoreHandle handle, const struct GNUNET_PeerIdentity peer)
	Checks if a given peer is connected to us and get the message queue. More...

Detailed Description

library to access the transport service for message exchange

Author: Christian Grothoff

Definition in file transport_api_core.c.

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log_from (kind, "transport-api-core", __VA_ARGS__)

Definition at line 34 of file transport_api_core.c.

◆ STARTING_NEIGHBOURS_SIZE

#define STARTING_NEIGHBOURS_SIZE 16

How large to start with for the hashmap of neighbours.

Definition at line 39 of file transport_api_core.c.

◆ SEND_WINDOW_SIZE

#define SEND_WINDOW_SIZE 4

Window size.

How many messages to the same target do we pass to TRANSPORT without a SEND_OK in between? Small values limit throughput, large values will increase latency.

FIXME-OPTIMIZE: find out what good values are experimentally, maybe set adaptively (i.e. to observed available bandwidth).

Definition at line 49 of file transport_api_core.c.

Function Documentation

◆ disconnect_and_schedule_reconnect()

static void disconnect_and_schedule_reconnect ( struct GNUNET_TRANSPORT_CoreHandle * h )

static

Function that will schedule the job that will try to connect us again to the client.

Parameters

h	transport service to reconnect

Definition at line 677 of file transport_api_core.c.

{
  GNUNET_assert (NULL == h->reconnect_task);
  disconnect (h);
  {
    /* Reduce delay based on runtime of the connection,
       so that there is a cool-down if a connection is up
       for a while. */
    struct GNUNET_TIME_Relative runtime;
    unsigned int minutes;
 
    runtime = GNUNET_TIME_absolute_get_duration (h->restarted_at);
    minutes = runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us;
    if (minutes > 31)
      h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
    else
      h->reconnect_delay.rel_value_us >>= minutes;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Scheduling task to reconnect to transport service in %s.\n",
       GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay, GNUNET_YES));
  h->reconnect_task =
    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
}

References disconnect(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_STD_BACKOFF, GNUNET_TIME_UNIT_MINUTES, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, h, LOG, reconnect(), GNUNET_ARM_Handle::reconnect_task, and GNUNET_TIME_Relative::rel_value_us.

Referenced by handle_connect(), handle_disconnect(), handle_recv(), handle_send_ok(), and mq_error_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ neighbour_find()

static struct Neighbour * neighbour_find	(	struct GNUNET_TRANSPORT_CoreHandle *	h,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Get the neighbour list entry for the given peer.

Parameters

h	our context
peer	peer to look up

Returns: NULL if no such peer entry exists

Definition at line 193 of file transport_api_core.c.

{
  return GNUNET_CONTAINER_multipeermap_get (h->neighbours, peer);
}

References GNUNET_CONTAINER_multipeermap_get(), and h.

Referenced by GNUNET_TRANSPORT_core_get_mq(), handle_connect(), handle_disconnect(), handle_recv(), and handle_send_ok().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ neighbour_delete()

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

static

Iterator over hash map entries, for deleting state of a neighbour.

Parameters

cls	the `struct GNUNET_TRANSPORT_CoreHandle *`
key	peer identity
value	value in the hash map, the neighbour entry to delete

Returns: GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 211 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *handle = cls;
  struct Neighbour *n = value;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Dropping entry for neighbour `%s'.\n",
       GNUNET_i2s (key));
  if (NULL != handle->nd_cb)
    handle->nd_cb (handle->cls, &n->id, n->handlers_cls);
  if (NULL != n->env)
  {
    GNUNET_MQ_send_cancel (n->env);
    n->env = NULL;
  }
  GNUNET_MQ_destroy (n->mq);
  GNUNET_assert (NULL == n->mq);
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (handle->neighbours, key, n));
  GNUNET_free (n);
  return GNUNET_YES;
}

References GNUNET_TRANSPORT_CoreHandle::cls, Neighbour::env, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_MQ_destroy(), GNUNET_MQ_send_cancel(), GNUNET_YES, handle, Neighbour::handlers_cls, Neighbour::id, key, LOG, Neighbour::mq, and value.

Referenced by disconnect(), and handle_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mq_error_handler()

static void mq_error_handler	(	void *	cls,
		enum GNUNET_MQ_Error	error
	)

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	closure with the `struct GNUNET_TRANSPORT_CoreHandle *`
error	error code

Definition at line 246 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Error %u received from transport service, disconnecting temporarily.\n",
       error);
  disconnect_and_schedule_reconnect (h);
}

References GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), GNUNET_ERROR_TYPE_DEBUG, h, and LOG.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_send_done()

static void notify_send_done ( void * cls )

static

A message from the handler's message queue to a neighbour was transmitted.

Now trigger (possibly delayed) notification of the neighbour's message queue that we are done and thus ready for the next message. Note that the MQ being ready is independent of the send window, as we may queue many messages and simply not pass them to TRANSPORT if the send window is insufficient.

Parameters

cls	the `struct Neighbour` where the message was sent

Definition at line 268 of file transport_api_core.c.

{
  struct Neighbour *n = cls;
 
  n->awaiting_done = GNUNET_NO;
  n->env = NULL;
  if (0 < n->ready_window)
    GNUNET_MQ_impl_send_continue (n->mq);
}

References Neighbour::awaiting_done, Neighbour::env, GNUNET_MQ_impl_send_continue(), GNUNET_NO, Neighbour::mq, and Neighbour::ready_window.

Referenced by do_send().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_send()

static void do_send ( struct Neighbour * n )

static

We have an envelope waiting for transmission at n, and our transmission window is positive.

Perform the transmission.

Parameters

n	neighbour to perform transmission for

Definition at line 286 of file transport_api_core.c.

{
  GNUNET_assert (0 < n->ready_window);
  GNUNET_assert (NULL != n->env);
  n->ready_window--;
  n->awaiting_done = GNUNET_YES;
  GNUNET_MQ_notify_sent (n->env, &notify_send_done, n);
  GNUNET_MQ_send (n->h->mq, n->env);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Passed message of type %u for neighbour `%s' to TRANSPORT. ready_window %u\n",
       ntohs (GNUNET_MQ_env_get_msg (n->env)->type),
       GNUNET_i2s (&n->id),
       n->ready_window);
}

References Neighbour::awaiting_done, Neighbour::env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_env_get_msg(), GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_YES, Neighbour::h, Neighbour::id, LOG, GNUNET_TRANSPORT_CoreHandle::mq, notify_send_done(), Neighbour::ready_window, and GNUNET_MessageHeader::type.

Referenced by handle_send_ok(), and mq_send_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mq_send_impl()

static void mq_send_impl	(	struct GNUNET_MQ_Handle *	mq,
		const struct GNUNET_MessageHeader *	msg,
		void *	impl_state
	)

static

Implement sending functionality of a message queue.

Called one message at a time. Should send the msg to the transport service and then notify the queue once we are ready for the next one.

Parameters

mq	the message queue
msg	the message to send
impl_state	state of the implementation

Definition at line 313 of file transport_api_core.c.

{
  struct Neighbour *n = impl_state;
  struct OutboundMessage *obm;
  uint16_t msize;
 
  msize = ntohs (msg->size);
  if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*obm))
  {
    GNUNET_break (0);
    GNUNET_MQ_impl_send_continue (mq);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "CORE requested transmission of message of type %u to neighbour `%s'.\n",
       ntohs (msg->type),
       GNUNET_i2s (&n->id));
 
  GNUNET_assert (NULL == n->env);
  n->env =
    GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg);
  n->env_size = ntohs (msg->size);
  {
    struct GNUNET_MQ_Envelope *env;
    enum GNUNET_MQ_PriorityPreferences prio;
 
    env = GNUNET_MQ_get_current_envelope (mq);
    prio = GNUNET_MQ_env_get_options (env);
    obm->priority = htonl ((uint32_t) prio);
  }
  obm->peer = n->id;
  if (0 == n->ready_window)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Flow control delays transmission to CORE until we see SEND_OK.\n");
    return;   /* can't send yet, need to wait for SEND_OK */
  }
  do_send (n);
}

References do_send(), env, Neighbour::env, Neighbour::env_size, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, GNUNET_MQ_env_get_options(), GNUNET_MQ_get_current_envelope(), GNUNET_MQ_impl_send_continue(), GNUNET_MQ_msg_nested_mh, Neighbour::id, LOG, mq, msg, OutboundMessage::peer, OutboundMessage::priority, Neighbour::ready_window, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by handle_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mq_destroy_impl()

static void mq_destroy_impl	(	struct GNUNET_MQ_Handle *	mq,
		void *	impl_state
	)

static

Handle destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters

mq	the message queue to destroy
impl_state	state of the implementation

Definition at line 364 of file transport_api_core.c.

{
  struct Neighbour *n = impl_state;
 
  GNUNET_assert (mq == n->mq);
  n->mq = NULL;
}

References GNUNET_assert, mq, and Neighbour::mq.

Referenced by handle_connect().

Here is the caller graph for this function:

◆ mq_cancel_impl()

static void mq_cancel_impl	(	struct GNUNET_MQ_Handle *	mq,
		void *	impl_state
	)

static

Implementation function that cancels the currently sent message.

Should basically undo whatever mq_send_impl() did.

Parameters

mq	message queue
impl_state	state specific to the implementation

Definition at line 381 of file transport_api_core.c.

{
  struct Neighbour *n = impl_state;
 
  n->ready_window++;
  if (GNUNET_YES == n->awaiting_done)
  {
    GNUNET_MQ_send_cancel (n->env);
    n->env = NULL;
    n->awaiting_done = GNUNET_NO;
  }
  else
  {
    GNUNET_assert (0 == n->ready_window);
    n->env = NULL;
  }
}

References Neighbour::awaiting_done, Neighbour::env, GNUNET_assert, GNUNET_MQ_send_cancel(), GNUNET_NO, GNUNET_YES, and Neighbour::ready_window.

Referenced by handle_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peer_mq_error_handler()

static void peer_mq_error_handler	(	void *	cls,
		enum GNUNET_MQ_Error	error
	)

static

We had an error processing a message we forwarded from a peer to the CORE service.

We should just complain about it but otherwise continue processing.

Parameters

cls	closure
error	error code

Definition at line 409 of file transport_api_core.c.

{
  struct Neighbour *n = cls;
 
  if (GNUNET_MQ_ERROR_MALFORMED == error)
    GNUNET_break_op (0);
  //TODO Look into bug #7887
 
  GNUNET_TRANSPORT_core_receive_continue (n->h, &n->id);
}

References GNUNET_break_op, GNUNET_MQ_ERROR_MALFORMED, Neighbour::h, and Neighbour::id.

Referenced by handle_connect().

Here is the caller graph for this function:

◆ handle_connect()

static void handle_connect	(	void *	cls,
		const struct ConnectInfoMessage *	cim
	)

static

Function we use for handling incoming connect messages.

Parameters

cls	closure, a `struct GNUNET_TRANSPORT_Handle *`
cim	message received

Definition at line 428 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
  struct Neighbour *n;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Receiving CONNECT message for `%s'\n",
       GNUNET_i2s (&cim->id));
  n = neighbour_find (h, &cim->id);
  if (NULL != n)
  {
    GNUNET_break (0);
    disconnect_and_schedule_reconnect (h);
    return;
  }
  n = GNUNET_new (struct Neighbour);
  n->id = cim->id;
  n->h = h;
  n->ready_window = SEND_WINDOW_SIZE;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_put (
                   h->neighbours,
                   &n->id,
                   n,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
  n->mq = GNUNET_MQ_queue_for_callbacks (&mq_send_impl,
                                         &mq_destroy_impl,
                                         &mq_cancel_impl,
                                         n,
                                         h->handlers,
                                         &peer_mq_error_handler,
                                         n);
  if (NULL != h->nc_cb)
  {
    n->handlers_cls = h->nc_cb (h->cls, &n->id, n->mq);
    GNUNET_MQ_set_handlers_closure (n->mq, n->handlers_cls);
  }
}

References GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_queue_for_callbacks(), GNUNET_MQ_set_handlers_closure(), GNUNET_new, GNUNET_OK, h, Neighbour::h, Neighbour::handlers_cls, ConnectInfoMessage::id, Neighbour::id, LOG, Neighbour::mq, mq_cancel_impl(), mq_destroy_impl(), mq_send_impl(), neighbour_find(), peer_mq_error_handler(), Neighbour::ready_window, and SEND_WINDOW_SIZE.

Here is the call graph for this function:

◆ handle_disconnect()

static void handle_disconnect	(	void *	cls,
		const struct DisconnectInfoMessage *	dim
	)

static

Function we use for handling incoming disconnect messages.

Parameters

cls	closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
dim	message received

Definition at line 476 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
  struct Neighbour *n;
 
  GNUNET_break (ntohl (dim->reserved) == 0);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Receiving DISCONNECT message for `%s'.\n",
       GNUNET_i2s (&dim->peer));
  n = neighbour_find (h, &dim->peer);
  if (NULL == n)
  {
    GNUNET_break (0);
    disconnect_and_schedule_reconnect (h);
    return;
  }
  GNUNET_assert (GNUNET_YES == neighbour_delete (h, &dim->peer, n));
}

References GNUNET_TRANSPORT_CoreHandle::cls, dim, disconnect_and_schedule_reconnect(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, h, LOG, neighbour_delete(), and neighbour_find().

Here is the call graph for this function:

◆ handle_send_ok()

static void handle_send_ok	(	void *	cls,
		const struct SendOkMessage *	okm
	)

static

Function we use for handling incoming send-ok messages.

Parameters

cls	closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
okm	message received

Definition at line 503 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
  struct Neighbour *n;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Receiving SEND_OK message for transmission to %s\n",
       GNUNET_i2s (&okm->peer));
 
  n = neighbour_find (h, &okm->peer);
 
  if (NULL == n)
  {
    /* We should never get a 'SEND_OK' for a peer that we are not
       connected to */
    GNUNET_break (0);
    disconnect_and_schedule_reconnect (h);
    return;
  }
 
  if ((GNUNET_NO == n->awaiting_done) &&
      (NULL != n->env) &&
      (0 == n->ready_window))
  {
    n->ready_window++;
    do_send (n);
    return;
  }
  else if ((GNUNET_NO == n->awaiting_done) &&
           (0 == n->ready_window))
  {
    n->ready_window++;
    GNUNET_MQ_impl_send_continue (n->mq);
    return;
  }
  n->ready_window++;
}

References Neighbour::awaiting_done, GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), do_send(), Neighbour::env, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_impl_send_continue(), GNUNET_NO, h, LOG, Neighbour::mq, neighbour_find(), SendOkMessage::peer, and Neighbour::ready_window.

Here is the call graph for this function:

◆ check_recv()

static int check_recv	(	void *	cls,
		const struct InboundMessage *	im
	)

static

Function we use for checking incoming "inbound" messages.

Parameters

cls	closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
im	message received

Definition at line 549 of file transport_api_core.c.

{
  const struct GNUNET_MessageHeader *imm;
  uint16_t size;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "check_recv\n");
  size = ntohs (im->header.size) - sizeof(*im);
  if (size < sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  imm = (const struct GNUNET_MessageHeader *) &im[1];
  if (ntohs (imm->size) != size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, InboundMessage::header, GNUNET_MessageHeader::size, and size.

◆ handle_recv()

static void handle_recv	(	void *	cls,
		const struct InboundMessage *	im
	)

static

Function we use for handling incoming messages.

Parameters

cls	closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
im	message received

Definition at line 579 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
  const struct GNUNET_MessageHeader *imm =
    (const struct GNUNET_MessageHeader *) &im[1];
  struct Neighbour *n;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received message of type %u with %u bytes from `%s'.\n",
       (unsigned int) ntohs (imm->type),
       (unsigned int) ntohs (imm->size),
       GNUNET_i2s (&im->peer));
  n = neighbour_find (h, &im->peer);
  if (NULL == n)
  {
    GNUNET_break (0);
    disconnect_and_schedule_reconnect (h);
    return;
  }
  GNUNET_MQ_inject_message (n->mq, imm);
}

References GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_inject_message(), h, LOG, Neighbour::mq, neighbour_find(), InboundMessage::peer, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ reconnect()

static void reconnect ( void * cls )

static

Try again to connect to transport service.

Parameters

cls	the handle to the transport service

Definition at line 608 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_fixed_size (connect,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT,
                             struct ConnectInfoMessage,
                             h),
    GNUNET_MQ_hd_fixed_size (disconnect,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT,
                             struct DisconnectInfoMessage,
                             h),
    GNUNET_MQ_hd_fixed_size (send_ok,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK,
                             struct SendOkMessage,
                             h),
    GNUNET_MQ_hd_var_size (recv,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_RECV,
                           struct InboundMessage,
                           h),
    GNUNET_MQ_handler_end () };
  struct GNUNET_MQ_Envelope *env;
  struct StartMessage *s;
  uint32_t options;
 
  h->reconnect_task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
  GNUNET_assert (NULL == h->mq);
  h->mq =
    GNUNET_CLIENT_connect (h->cfg, "transport", handlers, &mq_error_handler, h);
  h->restarted_at = GNUNET_TIME_absolute_get ();
  if (NULL == h->mq)
    return;
  env = GNUNET_MQ_msg (s, GNUNET_MESSAGE_TYPE_TRANSPORT_START);
  options = 0;
  if (h->check_self)
    options |= 1;
  if (NULL != h->handlers)
    options |= 2;
  s->options = htonl (options);
  s->self = h->self;
  GNUNET_MQ_send (h->mq, env);
}

References GNUNET_ARM_Handle::cfg, GNUNET_TRANSPORT_CoreHandle::cls, disconnect(), env, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT, GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK, GNUNET_MESSAGE_TYPE_TRANSPORT_START, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_TIME_absolute_get(), h, handlers, LOG, GNUNET_ARM_Handle::mq, mq_error_handler(), options, StartMessage::options, GNUNET_ARM_Handle::reconnect_task, and StartMessage::self.

Referenced by disconnect_and_schedule_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disconnect()

static void disconnect ( struct GNUNET_TRANSPORT_CoreHandle * h )

static

Disconnect from the transport service.

Parameters

h	transport service to reconnect

Definition at line 659 of file transport_api_core.c.

{
  GNUNET_CONTAINER_multipeermap_iterate (h->neighbours, &neighbour_delete, h);
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
}

References GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_MQ_destroy(), h, GNUNET_ARM_Handle::mq, and neighbour_delete().

Referenced by disconnect_and_schedule_reconnect(), and reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TRANSPORT_core_get_mq()

struct GNUNET_MQ_Handle * GNUNET_TRANSPORT_core_get_mq	(	struct GNUNET_TRANSPORT_CoreHandle *	handle,
		const struct GNUNET_PeerIdentity *	peer
	)

Checks if a given peer is connected to us and get the message queue.

Parameters

handle	connection to transport service
peer	the peer to check

Returns: NULL if disconnected, otherwise message queue for peer

Definition at line 712 of file transport_api_core.c.

{
  struct Neighbour *n;
 
  n = neighbour_find (handle, peer);
  if (NULL == n)
    return NULL;
  return n->mq;
}

References handle, Neighbour::mq, and neighbour_find().

Here is the call graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

◆ STARTING_NEIGHBOURS_SIZE

◆ SEND_WINDOW_SIZE

Function Documentation

◆ disconnect_and_schedule_reconnect()

◆ neighbour_find()

◆ neighbour_delete()

◆ mq_error_handler()

◆ notify_send_done()

◆ do_send()

◆ mq_send_impl()

◆ mq_destroy_impl()

◆ mq_cancel_impl()

◆ peer_mq_error_handler()

◆ handle_connect()

◆ handle_disconnect()

◆ handle_send_ok()

◆ check_recv()

◆ handle_recv()

◆ reconnect()

◆ disconnect()

◆ GNUNET_TRANSPORT_core_get_mq()