transport_api2_core.c File Reference

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

Include dependency graph for transport_api2_core.c:

Go to the source code of this file.

Data Structures
struct	Neighbour
	A connected controller which is not our child. 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...

Macro Definition Documentation

LOG

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

Definition at line 35 of file transport_api2_core.c.

STARTING_NEIGHBOURS_SIZE

#define STARTING_NEIGHBOURS_SIZE   16

How large to start with for the hashmap of neighbours.

Definition at line 40 of file transport_api2_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 thoughput, 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 50 of file transport_api2_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 666 of file transport_api2_core.c.

{
  GNUNET_assert (NULL == h->reconnect_task);
  disconnect (h);
  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_STD_BACKOFF, GNUNET_YES, h, LOG, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

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 189 of file transport_api2_core.c.

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

References GNUNET_CONTAINER_multipeermap_get(), h, and peer.

Referenced by 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 207 of file transport_api2_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 242 of file transport_api2_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 264 of file transport_api2_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 282 of file transport_api2_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 309 of file transport_api2_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;
 
    env = GNUNET_MQ_get_current_envelope (mq);
    obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
  }
  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 358 of file transport_api2_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 375 of file transport_api2_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 403 of file transport_api2_core.c.

{
  /* struct Neighbour *n = cls; */
 
  GNUNET_break_op (0);
}

References GNUNET_break_op.

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 418 of file transport_api2_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 466 of file transport_api2_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 493 of file transport_api2_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 539 of file transport_api2_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 569 of file transport_api2_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 598 of file transport_api2_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);
  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(), 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 648 of file transport_api2_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: