transport_api_core.c File Reference

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_hello_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_transport_service.h"
#include "transport.h"

Include dependency graph for transport_api_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	UNREADY_WARN_TIME   GNUNET_TIME_UNIT_MINUTES
	If we could not send any payload to a peer for this amount of time, we print a warning. More...
#define	STARTING_NEIGHBOURS_SIZE   16
	How large to start with for the hashmap of neighbours. 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 void	notify_excess_cb (void *cls)
	Function called by the bandwidth tracker if we have excess bandwidth. 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 int	check_hello (void *cls, const struct GNUNET_MessageHeader *msg)
	Function we use for checking incoming HELLO messages. More...
static void	handle_hello (void *cls, const struct GNUNET_MessageHeader *msg)
	Function we use for handling incoming HELLO messages. More...
static void	notify_send_done_fin (void *cls)
	A message from the handler's message queue to a neighbour was transmitted. More...
static void	notify_send_done (void *cls)
	A message from the handler's message queue to a neighbour was transmitted. 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	outbound_bw_tracker_update (void *cls)
	The outbound quota has changed in a way that may require us to reset the timeout. 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	handle_set_quota (void *cls, const struct QuotaSetMessage *qm)
	Function we use for handling incoming set quota messages. More...
static void	reconnect (void *cls)
	Try again to connect to 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...
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, GNUNET_TRANSPORT_NotifyExcessBandwidth neb)
	Connect to the transport service. More...
void	GNUNET_TRANSPORT_core_disconnect (struct GNUNET_TRANSPORT_CoreHandle *handle)
	Disconnect from the transport service. 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 35 of file transport_api_core.c.

UNREADY_WARN_TIME

#define UNREADY_WARN_TIME   GNUNET_TIME_UNIT_MINUTES

If we could not send any payload to a peer for this amount of time, we print a warning.

Definition at line 41 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 46 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 805 of file transport_api_core.c.

{
  GNUNET_assert (NULL == h->reconnect_task);
  /* Forget about all neighbours that we used to be connected to */
  GNUNET_CONTAINER_multipeermap_iterate (h->neighbours, &neighbour_delete, h);
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  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 GNUNET_assert, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, h, LOG, GNUNET_ARM_Handle::mq, neighbour_delete(), reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by GNUNET_TRANSPORT_core_disconnect(), handle_connect(), handle_disconnect(), handle_recv(), handle_send_ok(), handle_set_quota(), 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 216 of file transport_api_core.c.

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

References GNUNET_CONTAINER_multipeermap_get(), h, and peer.

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

Here is the call graph for this function:

Here is the caller graph for this function:

notify_excess_cb()

static void notify_excess_cb ( void *  cls )

static

Function called by the bandwidth tracker if we have excess bandwidth.

Parameters

cls	the struct Neighbour that has excess bandwidth

Definition at line 230 of file transport_api_core.c.

{
  struct Neighbour *n = cls;
  struct GNUNET_TRANSPORT_CoreHandle *h = n->h;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Notifying CORE that more bandwidth is available for %s\n",
       GNUNET_i2s (&n->id));
 
  if (NULL != h->neb_cb)
    h->neb_cb (h->cls, &n->id, n->handlers_cls);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), h, Neighbour::h, Neighbour::handlers_cls, Neighbour::id, and LOG.

Referenced by handle_connect().

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 255 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));
  GNUNET_BANDWIDTH_tracker_notification_stop (&n->out_tracker);
  if (NULL != handle->nd_cb)
    handle->nd_cb (handle->cls, &n->id, n->handlers_cls);
  if (NULL != n->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (n->timeout_task);
    n->timeout_task = NULL;
  }
  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_BANDWIDTH_tracker_notification_stop(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_MQ_destroy(), GNUNET_MQ_send_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, handle, Neighbour::handlers_cls, Neighbour::id, key, LOG, Neighbour::mq, Neighbour::out_tracker, Neighbour::timeout_task, and value.

Referenced by disconnect_and_schedule_reconnect(), 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 296 of file transport_api_core.c.

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

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

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

check_hello()

static int check_hello ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Function we use for checking incoming HELLO messages.

Parameters

cls	closure, a struct GNUNET_TRANSPORT_CoreHandle *
msg	message received

Returns

GNUNET_OK if message is well-formed

Definition at line 315 of file transport_api_core.c.

{
  struct GNUNET_PeerIdentity me;
 
  if (GNUNET_OK !=
      GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) msg, &me))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_HELLO_get_id(), GNUNET_OK, GNUNET_SYSERR, me, and msg.

Here is the call graph for this function:

handle_hello()

static void handle_hello ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Function we use for handling incoming HELLO messages.

Parameters

cls	closure, a struct GNUNET_TRANSPORT_CoreHandle *
msg	message received

Definition at line 336 of file transport_api_core.c.

{
  /* we do not care => FIXME: signal in options to NEVER send HELLOs! */
}

notify_send_done_fin()

static void notify_send_done_fin ( 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.

Parameters

cls	the struct Neighbour where the message was sent

Definition at line 351 of file transport_api_core.c.

{
  struct Neighbour *n = cls;
 
  n->timeout_task = NULL;
  n->is_ready = GNUNET_YES;
  GNUNET_MQ_impl_send_continue (n->mq);
}

References GNUNET_MQ_impl_send_continue(), GNUNET_YES, Neighbour::is_ready, Neighbour::mq, and Neighbour::timeout_task.

Referenced by notify_send_done().

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.

Parameters

cls	the struct Neighbour where the message was sent

Definition at line 370 of file transport_api_core.c.

{
  struct Neighbour *n = cls;
  struct GNUNET_TIME_Relative delay;
 
  n->timeout_task = NULL;
  if (NULL != n->env)
  {
    GNUNET_BANDWIDTH_tracker_consume (&n->out_tracker,
                                      n->env_size + n->traffic_overhead);
    n->env = NULL;
    n->traffic_overhead = 0;
  }
  delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, 128);
  if (0 == delay.rel_value_us)
  {
    n->is_ready = GNUNET_YES;
    GNUNET_MQ_impl_send_continue (n->mq);
    return;
  }
  GNUNET_MQ_impl_send_in_flight (n->mq);
  /* cannot send even a small message without violating
     quota, wait a before allowing MQ to send next message */
  n->timeout_task =
    GNUNET_SCHEDULER_add_delayed (delay, &notify_send_done_fin, n);
}

References delay, Neighbour::env, Neighbour::env_size, GNUNET_BANDWIDTH_tracker_consume(), GNUNET_BANDWIDTH_tracker_get_delay(), GNUNET_MQ_impl_send_continue(), GNUNET_MQ_impl_send_in_flight(), GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, Neighbour::is_ready, Neighbour::mq, notify_send_done_fin(), Neighbour::out_tracker, GNUNET_TIME_Relative::rel_value_us, Neighbour::timeout_task, and Neighbour::traffic_overhead.

Referenced by mq_send_impl(), and outbound_bw_tracker_update().

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 409 of file transport_api_core.c.

{
  struct Neighbour *n = impl_state;
  struct GNUNET_TRANSPORT_CoreHandle *h = n->h;
  struct OutboundMessage *obm;
  uint16_t msize;
 
  GNUNET_assert (GNUNET_YES == n->is_ready);
  msize = ntohs (msg->size);
  if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*obm))
  {
    GNUNET_break (0);
    GNUNET_MQ_impl_send_continue (mq);
    return;
  }
  GNUNET_assert (NULL == n->env);
  n->env =
    GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg);
  {
    struct GNUNET_MQ_Envelope *env;
 
    env = GNUNET_MQ_get_current_envelope (mq);
    obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
  }
  obm->timeout = GNUNET_TIME_relative_hton (
    GNUNET_TIME_UNIT_MINUTES); /* FIXME: to be removed */
  obm->peer = n->id;
  GNUNET_assert (NULL == n->timeout_task);
  n->is_ready = GNUNET_NO;
  n->env_size = ntohs (msg->size);
  GNUNET_MQ_notify_sent (n->env, &notify_send_done, n);
  GNUNET_MQ_send (h->mq, n->env);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Queued message of type %u for neighbour `%s'.\n",
       ntohs (msg->type),
       GNUNET_i2s (&n->id));
}

References 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, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_TIME_relative_hton(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, h, Neighbour::h, Neighbour::id, Neighbour::is_ready, LOG, mq, GNUNET_ARM_Handle::mq, msg, notify_send_done(), OutboundMessage::peer, OutboundMessage::priority, GNUNET_MessageHeader::size, OutboundMessage::timeout, Neighbour::timeout_task, 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 458 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 475 of file transport_api_core.c.

{
  struct Neighbour *n = impl_state;
 
  GNUNET_assert (GNUNET_NO == n->is_ready);
  if (NULL != n->env)
  {
    GNUNET_MQ_send_cancel (n->env);
    n->env = NULL;
  }
 
  n->is_ready = GNUNET_YES;
}

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

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 499 of file transport_api_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:

outbound_bw_tracker_update()

static void outbound_bw_tracker_update ( void *  cls )

static

The outbound quota has changed in a way that may require us to reset the timeout.

Update the timeout.

Parameters

cls	the struct Neighbour for which the timeout changed

Definition at line 514 of file transport_api_core.c.

{
  struct Neighbour *n = cls;
  struct GNUNET_TIME_Relative delay;
 
  if (NULL == n->timeout_task)
    return;
  delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, 128);
  GNUNET_SCHEDULER_cancel (n->timeout_task);
  n->timeout_task = GNUNET_SCHEDULER_add_delayed (delay, &notify_send_done, n);
}

References delay, GNUNET_BANDWIDTH_tracker_get_delay(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), notify_send_done(), Neighbour::out_tracker, and Neighbour::timeout_task.

Referenced by handle_connect().

Here is the call graph for this function:

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 534 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' with quota %u\n",
       GNUNET_i2s (&cim->id),
       ntohl (cim->quota_out.value__));
  n = neighbour_find (h, &cim->id);
  if (NULL != n)
  {
    GNUNET_break (0);  /* FIXME: this assertion seems to fail sometimes!? */
    disconnect_and_schedule_reconnect (h);
    return;
  }
  n = GNUNET_new (struct Neighbour);
  n->id = cim->id;
  n->h = h;
  n->is_ready = GNUNET_YES;
  n->traffic_overhead = 0;
  GNUNET_BANDWIDTH_tracker_init2 (&n->out_tracker,
                                  &outbound_bw_tracker_update,
                                  n,
                                  GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
                                  MAX_BANDWIDTH_CARRY_S,
                                  &notify_excess_cb,
                                  n);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_put (
                   h->neighbours,
                   &n->id,
                   n,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
  GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker, cim->quota_out);
  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_BANDWIDTH_tracker_init2(), GNUNET_BANDWIDTH_tracker_update_quota(), GNUNET_break, GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT, 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, GNUNET_YES, h, Neighbour::h, Neighbour::handlers_cls, ConnectInfoMessage::id, Neighbour::id, Neighbour::is_ready, LOG, MAX_BANDWIDTH_CARRY_S, Neighbour::mq, mq_cancel_impl(), mq_destroy_impl(), mq_send_impl(), neighbour_find(), notify_excess_cb(), Neighbour::out_tracker, outbound_bw_tracker_update(), peer_mq_error_handler(), ConnectInfoMessage::quota_out, Neighbour::traffic_overhead, and GNUNET_BANDWIDTH_Value32NBO::value__.

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 592 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 619 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
  struct Neighbour *n;
  uint32_t bytes_msg;
  uint32_t bytes_physical;
  uint16_t success =  ntohs (okm->success);
 
  bytes_msg = ntohs (okm->bytes_msg);
  bytes_physical = ntohl (okm->bytes_physical);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Receiving SEND_OK message, transmission to %s %s.\n",
       GNUNET_i2s (&okm->peer),
       success == GNUNET_OK ? "succeeded" : "failed");
  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 (bytes_physical > bytes_msg)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Overhead for %u byte message was %u\n",
         bytes_msg,
         bytes_physical - bytes_msg);
    n->traffic_overhead += bytes_physical - bytes_msg;
  }
}

References SendOkMessage::bytes_msg, SendOkMessage::bytes_physical, GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_OK, h, LOG, neighbour_find(), SendOkMessage::peer, SendOkMessage::success, and Neighbour::traffic_overhead.

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 660 of file transport_api_core.c.

{
  const struct GNUNET_MessageHeader *imm;
  uint16_t size;
 
  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_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 688 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;
  }
  h->rom_pending++;
  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:

handle_set_quota()

static void handle_set_quota ( void *  cls, const struct QuotaSetMessage *  qm  )

static

Function we use for handling incoming set quota messages.

Parameters

cls	closure, a struct GNUNET_TRANSPORT_CoreHandle *
qm	message received

Definition at line 719 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
  struct Neighbour *n;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Receiving SET_QUOTA message for `%s' with quota %u\n",
       GNUNET_i2s (&qm->peer),
       ntohl (qm->quota.value__));
  n = neighbour_find (h, &qm->peer);
  if (NULL == n)
  {
    GNUNET_break (
      0);   /* FIXME: julius reports this assertion fails sometimes? */
    disconnect_and_schedule_reconnect (h);
    return;
  }
  GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker, qm->quota);
}

References GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), GNUNET_BANDWIDTH_tracker_update_quota(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), h, LOG, neighbour_find(), Neighbour::out_tracker, QuotaSetMessage::peer, QuotaSetMessage::quota, and GNUNET_BANDWIDTH_Value32NBO::value__.

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 746 of file transport_api_core.c.

{
  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_var_size (hello,
                           GNUNET_MESSAGE_TYPE_HELLO,
                           struct GNUNET_MessageHeader,
                           h),
    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_hd_fixed_size (set_quota,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA,
                             struct QuotaSetMessage,
                             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_HELLO, 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_SET_QUOTA, 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(), and GNUNET_TRANSPORT_core_connect().

Here is the call graph for this function:

Here is the caller graph for this function: