gnunet-service-cadet_core.c File Reference

cadet service; interaction with CORE service More...

#include "platform.h"
#include "gnunet-service-cadet_core.h"
#include "gnunet-service-cadet_paths.h"
#include "gnunet-service-cadet_peer.h"
#include "gnunet-service-cadet_connection.h"
#include "gnunet-service-cadet_tunnels.h"
#include "gnunet_core_service.h"
#include "gnunet_statistics_service.h"
#include "cadet_protocol.h"

Include dependency graph for gnunet-service-cadet_core.c:

Go to the source code of this file.

Data Structures
struct	Rung
	Set of CadetRoutes that have exactly the same number of messages in their buffer. More...
struct	RouteDirection
	Information we keep per direction for a route. More...
struct	CadetRoute

Macros
#define	LOG(level, ...)   GNUNET_log_from (level, "cadet-cor", __VA_ARGS__)

Functions
static struct CadetRoute *	get_route (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
	Get the route corresponding to a hash. More...
static void	lower_rung (struct RouteDirection *dir)
	Lower the rung in which dir is by 1. More...
static void	discard_buffer (struct RouteDirection *dir, struct GNUNET_MQ_Envelope *env)
	Discard the buffer env from the route direction dir and move dir down a rung. More...
static void	discard_all_from_rung_tail ()
	Discard all messages from the highest rung, to make space. More...
static void	route_message (struct CadetPeer *prev, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, const struct GNUNET_MessageHeader *msg, const enum GNUNET_MQ_PriorityPreferences priority)
	We message msg from prev. More...
static int	check_connection_create (void *cls, const struct GNUNET_CADET_ConnectionCreateMessage *msg)
	Check if the create_connection message has the appropriate size. More...
static void	destroy_direction (struct RouteDirection *dir)
	Free internal data of a route direction. More...
static void	destroy_route (struct CadetRoute *route)
	Destroy our state for route. More...
static void	send_broken (struct RouteDirection *target, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, const struct GNUNET_PeerIdentity *peer1, const struct GNUNET_PeerIdentity *peer2)
	Send message that a route is broken between peer1 and peer2. More...
static void	timeout_cb (void *cls)
	Function called to check if any routes have timed out, and if so, to clean them up. More...
static void	dir_ready_cb (void *cls, int ready)
	Function called when the message queue to the previous hop becomes available/unavailable. More...
static void	dir_init (struct RouteDirection *dir, struct CadetRoute *route, struct CadetPeer *hop)
	Initialize one of the directions of a route. More...
static void	send_broken_without_mqm (struct CadetPeer *target, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, const struct GNUNET_PeerIdentity *failure_at)
	We could not create the desired route. More...
static void	handle_connection_create (void *cls, const struct GNUNET_CADET_ConnectionCreateMessage *msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE. More...
static void	handle_connection_create_ack (void *cls, const struct GNUNET_CADET_ConnectionCreateAckMessage *msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK. More...
static void	handle_connection_broken (void *cls, const struct GNUNET_CADET_ConnectionBrokenMessage *msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN. More...
static void	handle_connection_destroy (void *cls, const struct GNUNET_CADET_ConnectionDestroyMessage *msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY. More...
static void	handle_tunnel_kx (void *cls, const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX. More...
static void	handle_tunnel_kx_auth (void *cls, const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH. More...
static int	check_tunnel_encrypted (void *cls, const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
	Check if the encrypted message has the appropriate size. More...
static void	handle_tunnel_encrypted (void *cls, const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED. More...
static void	core_init_cb (void *cls, const struct GNUNET_PeerIdentity *my_identity)
	Function called after GNUNET_CORE_connect has succeeded (or failed for good). More...
static void *	core_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Method called whenever a given peer connects. More...
static void	core_disconnect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
	Method called whenever a peer disconnects. More...
void	GCO_init (const struct GNUNET_CONFIGURATION_Handle *c)
	Initialize the CORE subsystem. More...
void	GCO_shutdown ()
	Shut down the CORE subsystem. More...

Variables
static struct GNUNET_CORE_Handle *	core
	Handle to the CORE service. More...
static struct GNUNET_CONTAINER_MultiShortmap *	routes
	Routes on which this peer is an intermediate. More...
static struct GNUNET_CONTAINER_Heap *	route_heap
	Heap of routes, MIN-sorted by last activity. More...
static struct Rung	rung_zero
	Rung zero (always pointed to by rung_head). More...
static struct Rung *	rung_head = &rung_zero
	DLL of rungs, with the head always point to a rung of route directions with no messages in the queue. More...
static struct Rung *	rung_tail = &rung_zero
	Tail of the rung_head DLL. More...
static unsigned long long	max_routes
	Maximum number of concurrent routes this peer will support. More...
static unsigned long long	max_buffers
	Maximum number of envelopes we will buffer at this peer. More...
static unsigned long long	cur_buffers
	Current number of envelopes we have buffered at this peer. More...
static struct GNUNET_SCHEDULER_Task *	timeout_task
	Task to timeout routes. More...

Detailed Description

cadet service; interaction with CORE service

Author

Bartlomiej Polot

Christian Grothoff

All functions in this file should use the prefix GCO (Gnunet Cadet cOre (bottom))

TODO:

• Optimization: given BROKEN messages, destroy paths (?)

Definition in file gnunet-service-cadet_core.c.

Macro Definition Documentation

LOG

#define LOG	(		level,
			...
	)		GNUNET_log_from (level, "cadet-cor", __VA_ARGS__)

Definition at line 42 of file gnunet-service-cadet_core.c.

Function Documentation

get_route()

static struct CadetRoute * get_route ( const struct GNUNET_CADET_ConnectionTunnelIdentifier *  cid )

static

Get the route corresponding to a hash.

Parameters

cid	hash generated from the connection identifier

Definition at line 228 of file gnunet-service-cadet_core.c.

{
  return GNUNET_CONTAINER_multishortmap_get (routes,
                                             &cid->connection_of_tunnel);
}

References CadetRoute::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, GNUNET_CONTAINER_multishortmap_get(), and routes.

Referenced by handle_connection_broken(), handle_connection_create(), handle_connection_destroy(), and route_message().

Here is the call graph for this function:

Here is the caller graph for this function:

lower_rung()

static void lower_rung ( struct RouteDirection *  dir )

static

Lower the rung in which dir is by 1.

Parameters

dir	direction to lower in rung.

Definition at line 241 of file gnunet-service-cadet_core.c.

{
  struct Rung *rung = dir->rung;
  struct Rung *prev;
 
  GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir);
  prev = rung->prev;
  GNUNET_assert (NULL != prev);
  if (prev->rung_off != rung->rung_off - 1)
  {
    prev = GNUNET_new (struct Rung);
    prev->rung_off = rung->rung_off - 1;
    GNUNET_CONTAINER_DLL_insert_after (rung_head, rung_tail, rung->prev, prev);
  }
  GNUNET_assert (NULL != prev);
  GNUNET_CONTAINER_DLL_insert (prev->rd_head, prev->rd_tail, dir);
  dir->rung = prev;
}

References dir, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_insert_after, GNUNET_CONTAINER_DLL_remove, GNUNET_new, Rung::prev, Rung::rd_head, Rung::rd_tail, rung_head, Rung::rung_off, and rung_tail.

Referenced by dir_ready_cb(), and discard_buffer().

Here is the caller graph for this function:

discard_buffer()

static void discard_buffer ( struct RouteDirection *  dir, struct GNUNET_MQ_Envelope *  env  )

static

Discard the buffer env from the route direction dir and move dir down a rung.

Parameters

dir	direction that contains the env in the buffer
env	envelope to discard

Definition at line 269 of file gnunet-service-cadet_core.c.

{
  GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env);
  cur_buffers--;
  GNUNET_MQ_discard (env);
  lower_rung (dir);
  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
}

References cur_buffers, dir, env, GNUNET_MQ_discard(), GNUNET_MQ_dll_remove(), GNUNET_NO, GNUNET_STATISTICS_set(), lower_rung(), and stats.

Referenced by destroy_direction(), discard_all_from_rung_tail(), and route_message().

Here is the call graph for this function:

Here is the caller graph for this function:

discard_all_from_rung_tail()

static void discard_all_from_rung_tail ( )

static

Discard all messages from the highest rung, to make space.

Definition at line 283 of file gnunet-service-cadet_core.c.

{
  struct Rung *tail = rung_tail;
  struct RouteDirection *dir;
 
  while (NULL != (dir = tail->rd_head))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Queue full due new message on connection %s, dropping old message\n",
         GNUNET_sh2s (&dir->my_route->cid.connection_of_tunnel));
    GNUNET_STATISTICS_update (stats,
                              "# messages dropped due to full buffer",
                              1,
                              GNUNET_NO);
    discard_buffer (dir, dir->env_head);
  }
  GNUNET_CONTAINER_DLL_remove (rung_head, rung_tail, tail);
  GNUNET_free (tail);
}

References dir, discard_buffer(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_sh2s(), GNUNET_STATISTICS_update(), LOG, Rung::rd_head, rung_head, rung_tail, and stats.

Referenced by route_message().

Here is the call graph for this function:

Here is the caller graph for this function:

route_message()

static void route_message ( struct CadetPeer *  prev, const struct GNUNET_CADET_ConnectionTunnelIdentifier *  cid, const struct GNUNET_MessageHeader *  msg, const enum GNUNET_MQ_PriorityPreferences  priority  )

static

We message msg from prev.

Find its route by cid and forward to the next hop. Drop and signal broken route if we do not have a route.

Parameters

prev	previous hop (sender)
cid	connection identifier, tells us which route to use
msg	the message to forward

Definition at line 314 of file gnunet-service-cadet_core.c.

{
  struct CadetRoute *route;
  struct RouteDirection *dir;
  struct Rung *rung;
  struct Rung *nxt;
  struct GNUNET_MQ_Envelope *env;
 
  route = get_route (cid);
  if (NULL == route)
  {
    struct GNUNET_CADET_ConnectionBrokenMessage *bm;
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Failed to route message of type %u from %s on connection %s: no route\n",
         ntohs (msg->type),
         GCP_2s (prev),
         GNUNET_sh2s (&cid->connection_of_tunnel));
    switch (ntohs (msg->type))
    {
    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
      /* No need to respond to these! */
      return;
    }
    env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
    bm->cid = *cid;
    bm->peer1 = my_full_id;
    GCP_send_ooo (prev, env);
    return;
  }
  route->last_use = GNUNET_TIME_absolute_get ();
  GNUNET_CONTAINER_heap_update_cost (route->hn, route->last_use.abs_value_us);
  dir = (prev == route->prev.hop) ? &route->next : &route->prev;
  if (GNUNET_YES == dir->is_ready)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Routing message of type %u from %s to %s on connection %s\n",
         ntohs (msg->type),
         GCP_2s (prev),
         GNUNET_i2s (GCP_get_id (dir->hop)),
         GNUNET_sh2s (&cid->connection_of_tunnel));
    dir->is_ready = GNUNET_NO;
    GCP_send (dir->mqm, GNUNET_MQ_msg_copy (msg));
    return;
  }
  /* Check if low latency is required and if the previous message was
     unreliable; if so, make sure we only queue one message per
     direction (no buffering). */
  if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) &&
      (NULL != dir->env_head) &&
      (0 ==
       (GNUNET_MQ_env_get_options (dir->env_head) & GNUNET_MQ_PREF_UNRELIABLE)))
    discard_buffer (dir, dir->env_head);
  /* Check for duplicates */
  for (const struct GNUNET_MQ_Envelope *env_tmp = dir->env_head;
       NULL != env_tmp;
       env_tmp = GNUNET_MQ_env_next (env_tmp))
  {
    const struct GNUNET_MessageHeader *hdr = GNUNET_MQ_env_get_msg (env_tmp);
 
    if ((hdr->size == msg->size) && (0 == memcmp (hdr, msg, ntohs (msg->size))))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Received duplicate of message already in buffer, dropping\n");
      GNUNET_STATISTICS_update (stats,
                                "# messages dropped due to duplicate in buffer",
                                1,
                                GNUNET_NO);
      return;
    }
  }
 
  rung = dir->rung;
  if (cur_buffers == max_buffers)
  {
    /* Need to make room. */
    if (NULL != rung->next)
    {
      /* Easy case, drop messages from route directions in highest rung */
      discard_all_from_rung_tail ();
    }
    else
    {
      /* We are in the highest rung, drop our own! */
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Queue full due new message on connection %s, dropping old message\n",
           GNUNET_sh2s (&dir->my_route->cid.connection_of_tunnel));
      GNUNET_STATISTICS_update (stats,
                                "# messages dropped due to full buffer",
                                1,
                                GNUNET_NO);
      discard_buffer (dir, dir->env_head);
      rung = dir->rung;
    }
  }
  /* remove 'dir' from current rung */
  GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir);
  /* make 'nxt' point to the next higher rung, create if necessary */
  nxt = rung->next;
  if ((NULL == nxt) || (rung->rung_off + 1 != nxt->rung_off))
  {
    nxt = GNUNET_new (struct Rung);
    nxt->rung_off = rung->rung_off + 1;
    GNUNET_CONTAINER_DLL_insert_after (rung_head, rung_tail, rung, nxt);
  }
  /* insert 'dir' into next higher rung */
  GNUNET_CONTAINER_DLL_insert (nxt->rd_head, nxt->rd_tail, dir);
  dir->rung = nxt;
 
  /* add message into 'dir' buffer */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Queueing new message of type %u from %s to %s on connection %s\n",
       ntohs (msg->type),
       GCP_2s (prev),
       GNUNET_i2s (GCP_get_id (dir->hop)),
       GNUNET_sh2s (&cid->connection_of_tunnel));
  env = GNUNET_MQ_msg_copy (msg);
  GNUNET_MQ_env_set_options (env, priority);
  if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) &&
      (0 != (priority & GNUNET_MQ_PREF_OUT_OF_ORDER)) &&
      (NULL != dir->env_head) &&
      (0 == (GNUNET_MQ_env_get_options (dir->env_head)
             & GNUNET_MQ_PREF_LOW_LATENCY)))
    GNUNET_MQ_dll_insert_head (&dir->env_head, &dir->env_tail, env);
  else
    GNUNET_MQ_dll_insert_tail (&dir->env_head, &dir->env_tail, env);
  cur_buffers++;
  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
  /* Clean up 'rung' if now empty (and not head) */
  if ((NULL == rung->rd_head) && (rung != rung_head))
  {
    GNUNET_CONTAINER_DLL_remove (rung_head, rung_tail, rung);
    GNUNET_free (rung);
  }
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CADET_ConnectionBrokenMessage::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, cur_buffers, dir, discard_all_from_rung_tail(), discard_buffer(), env, GCP_2s(), GCP_get_id(), GCP_send(), GCP_send_ooo(), get_route(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_insert_after, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_update_cost(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY, GNUNET_MQ_dll_insert_head(), GNUNET_MQ_dll_insert_tail(), GNUNET_MQ_env_get_msg(), GNUNET_MQ_env_get_options(), GNUNET_MQ_env_next(), GNUNET_MQ_env_set_options(), GNUNET_MQ_msg, GNUNET_MQ_msg_copy(), GNUNET_MQ_PREF_LOW_LATENCY, GNUNET_MQ_PREF_OUT_OF_ORDER, GNUNET_MQ_PREF_UNRELIABLE, GNUNET_new, GNUNET_NO, GNUNET_sh2s(), GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_YES, CadetRoute::hn, RouteDirection::hop, CadetRoute::last_use, LOG, max_buffers, msg, my_full_id, Rung::next, CadetRoute::next, GNUNET_CADET_ConnectionBrokenMessage::peer1, CadetRoute::prev, Rung::rd_head, Rung::rd_tail, rung_head, Rung::rung_off, rung_tail, GNUNET_MessageHeader::size, stats, and GNUNET_MessageHeader::type.

Referenced by handle_connection_broken(), handle_connection_create(), handle_connection_create_ack(), handle_connection_destroy(), handle_tunnel_encrypted(), handle_tunnel_kx(), and handle_tunnel_kx_auth().

Here is the call graph for this function:

Here is the caller graph for this function:

check_connection_create()

static int check_connection_create ( void *  cls, const struct GNUNET_CADET_ConnectionCreateMessage *  msg  )

static

Check if the create_connection message has the appropriate size.

Parameters

cls	Closure (unused).
msg	Message to check.

Returns

GNUNET_YES if size is correct, GNUNET_NO otherwise.

Definition at line 464 of file gnunet-service-cadet_core.c.

{
  uint16_t size = ntohs (msg->header.size) - sizeof(*msg);
 
  if (0 != (size % sizeof(struct GNUNET_PeerIdentity)))
  {
    GNUNET_break_op (0);
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References GNUNET_break_op, GNUNET_NO, GNUNET_YES, msg, GNUNET_MessageHeader::size, and size.

destroy_direction()

static void destroy_direction ( struct RouteDirection *  dir )

static

Free internal data of a route direction.

Parameters

dir	direction to destroy (do NOT free memory of 'dir' itself)

Definition at line 484 of file gnunet-service-cadet_core.c.

{
  struct GNUNET_MQ_Envelope *env;
 
  while (NULL != (env = dir->env_head))
  {
    GNUNET_STATISTICS_update (stats,
                              "# messages dropped due to route destruction",
                              1,
                              GNUNET_NO);
    discard_buffer (dir, env);
  }
  if (NULL != dir->mqm)
  {
    GCP_request_mq_cancel (dir->mqm, NULL);
    dir->mqm = NULL;
  }
  GNUNET_CONTAINER_DLL_remove (rung_head->rd_head, rung_head->rd_tail, dir);
}

References dir, discard_buffer(), env, GCP_request_mq_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_NO, GNUNET_STATISTICS_update(), Rung::rd_head, Rung::rd_tail, rung_head, and stats.

Referenced by destroy_route().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_route()

static void destroy_route ( struct CadetRoute *  route )

static

Destroy our state for route.

Parameters

route

route to destroy

Definition at line 511 of file gnunet-service-cadet_core.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying route from %s to %s of connection %s\n",
       GNUNET_i2s (GCP_get_id (route->prev.hop)),
       GNUNET_i2s2 (GCP_get_id (route->next.hop)),
       GNUNET_sh2s (&route->cid.connection_of_tunnel));
  GNUNET_assert (route == GNUNET_CONTAINER_heap_remove_node (route->hn));
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multishortmap_remove (routes,
                                           &route->cid.connection_of_tunnel,
                                           route));
  GNUNET_STATISTICS_set (stats,
                         "# routes",
                         GNUNET_CONTAINER_multishortmap_size (routes),
                         GNUNET_NO);
  destroy_direction (&route->prev);
  destroy_direction (&route->next);
  GNUNET_free (route);
}

References CadetRoute::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, destroy_direction(), GCP_get_id(), GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multishortmap_remove(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_i2s2(), GNUNET_NO, GNUNET_sh2s(), GNUNET_STATISTICS_set(), GNUNET_YES, CadetRoute::hn, RouteDirection::hop, LOG, CadetRoute::next, CadetRoute::prev, routes, and stats.

Referenced by dir_ready_cb(), handle_connection_broken(), handle_connection_destroy(), and timeout_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

send_broken()

static void send_broken ( struct RouteDirection *  target, const struct GNUNET_CADET_ConnectionTunnelIdentifier *  cid, const struct GNUNET_PeerIdentity *  peer1, const struct GNUNET_PeerIdentity *  peer2  )

static

Send message that a route is broken between peer1 and peer2.

Parameters

target	where to send the message
cid	connection identifier to use
peer1	one of the peers where a link is broken
peer2	another one of the peers where a link is broken

Definition at line 543 of file gnunet-service-cadet_core.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_CADET_ConnectionBrokenMessage *bm;
 
  if (NULL == target->mqm)
    return; /* Can't send notification, connection is down! */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Notifying %s about BROKEN route at %s-%s of connection %s\n",
       GCP_2s (target->hop),
       GNUNET_i2s (peer1),
       GNUNET_i2s2 (peer2),
       GNUNET_sh2s (&cid->connection_of_tunnel));
 
  env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
  bm->cid = *cid;
  if (NULL != peer1)
    bm->peer1 = *peer1;
  if (NULL != peer2)
    bm->peer2 = *peer2;
  GCP_request_mq_cancel (target->mqm, env);
  target->mqm = NULL;
}

References GNUNET_CADET_ConnectionBrokenMessage::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, env, GCP_2s(), GCP_request_mq_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_i2s2(), GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, GNUNET_MQ_msg, GNUNET_sh2s(), RouteDirection::hop, LOG, RouteDirection::mqm, GNUNET_CADET_ConnectionBrokenMessage::peer1, and GNUNET_CADET_ConnectionBrokenMessage::peer2.

Referenced by dir_ready_cb(), and timeout_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

timeout_cb()

static void timeout_cb ( void *  cls )

static

Function called to check if any routes have timed out, and if so, to clean them up.

Finally, schedules itself again at the earliest time where there might be more work.

Parameters

cls

NULL

Definition at line 579 of file gnunet-service-cadet_core.c.

{
  struct CadetRoute *r;
  struct GNUNET_TIME_Relative linger;
  struct GNUNET_TIME_Absolute exp;
 
  timeout_task = NULL;
  linger = GNUNET_TIME_relative_multiply (keepalive_period, 3);
  while (NULL != (r = GNUNET_CONTAINER_heap_peek (route_heap)))
  {
    exp = GNUNET_TIME_absolute_add (r->last_use, linger);
    if (0 != GNUNET_TIME_absolute_get_remaining (exp).rel_value_us)
    {
      /* Route not yet timed out, wait until it does. */
      timeout_task = GNUNET_SCHEDULER_add_at (exp, &timeout_cb, NULL);
      return;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Sending BROKEN due to timeout (%s was last use, %s linger)\n",
                GNUNET_STRINGS_absolute_time_to_string (r->last_use),
                GNUNET_STRINGS_relative_time_to_string (linger, GNUNET_YES));
    send_broken (&r->prev, &r->cid, NULL, NULL);
    send_broken (&r->next, &r->cid, NULL, NULL);
    destroy_route (r);
  }
  /* No more routes left, so no need for a #timeout_task */
}

References CadetRoute::cid, destroy_route(), GNUNET_CONTAINER_heap_peek(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_at(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_multiply(), GNUNET_YES, keepalive_period, CadetRoute::last_use, CadetRoute::next, CadetRoute::prev, route_heap, send_broken(), timeout_cb(), and timeout_task.

Referenced by handle_connection_create(), and timeout_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

dir_ready_cb()

static void dir_ready_cb ( void *  cls, int  ready  )

static

Function called when the message queue to the previous hop becomes available/unavailable.

We expect this function to be called immediately when we register, and then again later if the connection ever goes down.

Parameters

cls	the struct RouteDirection
ready	GNUNET_YES if sending is now possible, GNUNET_NO if sending is no longer possible GNUNET_SYSERR if sending is no longer possible and the last envelope was discarded

Definition at line 621 of file gnunet-service-cadet_core.c.

{
  struct RouteDirection *dir = cls;
  struct CadetRoute *route = dir->my_route;
  struct RouteDirection *odir;
 
  if (GNUNET_YES == ready)
  {
    struct GNUNET_MQ_Envelope *env;
 
    dir->is_ready = GNUNET_YES;
    if (NULL != (env = dir->env_head))
    {
      GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env);
      cur_buffers--;
      GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
      lower_rung (dir);
      dir->is_ready = GNUNET_NO;
      GCP_send (dir->mqm, env);
    }
    return;
  }
  odir = (dir == &route->next) ? &route->prev : &route->next;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending BROKEN due to MQ going down\n");
  send_broken (&route->next, &route->cid, GCP_get_id (odir->hop), &my_full_id);
  destroy_route (route);
}

References CadetRoute::cid, cur_buffers, destroy_route(), dir, env, GCP_get_id(), GCP_send(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_dll_remove(), GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_YES, RouteDirection::hop, lower_rung(), my_full_id, CadetRoute::next, CadetRoute::prev, send_broken(), and stats.

Referenced by dir_init().

Here is the call graph for this function:

Here is the caller graph for this function:

dir_init()

static void dir_init ( struct RouteDirection *  dir, struct CadetRoute *  route, struct CadetPeer *  hop  )

static

Initialize one of the directions of a route.

Parameters

route	route the direction belongs to
dir	direction to initialize
hop	next hop on in the dir

Definition at line 658 of file gnunet-service-cadet_core.c.

{
  dir->hop = hop;
  dir->my_route = route;
  dir->mqm = GCP_request_mq (hop, &dir_ready_cb, dir);
  GNUNET_CONTAINER_DLL_insert (rung_head->rd_head, rung_head->rd_tail, dir);
  dir->rung = rung_head;
  GNUNET_assert (GNUNET_YES == dir->is_ready);
}

References dir, dir_ready_cb(), GCP_request_mq(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_YES, Rung::rd_head, Rung::rd_tail, and rung_head.

Referenced by handle_connection_create().

Here is the call graph for this function:

Here is the caller graph for this function:

send_broken_without_mqm()

static void send_broken_without_mqm ( struct CadetPeer *  target, const struct GNUNET_CADET_ConnectionTunnelIdentifier *  cid, const struct GNUNET_PeerIdentity *  failure_at  )

static

We could not create the desired route.

Send a GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN message to target.

Parameters

target	who should receive the message
cid	identifier of the connection/route that failed
failure_at	neighbour with which we failed to route, or NULL.

Definition at line 682 of file gnunet-service-cadet_core.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_CADET_ConnectionBrokenMessage *bm;
 
  env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
  bm->cid = *cid;
  bm->peer1 = my_full_id;
  if (NULL != failure_at)
    bm->peer2 = *failure_at;
  GCP_send_ooo (target, env);
}

References GNUNET_CADET_ConnectionBrokenMessage::cid, env, GCP_send_ooo(), GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, GNUNET_MQ_msg, my_full_id, GNUNET_CADET_ConnectionBrokenMessage::peer1, and GNUNET_CADET_ConnectionBrokenMessage::peer2.

Referenced by handle_connection_create().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_connection_create()

static void handle_connection_create ( void *  cls, const struct GNUNET_CADET_ConnectionCreateMessage *  msg  )

static

Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE.

Parameters

cls	Closure (CadetPeer for neighbor that sent the message).
msg	Message itself.

Definition at line 706 of file gnunet-service-cadet_core.c.

{
  struct CadetPeer *sender = cls;
  struct CadetPeer *next;
  const struct GNUNET_PeerIdentity *pids =
    (const struct GNUNET_PeerIdentity *) &msg[1];
  struct CadetRoute *route;
  uint16_t size = ntohs (msg->header.size) - sizeof(*msg);
  unsigned int path_length;
  unsigned int off;
  struct CadetTunnel *t;
 
  path_length = size / sizeof(struct GNUNET_PeerIdentity);
  if (0 == path_length)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Dropping CADET_CONNECTION_CREATE with empty path\n");
    GNUNET_break_op (0);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Handling CADET_CONNECTION_CREATE from %s for CID %s with %u hops\n",
       GCP_2s (sender),
       GNUNET_sh2s (&msg->cid.connection_of_tunnel),
       path_length);
  /* Check for loops */
  {
    struct GNUNET_CONTAINER_MultiPeerMap *map;
 
    map = GNUNET_CONTAINER_multipeermap_create (path_length * 2, GNUNET_YES);
    GNUNET_assert (NULL != map);
    for (unsigned int i = 0; i < path_length; i++)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "CADET_CONNECTION_CREATE has peer %s at offset %u\n",
           GNUNET_i2s (&pids[i]),
           i);
      if (GNUNET_SYSERR == GNUNET_CONTAINER_multipeermap_put (
            map,
            &pids[i],
            NULL,
            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
      {
        /* bogus request */
        GNUNET_CONTAINER_multipeermap_destroy (map);
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "Dropping CADET_CONNECTION_CREATE with cyclic path\n");
        GNUNET_break_op (0);
        return;
      }
    }
    GNUNET_CONTAINER_multipeermap_destroy (map);
  }
  /* Initiator is at offset 0, find us */
  for (off = 1; off < path_length; off++)
    if (0 == GNUNET_memcmp (&my_full_id, &pids[off]))
      break;
  if (off == path_length)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Dropping CADET_CONNECTION_CREATE without us in the path\n");
    GNUNET_break_op (0);
    return;
  }
  /* Check previous hop */
  if (sender != GCP_get (&pids[off - 1], GNUNET_NO))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Dropping CADET_CONNECTION_CREATE without sender at previous hop in the path\n");
    GNUNET_break_op (0);
    return;
  }
  if (NULL != (route = get_route (&msg->cid)))
  {
    /* Duplicate CREATE, pass it on, previous one might have been lost! */
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Passing on duplicate CADET_CONNECTION_CREATE message on connection %s\n",
         GNUNET_sh2s (&msg->cid.connection_of_tunnel));
    route_message (sender,
                   &msg->cid,
                   &msg->header,
                   GNUNET_MQ_PRIO_CRITICAL_CONTROL
                   | GNUNET_MQ_PREF_LOW_LATENCY);
    return;
  }
  if (off == path_length - 1)
  {
    /* We are the destination, create connection */
    struct CadetConnection *cc;
    struct CadetPeerPath *path;
    struct CadetPeer *origin;
 
    cc = GCC_lookup (&msg->cid);
    if (NULL != cc)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Received duplicate CADET_CONNECTION_CREATE message on connection %s\n",
           GNUNET_sh2s (&msg->cid.connection_of_tunnel));
      GCC_handle_duplicate_create (cc);
      return;
    }
 
    origin = GCP_get (&pids[0], GNUNET_YES);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "I am destination for CADET_CONNECTION_CREATE message from %s for connection %s, building inverse path\n",
         GCP_2s (origin),
         GNUNET_sh2s (&msg->cid.connection_of_tunnel));
    path = GCPP_get_path_from_route (path_length - 1, pids);
    t = GCP_get_tunnel (origin, GNUNET_YES);
 
    // Check for CADET state in case the other side has lost the tunnel (xrs,t3ss)
    if ((GNUNET_YES == msg->has_monotime) &&
        (GNUNET_YES == GCP_check_and_update_monotime (origin, msg->monotime)) &&
        (GNUNET_OK == GCP_check_monotime_sig (origin, msg)) &&
        (CADET_TUNNEL_KEY_OK == GCT_get_estate (t)))
    {
      GCT_change_estate (t, CADET_TUNNEL_KEY_UNINITIALIZED);
    }
 
    if (GNUNET_OK !=
        GCT_add_inbound_connection (t,
                                    &msg->cid,
                                    path))
    {
      /* Send back BROKEN: duplicate connection on the same path,
         we will use the other one. */
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Received CADET_CONNECTION_CREATE from %s for %s, but %s already has a connection. Sending BROKEN\n",
           GCP_2s (sender),
           GNUNET_sh2s (&msg->cid.connection_of_tunnel),
           GCPP_2s (path));
      send_broken_without_mqm (sender, &msg->cid, NULL);
      return;
    }
    return;
  }
  /* We are merely a hop on the way, check if we can support the route */
  next = GCP_get (&pids[off + 1], GNUNET_NO);
  if ((NULL == next) || (GNUNET_NO == GCP_has_core_connection (next)))
  {
    /* unworkable, send back BROKEN notification */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is down. Sending BROKEN\n",
         GCP_2s (sender),
         GNUNET_sh2s (&msg->cid.connection_of_tunnel),
         GNUNET_i2s (&pids[off + 1]),
         off + 1);
    send_broken_without_mqm (sender, &msg->cid, &pids[off + 1]);
    return;
  }
  if (max_routes <= GNUNET_CONTAINER_multishortmap_size (routes))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received CADET_CONNECTION_CREATE from %s for %s. We have reached our route limit. Sending BROKEN\n",
         GCP_2s (sender),
         GNUNET_sh2s (&msg->cid.connection_of_tunnel));
    send_broken_without_mqm (sender, &msg->cid, &pids[off - 1]);
    return;
  }
 
  /* Workable route, create routing entry */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is up. Creating route\n",
       GCP_2s (sender),
       GNUNET_sh2s (&msg->cid.connection_of_tunnel),
       GNUNET_i2s (&pids[off + 1]),
       off + 1);
  route = GNUNET_new (struct CadetRoute);
  route->cid = msg->cid;
  route->last_use = GNUNET_TIME_absolute_get ();
  dir_init (&route->prev, route, sender);
  dir_init (&route->next, route, next);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_put (
                   routes,
                   &route->cid.connection_of_tunnel,
                   route,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  GNUNET_STATISTICS_set (stats,
                         "# routes",
                         GNUNET_CONTAINER_multishortmap_size (routes),
                         GNUNET_NO);
  route->hn = GNUNET_CONTAINER_heap_insert (route_heap,
                                            route,
                                            route->last_use.abs_value_us);
  if (NULL == timeout_task)
    timeout_task =
      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
                                      keepalive_period,
                                      3),
                                    &timeout_cb,
                                    NULL);
  /* also pass CREATE message along to next hop */
  route_message (sender,
                 &msg->cid,
                 &msg->header,
                 GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY);
}

References GNUNET_TIME_Absolute::abs_value_us, CADET_TUNNEL_KEY_OK, CADET_TUNNEL_KEY_UNINITIALIZED, CadetRoute::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, dir_init(), GCC_handle_duplicate_create(), GCC_lookup(), GCP_2s(), GCP_check_and_update_monotime(), GCP_check_monotime_sig(), GCP_get(), GCP_get_tunnel(), GCP_has_core_connection(), GCPP_2s(), GCPP_get_path_from_route(), GCT_add_inbound_connection(), GCT_change_estate(), GCT_get_estate(), get_route(), GNUNET_assert, GNUNET_break_op, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcmp, GNUNET_MQ_PREF_LOW_LATENCY, GNUNET_MQ_PRIO_CRITICAL_CONTROL, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_sh2s(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_multiply(), GNUNET_YES, CadetRoute::hn, keepalive_period, CadetRoute::last_use, LOG, map, max_routes, msg, my_full_id, CadetRoute::next, origin, CadetRoute::prev, route_heap, route_message(), routes, send_broken_without_mqm(), GNUNET_MessageHeader::size, size, stats, t, timeout_cb(), and timeout_task.

Here is the call graph for this function:

handle_connection_create_ack()

static void handle_connection_create_ack ( void *  cls, const struct GNUNET_CADET_ConnectionCreateAckMessage *  msg  )

static

Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK.

Parameters

cls	Closure (CadetPeer for neighbor that sent the message).
msg	Message itself.

Definition at line 916 of file gnunet-service-cadet_core.c.

{
  struct CadetPeer *peer = cls;
  struct CadetConnection *cc;
 
  /* First, check if ACK belongs to a connection that ends here. */
  cc = GCC_lookup (&msg->cid);
  if (NULL != cc)
  {
    /* verify ACK came from the right direction */
    unsigned int len;
    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
    if (peer != GCPP_get_peer_at_offset (path, 0))
    {
      /* received ACK from unexpected direction, ignore! */
      GNUNET_break_op (0);
      return;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received CONNECTION_CREATE_ACK for connection %s.\n",
         GNUNET_sh2s (&msg->cid.connection_of_tunnel));
    GCC_handle_connection_create_ack (cc);
    return;
  }
 
  /* We're just an intermediary peer, route the message along its path */
  route_message (peer,
                 &msg->cid,
                 &msg->header,
                 GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY);
}

References GCC_get_path(), GCC_handle_connection_create_ack(), GCC_lookup(), GCPP_get_peer_at_offset(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_PREF_LOW_LATENCY, GNUNET_MQ_PRIO_CRITICAL_CONTROL, GNUNET_sh2s(), LOG, msg, and route_message().

Here is the call graph for this function:

handle_connection_broken()

static void handle_connection_broken ( void *  cls, const struct GNUNET_CADET_ConnectionBrokenMessage *  msg  )

static

Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN.

Parameters

cls	Closure (CadetPeer for neighbor that sent the message).
msg	Message itself.

Deprecated:

duplicate logic with handle_destroy(); dedup!

Definition at line 960 of file gnunet-service-cadet_core.c.

{
  struct CadetPeer *peer = cls;
  struct CadetConnection *cc;
  struct CadetRoute *route;
 
  /* First, check if message belongs to a connection that ends here. */
  cc = GCC_lookup (&msg->cid);
  if (NULL != cc)
  {
    /* verify message came from the right direction */
    unsigned int len;
    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
    if (peer != GCPP_get_peer_at_offset (path, 0))
    {
      /* received message from unexpected direction, ignore! */
      GNUNET_break_op (0);
      return;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received CONNECTION_BROKEN for connection %s. Destroying it.\n",
         GNUNET_sh2s (&msg->cid.connection_of_tunnel));
    GCC_destroy_without_core (cc);
 
    /* FIXME: also destroy the path up to the specified link! */
    return;
  }
 
  /* We're just an intermediary peer, route the message along its path */
  route_message (peer,
                 &msg->cid,
                 &msg->header,
                 GNUNET_MQ_PREF_LOW_LATENCY | GNUNET_MQ_PRIO_CRITICAL_CONTROL);
  route = get_route (&msg->cid);
  if (NULL != route)
    destroy_route (route);
  /* FIXME: also destroy paths we MAY have up to the specified link! */
}

References destroy_route(), GCC_destroy_without_core(), GCC_get_path(), GCC_lookup(), GCPP_get_peer_at_offset(), get_route(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_PREF_LOW_LATENCY, GNUNET_MQ_PRIO_CRITICAL_CONTROL, GNUNET_sh2s(), LOG, msg, and route_message().

Here is the call graph for this function:

handle_connection_destroy()

static void handle_connection_destroy ( void *  cls, const struct GNUNET_CADET_ConnectionDestroyMessage *  msg  )

static

Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY.

Parameters

cls	Closure (CadetPeer for neighbor that sent the message).
msg	Message itself.

Definition at line 1010 of file gnunet-service-cadet_core.c.

{
  struct CadetPeer *peer = cls;
  struct CadetConnection *cc;
  struct CadetRoute *route;
 
  /* First, check if message belongs to a connection that ends here. */
  cc = GCC_lookup (&msg->cid);
  if (NULL != cc)
  {
    /* verify message came from the right direction */
    unsigned int len;
    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
    if (peer != GCPP_get_peer_at_offset (path, 0))
    {
      /* received message from unexpected direction, ignore! */
      GNUNET_break_op (0);
      return;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received CONNECTION_DESTROY for connection %s. Destroying connection.\n",
         GNUNET_sh2s (&msg->cid.connection_of_tunnel));
 
    GCC_destroy_without_core (cc);
    return;
  }
 
  /* We're just an intermediary peer, route the message along its path */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received CONNECTION_DESTROY for connection %s. Destroying route.\n",
       GNUNET_sh2s (&msg->cid.connection_of_tunnel));
  route_message (peer,
                 &msg->cid,
                 &msg->header,
                 GNUNET_MQ_PREF_LOW_LATENCY | GNUNET_MQ_PRIO_CRITICAL_CONTROL);
  route = get_route (&msg->cid);
  if (NULL != route)
    destroy_route (route);
}

References destroy_route(), GCC_destroy_without_core(), GCC_get_path(), GCC_lookup(), GCPP_get_peer_at_offset(), get_route(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_PREF_LOW_LATENCY, GNUNET_MQ_PRIO_CRITICAL_CONTROL, GNUNET_sh2s(), LOG, msg, and route_message().

Here is the call graph for this function:

handle_tunnel_kx()

static void handle_tunnel_kx ( void *  cls, const struct GNUNET_CADET_TunnelKeyExchangeMessage *  msg  )

static

Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX.

Parameters

cls	Closure (CadetPeer for neighbor that sent the message).
msg	Message itself.

Definition at line 1061 of file gnunet-service-cadet_core.c.

{
  struct CadetPeer *peer = cls;
  struct CadetConnection *cc;
 
  /* First, check if message belongs to a connection that ends here. */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Routing KX with ephemeral %s on CID %s\n",
       GNUNET_e2s (&msg->ephemeral_key),
       GNUNET_sh2s (&msg->cid.connection_of_tunnel));
 
 
  cc = GCC_lookup (&msg->cid);
  if (NULL != cc)
  {
    /* verify message came from the right direction */
    unsigned int len;
    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
    if (peer != GCPP_get_peer_at_offset (path, 0))
    {
      /* received message from unexpected direction, ignore! */
      GNUNET_break_op (0);
      return;
    }
    GCC_handle_kx (cc, msg);
    return;
  }
 
  /* We're just an intermediary peer, route the message along its path */
  route_message (peer,
                 &msg->cid,
                 &msg->header,
                 GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY);
}

References GCC_get_path(), GCC_handle_kx(), GCC_lookup(), GCPP_get_peer_at_offset(), GNUNET_break_op, GNUNET_e2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_PREF_LOW_LATENCY, GNUNET_MQ_PRIO_CRITICAL_CONTROL, GNUNET_sh2s(), LOG, msg, and route_message().

Here is the call graph for this function:

handle_tunnel_kx_auth()

static void handle_tunnel_kx_auth ( void *  cls, const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *  msg  )

static

Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH.

Parameters

cls	Closure (CadetPeer for neighbor that sent the message).
msg	Message itself.

Definition at line 1106 of file gnunet-service-cadet_core.c.

{
  struct CadetPeer *peer = cls;
  struct CadetConnection *cc;
 
  /* First, check if message belongs to a connection that ends here. */
  cc = GCC_lookup (&msg->kx.cid);
  if (NULL != cc)
  {
    /* verify message came from the right direction */
    unsigned int len;
    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
    if (peer != GCPP_get_peer_at_offset (path, 0))
    {
      /* received message from unexpected direction, ignore! */
      GNUNET_break_op (0);
      return;
    }
    GCC_handle_kx_auth (cc, msg);
    return;
  }
 
  /* We're just an intermediary peer, route the message along its path */
  route_message (peer,
                 &msg->kx.cid,
                 &msg->kx.header,
                 GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY);
}

References GCC_get_path(), GCC_handle_kx_auth(), GCC_lookup(), GCPP_get_peer_at_offset(), GNUNET_break_op, GNUNET_MQ_PREF_LOW_LATENCY, GNUNET_MQ_PRIO_CRITICAL_CONTROL, msg, and route_message().

Here is the call graph for this function:

check_tunnel_encrypted()

static int check_tunnel_encrypted ( void *  cls, const struct GNUNET_CADET_TunnelEncryptedMessage *  msg  )

static

Check if the encrypted message has the appropriate size.

Parameters

cls	Closure (unused).
msg	Message to check.

Returns

GNUNET_YES if size is correct, GNUNET_NO otherwise.

Definition at line 1148 of file gnunet-service-cadet_core.c.

{
  return GNUNET_YES;
}

References GNUNET_YES.

handle_tunnel_encrypted()

static void handle_tunnel_encrypted ( void *  cls, const struct GNUNET_CADET_TunnelEncryptedMessage *  msg  )

static

Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED.

Parameters

cls	Closure (CadetPeer for neighbor that sent the message).
msg	Message itself.

Definition at line 1162 of file gnunet-service-cadet_core.c.

{
  struct CadetPeer *peer = cls;
  struct CadetConnection *cc;
 
  /* First, check if message belongs to a connection that ends here. */
  cc = GCC_lookup (&msg->cid);
  if (NULL != cc)
  {
    /* verify message came from the right direction */
    unsigned int len;
    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
    if (peer != GCPP_get_peer_at_offset (path, 0))
    {
      /* received message from unexpected direction, ignore! */
      GNUNET_break_op (0);
      return;
    }
    GCC_handle_encrypted (cc, msg);
    return;
  }
  /* We're just an intermediary peer, route the message along its path */
  route_message (peer, &msg->cid, &msg->header, GNUNET_MQ_PRIO_BEST_EFFORT);
}

References GCC_get_path(), GCC_handle_encrypted(), GCC_lookup(), GCPP_get_peer_at_offset(), GNUNET_break_op, GNUNET_MQ_PRIO_BEST_EFFORT, msg, and route_message().

Here is the call graph for this function:

core_init_cb()

static void core_init_cb ( void *  cls, const struct GNUNET_PeerIdentity *  my_identity  )

static

Function called after GNUNET_CORE_connect has succeeded (or failed for good).

Note that the private key of the peer is intentionally not exposed here; if you need it, your process should try to read the private key file directly (which should work if you are authorized...). Implementations of this function must not call GNUNET_CORE_disconnect (other than by scheduling a new task to do this later).

Parameters

cls	closure
my_identity	ID of this peer, NULL if we failed

Definition at line 1203 of file gnunet-service-cadet_core.c.

{
  if (NULL == my_identity)
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_break (0 == GNUNET_memcmp (my_identity, &my_full_id));
}

References GNUNET_break, GNUNET_memcmp, my_full_id, and my_identity.

Referenced by GCO_init().

Here is the caller graph for this function:

core_connect_cb()

static void * core_connect_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq  )

static

Method called whenever a given peer connects.

Parameters

cls	closure
peer	peer identity this notification is about

Definition at line 1221 of file gnunet-service-cadet_core.c.

{
  struct CadetPeer *cp;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "CORE connection to peer %s was established.\n",
       GNUNET_i2s (peer));
  cp = GCP_get (peer, GNUNET_YES);
  GCP_set_mq (cp, mq);
  return cp;
}

References GCP_get(), GCP_set_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, LOG, and mq.

Referenced by GCO_init().

Here is the call graph for this function:

Here is the caller graph for this function:

core_disconnect_cb()

static void core_disconnect_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  peer_cls  )

static

Method called whenever a peer disconnects.

Parameters

cls	closure
peer	peer identity this notification is about

Definition at line 1243 of file gnunet-service-cadet_core.c.

{
  struct CadetPeer *cp = peer_cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "CORE connection to peer %s went down.\n",
       GNUNET_i2s (peer));
  GCP_set_mq (cp, NULL);
}

References GCP_set_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), and LOG.

Referenced by GCO_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GCO_init()

void GCO_init

(

const struct GNUNET_CONFIGURATION_Handle *

c

)

Initialize the CORE subsystem.

Parameters

c	Configuration.

Definition at line 1262 of file gnunet-service-cadet_core.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_var_size (connection_create,
                           GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE,
                           struct GNUNET_CADET_ConnectionCreateMessage,
                           NULL),
    GNUNET_MQ_hd_fixed_size (connection_create_ack,
                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK,
                             struct GNUNET_CADET_ConnectionCreateAckMessage,
                             NULL),
    GNUNET_MQ_hd_fixed_size (connection_broken,
                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN,
                             struct GNUNET_CADET_ConnectionBrokenMessage,
                             NULL),
    GNUNET_MQ_hd_fixed_size (connection_destroy,
                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY,
                             struct GNUNET_CADET_ConnectionDestroyMessage,
                             NULL),
    GNUNET_MQ_hd_fixed_size (tunnel_kx,
                             GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX,
                             struct GNUNET_CADET_TunnelKeyExchangeMessage,
                             NULL),
    GNUNET_MQ_hd_fixed_size (tunnel_kx_auth,
                             GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH,
                             struct GNUNET_CADET_TunnelKeyExchangeAuthMessage,
                             NULL),
    GNUNET_MQ_hd_var_size (tunnel_encrypted,
                           GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED,
                           struct GNUNET_CADET_TunnelEncryptedMessage,
                           NULL),
    GNUNET_MQ_handler_end () };
 
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c,
                                                          "CADET",
                                                          "MAX_ROUTES",
                                                          &max_routes))
    max_routes = 5000;
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c,
                                                          "CADET",
                                                          "MAX_MSGS_QUEUE",
                                                          &max_buffers))
    max_buffers = 10000;
  routes = GNUNET_CONTAINER_multishortmap_create (1024, GNUNET_NO);
  route_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  core = GNUNET_CORE_connect (c,
                              NULL,
                              &core_init_cb,
                              &core_connect_cb,
                              &core_disconnect_cb,
                              handlers);
}

References connection_create(), connection_destroy(), core, core_connect_cb(), core_disconnect_cb(), core_init_cb(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CORE_connect(), GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY, GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED, GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX, GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_OK, handlers, max_buffers, max_routes, route_heap, and routes.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GCO_shutdown()

void GCO_shutdown

(

void

)

Shut down the CORE subsystem.

Definition at line 1317 of file gnunet-service-cadet_core.c.

{
  if (NULL != core)
  {
    GNUNET_CORE_disconnect (core);
    core = NULL;
  }
  GNUNET_assert (0 == GNUNET_CONTAINER_multishortmap_size (routes));
  GNUNET_CONTAINER_multishortmap_destroy (routes);
  routes = NULL;
  GNUNET_CONTAINER_heap_destroy (route_heap);
  route_heap = NULL;
  if (NULL != timeout_task)
  {
    GNUNET_SCHEDULER_cancel (timeout_task);
    timeout_task = NULL;
  }
}

References core, GNUNET_assert, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_CORE_disconnect(), GNUNET_SCHEDULER_cancel(), route_heap, routes, and timeout_task.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

core

struct GNUNET_CORE_Handle* core

static

Handle to the CORE service.

Definition at line 174 of file gnunet-service-cadet_core.c.

Referenced by GCO_init(), and GCO_shutdown().

routes

struct GNUNET_CONTAINER_MultiShortmap* routes

static

Routes on which this peer is an intermediate.

Definition at line 179 of file gnunet-service-cadet_core.c.

Referenced by destroy_route(), GCO_init(), GCO_shutdown(), get_route(), and handle_connection_create().

route_heap

struct GNUNET_CONTAINER_Heap* route_heap

static

Heap of routes, MIN-sorted by last activity.

Definition at line 184 of file gnunet-service-cadet_core.c.

Referenced by GCO_init(), GCO_shutdown(), handle_connection_create(), and timeout_cb().

rung_zero

struct Rung rung_zero

static

Rung zero (always pointed to by rung_head).

Definition at line 189 of file gnunet-service-cadet_core.c.

rung_head

struct Rung* rung_head = &rung_zero

static

DLL of rungs, with the head always point to a rung of route directions with no messages in the queue.

Definition at line 195 of file gnunet-service-cadet_core.c.

Referenced by destroy_direction(), dir_init(), discard_all_from_rung_tail(), lower_rung(), and route_message().

rung_tail

struct Rung* rung_tail = &rung_zero

static

Tail of the rung_head DLL.

Definition at line 200 of file gnunet-service-cadet_core.c.

Referenced by discard_all_from_rung_tail(), lower_rung(), and route_message().

max_routes

unsigned long long max_routes

static

Maximum number of concurrent routes this peer will support.

Definition at line 205 of file gnunet-service-cadet_core.c.

Referenced by GCO_init(), and handle_connection_create().

max_buffers

unsigned long long max_buffers

static

Maximum number of envelopes we will buffer at this peer.

Definition at line 210 of file gnunet-service-cadet_core.c.

Referenced by GCO_init(), and route_message().

cur_buffers

unsigned long long cur_buffers

static

Current number of envelopes we have buffered at this peer.

Definition at line 215 of file gnunet-service-cadet_core.c.

Referenced by dir_ready_cb(), discard_buffer(), and route_message().

timeout_task

struct GNUNET_SCHEDULER_Task* timeout_task

static

Task to timeout routes.

Definition at line 220 of file gnunet-service-cadet_core.c.

Referenced by GCO_shutdown(), handle_connection_create(), and timeout_cb().