cadet service; interaction with CORE service More...

#include "gnunet-service-cadet.h"
#include "gnunet_common.h"
#include "gnunet_pils_service.h"
#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:

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.

static void	lower_rung (struct RouteDirection *dir)
	Lower the rung in which dir is by 1.

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.

static void	discard_all_from_rung_tail ()
	Discard all messages from the highest rung, to make space.

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.

static int	check_connection_create (void cls, const struct GNUNET_CADET_ConnectionCreateMessage msg)
	Check if the create_connection message has the appropriate size.

static void	destroy_direction (struct RouteDirection *dir)
	Free internal data of a route direction.

static void	destroy_route (struct CadetRoute *route)
	Destroy our state for route.

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.

static void	timeout_cb (void *cls)
	Function called to check if any routes have timed out, and if so, to clean them up.

static void	dir_ready_cb (void *cls, int ready)
	Function called when the message queue to the previous hop becomes available/unavailable.

static void	dir_init (struct RouteDirection dir, struct CadetRoute route, struct CadetPeer *hop)
	Initialize one of the directions of a route.

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.

static void	handle_connection_create (void cls, const struct GNUNET_CADET_ConnectionCreateMessage msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE.

static void	handle_connection_create_ack (void cls, const struct GNUNET_CADET_ConnectionCreateAckMessage msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK.

static void	handle_connection_broken (void cls, const struct GNUNET_CADET_ConnectionBrokenMessage msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN.

static void	handle_connection_destroy (void cls, const struct GNUNET_CADET_ConnectionDestroyMessage msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY.

static void	handle_tunnel_kx (void cls, const struct GNUNET_CADET_TunnelKeyExchangeMessage msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX.

static void	handle_tunnel_kx_auth (void cls, const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH.

static int	check_tunnel_encrypted (void cls, const struct GNUNET_CADET_TunnelEncryptedMessage msg)
	Check if the encrypted message has the appropriate size.

static void	handle_tunnel_encrypted (void cls, const struct GNUNET_CADET_TunnelEncryptedMessage msg)
	Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED.

static void *	core_connect_cb (void cls, const struct GNUNET_PeerIdentity peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
	Method called whenever a given peer connects.

static void	core_disconnect_cb (void cls, const struct GNUNET_PeerIdentity peer, void *peer_cls)
	Method called whenever a peer disconnects.

void	GCO_init (const struct GNUNET_CONFIGURATION_Handle *c)
	Initialize the CORE subsystem.

void	GCO_shutdown ()
	Shut down the CORE subsystem.

Variables
static struct GNUNET_CORE_Handle *	core
	Handle to the CORE service.

static struct GNUNET_CONTAINER_MultiShortmap *	routes
	Routes on which this peer is an intermediate.

static struct GNUNET_CONTAINER_Heap *	route_heap
	Heap of routes, MIN-sorted by last activity.

static struct Rung	rung_zero
	Rung zero (always pointed to by rung_head).

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.

static struct Rung *	rung_tail = &rung_zero
	Tail of the rung_head DLL.

static unsigned long long	max_routes
	Maximum number of concurrent routes this peer will support.

static unsigned long long	max_buffers
	Maximum number of envelopes we will buffer at this peer.

static unsigned long long	cur_buffers
	Current number of envelopes we have buffered at this peer.

static struct GNUNET_SCHEDULER_Task *	timeout_task
	Task to timeout routes.

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 45 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 231 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 244 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 272 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 286 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 317 of file gnunet-service-cadet_core.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct CadetRoute *route;
  struct RouteDirection *dir;
  struct Rung *rung;
  struct Rung *nxt;
  struct GNUNET_MQ_Envelope *env;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  if (! my_identity)
    return;
 
  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_identity;
    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_PILS_get_identity(), 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_identity, Rung::next, CadetRoute::next, GNUNET_CADET_ConnectionBrokenMessage::peer1, pils, 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 472 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 492 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 519 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 551 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 587 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 629 of file gnunet-service-cadet_core.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct RouteDirection *dir = cls;
  struct CadetRoute *route = dir->my_route;
  struct RouteDirection *odir;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  if (! my_identity)
    return;
 
  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_identity);
  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_PILS_get_identity(), GNUNET_STATISTICS_set(), GNUNET_YES, RouteDirection::hop, lower_rung(), my_identity, CadetRoute::next, pils, 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 671 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 695 of file gnunet-service-cadet_core.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_CADET_ConnectionBrokenMessage *bm;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
  bm->cid = *cid;
  bm->peer1 = *my_identity;
  if (NULL != failure_at)
    bm->peer2 = *failure_at;
  GCP_send_ooo (target, env);
}

References GNUNET_CADET_ConnectionBrokenMessage::cid, env, GCP_send_ooo(), GNUNET_assert, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, GNUNET_MQ_msg, GNUNET_PILS_get_identity(), my_identity, GNUNET_CADET_ConnectionBrokenMessage::peer1, GNUNET_CADET_ConnectionBrokenMessage::peer2, and pils.

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 723 of file gnunet-service-cadet_core.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  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;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  if (! my_identity)
    return;
 
  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_identity, &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_PILS_get_identity(), 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_identity, CadetRoute::next, origin, pils, 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 938 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, CadetConnection::off, 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 982 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 1032 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 1083 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, CadetConnection::off, 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 1128 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, CadetConnection::off, 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 1170 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 1184 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, CadetConnection::off, and route_message().

Here is the call graph for this function:

◆ core_connect_cb()

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

static

Method called whenever a given peer connects.

Parameters

cls	closure
peer	peer identity this notification is about
class	class of the connecting peer

Definition at line 1220 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 () };
  const struct GNUNET_CORE_ServiceInfo service_info = {
    .service = GNUNET_CORE_SERVICE_CADET,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  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,
                              NULL,
                              &core_connect_cb,
                              &core_disconnect_cb,
                              handlers,
                              &service_info);
}

References connection_create(), connection_destroy(), core, core_connect_cb(), core_disconnect_cb(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CORE_connect(), GNUNET_CORE_SERVICE_CADET, 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, routes, and GNUNET_CORE_ServiceInfo::service.

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 1324 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;
  }
}