GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
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
 Description of a segment of a struct CadetConnection at the intermediate peers. More...
 

Macros

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

Functions

static struct CadetRouteget_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_Handlecore
 Handle to the CORE service. More...
 
static struct GNUNET_CONTAINER_MultiShortmaproutes
 Routes on which this peer is an intermediate. More...
 
static struct GNUNET_CONTAINER_Heaproute_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 Rungrung_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 Rungrung_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_Tasktimeout_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:

Definition in file gnunet-service-cadet_core.c.

Macro Definition Documentation

◆ LOG

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

Function Documentation

◆ get_route()

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

Get the route corresponding to a hash.

Parameters
cidhash generated from the connection identifier

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

References GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, and GNUNET_CONTAINER_multishortmap_get().

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

237 {
239  &cid->connection_of_tunnel);
240 }
void * GNUNET_CONTAINER_multishortmap_get(const struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key)
Given a key find a value in the map matching the key.
struct GNUNET_ShortHashCode connection_of_tunnel
static struct GNUNET_CONTAINER_MultiShortmap * routes
Routes on which this peer is an intermediate.
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
dirdirection to lower in rung.

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

References 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, RouteDirection::rung, and Rung::rung_off.

Referenced by dir_ready_cb(), and discard_buffer().

250 {
251  struct Rung *rung = dir->rung;
252  struct Rung *prev;
253 
254  GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir);
255  prev = rung->prev;
256  GNUNET_assert (NULL != prev);
257  if (prev->rung_off != rung->rung_off - 1)
258  {
259  prev = GNUNET_new (struct Rung);
260  prev->rung_off = rung->rung_off - 1;
262  }
263  GNUNET_assert (NULL != prev);
264  GNUNET_CONTAINER_DLL_insert (prev->rd_head, prev->rd_tail, dir);
265  dir->rung = prev;
266 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Set of CadetRoutes that have exactly the same number of messages in their buffer. ...
struct Rung * prev
Rung of RouteDirections with one less buffer entry each.
struct RouteDirection * rd_head
DLL of route directions with a number of buffer entries matching this rung.
static struct Rung * rung_head
DLL of rungs, with the head always point to a rung of route directions with no messages in the queue...
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element)
Insert an element into a DLL after the given other element.
struct RouteDirection * rd_tail
DLL of route directions with a number of buffer entries matching this rung.
unsigned int rung_off
Number of messages route directions at this rung have in their buffer.
struct Rung * rung
Rung of this route direction (matches length of the buffer DLL).
static struct Rung * rung_tail
Tail of the rung_head DLL.
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
dirdirection that contains the env in the buffer
envenvelope to discard

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

References cur_buffers, RouteDirection::env_head, RouteDirection::env_tail, 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().

278 {
279  GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env);
280  cur_buffers--;
281  GNUNET_MQ_discard (env);
282  lower_rung (dir);
283  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
284 }
struct GNUNET_MQ_Envelope * env_head
Head of DLL of envelopes we have in the buffer for this direction.
static unsigned long long cur_buffers
Current number of envelopes we have buffered at this peer.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void GNUNET_MQ_dll_remove(struct GNUNET_MQ_Envelope **env_head, struct GNUNET_MQ_Envelope **env_tail, struct GNUNET_MQ_Envelope *env)
Remove env from the envelope DLL starting at env_head.
Definition: mq.c:1212
static void lower_rung(struct RouteDirection *dir)
Lower the rung in which dir is by 1.
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:323
struct GNUNET_MQ_Envelope * env_tail
Tail of DLL of envelopes we have in the buffer for this direction.
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 291 of file gnunet-service-cadet_core.c.

References CadetRoute::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, dir, discard_buffer(), RouteDirection::env_head, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_sh2s(), GNUNET_STATISTICS_update(), LOG, RouteDirection::my_route, Rung::rd_head, rung_tail, stats, and tail.

Referenced by route_message().

292 {
293  struct Rung *tail = rung_tail;
294  struct RouteDirection *dir;
295 
296  while (NULL != (dir = tail->rd_head))
297  {
299  "Queue full due new message %s on connection %s, dropping old message\n",
302  "# messages dropped due to full buffer",
303  1,
304  GNUNET_NO);
305  discard_buffer (dir, dir->env_head);
306  }
308  GNUNET_free (tail);
309 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
struct GNUNET_MQ_Envelope * env_head
Head of DLL of envelopes we have in the buffer for this direction.
Information we keep per direction for a route.
#define LOG(level,...)
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
Set of CadetRoutes that have exactly the same number of messages in their buffer. ...
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
Unique identifier for the connection that uses this route.
struct CadetRoute * my_route
Route this direction is part of.
struct RouteDirection * rd_head
DLL of route directions with a number of buffer entries matching this rung.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
static struct Rung * rung_head
DLL of rungs, with the head always point to a rung of route directions with no messages in the queue...
static struct PendingResolutions * tail
Tail of list of pending resolution requests.
Definition: gnunet-ats.c:235
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.
struct GNUNET_ShortHashCode connection_of_tunnel
static struct Rung * rung_tail
Tail of the rung_head DLL.
#define GNUNET_free(ptr)
Wrapper around free.
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
prevprevious hop (sender)
cidconnection identifier, tells us which route to use
msgthe message to forward

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

References GNUNET_TIME_Absolute::abs_value_us, CadetRoute::cid, GNUNET_CADET_ConnectionBrokenMessage::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, cur_buffers, dir, discard_all_from_rung_tail(), discard_buffer(), env, RouteDirection::env_head, RouteDirection::env_tail, 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, RouteDirection::is_ready, CadetRoute::last_use, LOG, max_buffers, RouteDirection::mqm, my_full_id, RouteDirection::my_route, Rung::next, CadetRoute::next, GNUNET_CADET_ConnectionBrokenMessage::peer1, CadetRoute::prev, Rung::rd_head, Rung::rd_tail, RouteDirection::rung, Rung::rung_off, 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().

326 {
327  struct CadetRoute *route;
328  struct RouteDirection *dir;
329  struct Rung *rung;
330  struct Rung *nxt;
331  struct GNUNET_MQ_Envelope *env;
332 
333  route = get_route (cid);
334  if (NULL == route)
335  {
336  struct GNUNET_MQ_Envelope *env;
338 
340  "Failed to route message of type %u from %s on connection %s: no route\n",
341  ntohs (msg->type),
342  GCP_2s (prev),
344  switch (ntohs (msg->type))
345  {
348  /* No need to respond to these! */
349  return;
350  }
352  bm->cid = *cid;
353  bm->peer1 = my_full_id;
354  GCP_send_ooo (prev, env);
355  return;
356  }
359  dir = (prev == route->prev.hop) ? &route->next : &route->prev;
360  if (GNUNET_YES == dir->is_ready)
361  {
363  "Routing message of type %u from %s to %s on connection %s\n",
364  ntohs (msg->type),
365  GCP_2s (prev),
366  GNUNET_i2s (GCP_get_id (dir->hop)),
368  dir->is_ready = GNUNET_NO;
369  GCP_send (dir->mqm, GNUNET_MQ_msg_copy (msg));
370  return;
371  }
372  /* Check if low latency is required and if the previous message was
373  unreliable; if so, make sure we only queue one message per
374  direction (no buffering). */
375  if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) &&
376  (NULL != dir->env_head) &&
377  (0 ==
379  discard_buffer (dir, dir->env_head);
380  /* Check for duplicates */
381  for (const struct GNUNET_MQ_Envelope *env = dir->env_head; NULL != env;
382  env = GNUNET_MQ_env_next (env))
383  {
384  const struct GNUNET_MessageHeader *hdr = GNUNET_MQ_env_get_msg (env);
385 
386  if ((hdr->size == msg->size) && (0 == memcmp (hdr, msg, ntohs (msg->size))))
387  {
389  "Received duplicate of message already in buffer, dropping\n");
391  "# messages dropped due to duplicate in buffer",
392  1,
393  GNUNET_NO);
394  return;
395  }
396  }
397 
398  rung = dir->rung;
399  if (cur_buffers == max_buffers)
400  {
401  /* Need to make room. */
402  if (NULL != rung->next)
403  {
404  /* Easy case, drop messages from route directions in highest rung */
406  }
407  else
408  {
409  /* We are in the highest rung, drop our own! */
411  "Queue full due new message %s on connection %s, dropping old message\n",
414  "# messages dropped due to full buffer",
415  1,
416  GNUNET_NO);
417  discard_buffer (dir, dir->env_head);
418  rung = dir->rung;
419  }
420  }
421  /* remove 'dir' from current rung */
422  GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir);
423  /* make 'nxt' point to the next higher rung, create if necessary */
424  nxt = rung->next;
425  if ((NULL == nxt) || (rung->rung_off + 1 != nxt->rung_off))
426  {
427  nxt = GNUNET_new (struct Rung);
428  nxt->rung_off = rung->rung_off + 1;
430  }
431  /* insert 'dir' into next higher rung */
432  GNUNET_CONTAINER_DLL_insert (nxt->rd_head, nxt->rd_tail, dir);
433  dir->rung = nxt;
434 
435  /* add message into 'dir' buffer */
437  "Queueing new message of type %u from %s to %s on connection %s\n",
438  ntohs (msg->type),
439  GCP_2s (prev),
440  GNUNET_i2s (GCP_get_id (dir->hop)),
442  env = GNUNET_MQ_msg_copy (msg);
443  GNUNET_MQ_env_set_options (env, priority);
444  if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) &&
445  (0 != (priority & GNUNET_MQ_PREF_OUT_OF_ORDER)) &&
446  (NULL != dir->env_head) &&
447  (0 == (GNUNET_MQ_env_get_options (dir->env_head)
448  & GNUNET_MQ_PREF_LOW_LATENCY)))
449  GNUNET_MQ_dll_insert_head (&dir->env_head, &dir->env_tail, env);
450  else
451  GNUNET_MQ_dll_insert_tail (&dir->env_head, &dir->env_tail, env);
452  cur_buffers++;
453  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
454  /* Clean up 'rung' if now empty (and not head) */
455  if ((NULL == rung->rd_head) && (rung != rung_head))
456  {
458  GNUNET_free (rung);
459  }
460 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
void GNUNET_MQ_dll_insert_tail(struct GNUNET_MQ_Envelope **env_head, struct GNUNET_MQ_Envelope **env_tail, struct GNUNET_MQ_Envelope *env)
Insert env into the envelope DLL starting at env_head Note that env must not be in any MQ while this ...
Definition: mq.c:1191
void GNUNET_MQ_dll_insert_head(struct GNUNET_MQ_Envelope **env_head, struct GNUNET_MQ_Envelope **env_tail, struct GNUNET_MQ_Envelope *env)
Insert env into the envelope DLL starting at env_head Note that env must not be in any MQ while this ...
Definition: mq.c:1170
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
static unsigned long long max_buffers
Maximum number of envelopes we will buffer at this peer.
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
void GNUNET_CONTAINER_heap_update_cost(struct GNUNET_CONTAINER_HeapNode *node, GNUNET_CONTAINER_HeapCostType new_cost)
Updates the cost of any node in the tree.
struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
Create a new envelope by copying an existing message.
Definition: mq.c:666
struct GNUNET_MQ_Envelope * env_head
Head of DLL of envelopes we have in the buffer for this direction.
const struct GNUNET_MessageHeader * GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
Obtain message contained in envelope.
Definition: mq.c:1097
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Information we keep per direction for a route.
struct GNUNET_CONTAINER_HeapNode * hn
Position of this route in the route_heap.
#define LOG(level,...)
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
static unsigned long long cur_buffers
Current number of envelopes we have buffered at this peer.
void GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this envelope.
Definition: mq.c:1022
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GCP_send(struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *env)
Send the message in env to cp.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
Set of CadetRoutes that have exactly the same number of messages in their buffer. ...
uint64_t abs_value_us
The actual value.
const struct GNUNET_MQ_Envelope * GNUNET_MQ_env_next(const struct GNUNET_MQ_Envelope *env)
Return next envelope in queue.
Definition: mq.c:1110
struct Rung * next
Rung of RouteDirections with one more buffer entry each.
const char * GCP_2s(const struct CadetPeer *cp)
Get the static string for a peer ID.
Flag to indicate that low latency is important.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
Unique identifier for the connection that uses this route.
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:1037
struct CadetRoute * my_route
Route this direction is part of.
struct RouteDirection * rd_head
DLL of route directions with a number of buffer entries matching this rung.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
static struct CadetRoute * get_route(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Get the route corresponding to a hash.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct RouteDirection prev
Information about the previous hop on this route.
void GCP_send_ooo(struct CadetPeer *cp, struct GNUNET_MQ_Envelope *env)
Send the message in env to cp, overriding queueing logic.
Description of a segment of a struct CadetConnection at the intermediate peers.
struct CadetPeer * hop
Target peer.
struct GNUNET_TIME_Absolute last_use
When was this route last in use?
static struct Rung * rung_head
DLL of rungs, with the head always point to a rung of route directions with no messages in the queue...
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element)
Insert an element into a DLL after the given other element.
Message for notifying a disconnection in a path.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct RouteDirection next
Information about the next hop on this route.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct RouteDirection * rd_tail
DLL of route directions with a number of buffer entries matching this rung.
unsigned int rung_off
Number of messages route directions at this rung have in their buffer.
struct GNUNET_PeerIdentity peer1
ID of the endpoint.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GCP_MessageQueueManager * mqm
Message queue manager for hop.
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY
Request the destuction of a connection.
Flag to indicate that out-of-order delivery is OK.
struct Rung * rung
Rung of this route direction (matches length of the buffer DLL).
Header for all communications.
int is_ready
Is mqm currently ready for transmission?
Flag to indicate that unreliable delivery is acceptable.
static void discard_all_from_rung_tail()
Discard all messages from the highest rung, to make space.
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.
struct GNUNET_ShortHashCode connection_of_tunnel
static struct Rung * rung_tail
Tail of the rung_head DLL.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
Notify that a connection is no longer valid.
struct GNUNET_MQ_Envelope * env_tail
Tail of DLL of envelopes we have in the buffer for this direction.
#define GNUNET_free(ptr)
Wrapper around free.
const struct GNUNET_PeerIdentity * GCP_get_id(struct CadetPeer *cp)
Obtain the peer identity for a struct CadetPeer.
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
clsClosure (unused).
msgMessage to check.
Returns
GNUNET_YES if size is correct, GNUNET_NO otherwise.

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

References GNUNET_break_op, GNUNET_NO, GNUNET_YES, GNUNET_CADET_ConnectionCreateMessage::header, size, and GNUNET_MessageHeader::size.

474 {
475  uint16_t size = ntohs (msg->header.size) - sizeof(*msg);
476 
477  if (0 != (size % sizeof(struct GNUNET_PeerIdentity)))
478  {
479  GNUNET_break_op (0);
480  return GNUNET_NO;
481  }
482  return GNUNET_YES;
483 }
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
static unsigned int size
Size of the "table".
Definition: peer.c:67
The identity of the host (wraps the signing key of the peer).

◆ destroy_direction()

static void destroy_direction ( struct RouteDirection dir)
static

Free internal data of a route direction.

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

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

References discard_buffer(), env, RouteDirection::env_head, GCP_request_mq_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_NO, GNUNET_STATISTICS_update(), RouteDirection::mqm, Rung::rd_head, Rung::rd_tail, and stats.

Referenced by destroy_route().

493 {
494  struct GNUNET_MQ_Envelope *env;
495 
496  while (NULL != (env = dir->env_head))
497  {
499  "# messages dropped due to route destruction",
500  1,
501  GNUNET_NO);
502  discard_buffer (dir, env);
503  }
504  if (NULL != dir->mqm)
505  {
506  GCP_request_mq_cancel (dir->mqm, NULL);
507  dir->mqm = NULL;
508  }
510 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_MQ_Envelope * env_head
Head of DLL of envelopes we have in the buffer for this direction.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct RouteDirection * rd_head
DLL of route directions with a number of buffer entries matching this rung.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
static struct Rung * rung_head
DLL of rungs, with the head always point to a rung of route directions with no messages in the queue...
struct RouteDirection * rd_tail
DLL of route directions with a number of buffer entries matching this rung.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GCP_MessageQueueManager * mqm
Message queue manager for hop.
void GCP_request_mq_cancel(struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *last_env)
Stops message queue change notifications.
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.
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
routeroute to destroy

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

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, and stats.

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

520 {
522  "Destroying route from %s to %s of connection %s\n",
523  GNUNET_i2s (GCP_get_id (route->prev.hop)),
524  GNUNET_i2s2 (GCP_get_id (route->next.hop)),
527  GNUNET_assert (
528  GNUNET_YES ==
530  &route->cid.connection_of_tunnel,
531  route));
533  "# routes",
535  GNUNET_NO);
536  destroy_direction (&route->prev);
537  destroy_direction (&route->next);
538  GNUNET_free (route);
539 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
const char * GNUNET_i2s2(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
unsigned int GNUNET_CONTAINER_multishortmap_size(const struct GNUNET_CONTAINER_MultiShortmap *map)
Get the number of key-value pairs in the map.
struct GNUNET_CONTAINER_HeapNode * hn
Position of this route in the route_heap.
#define LOG(level,...)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_CONTAINER_multishortmap_remove(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, const void *value)
Remove the given key-value pair from the map.
static void destroy_direction(struct RouteDirection *dir)
Free internal data of a route direction.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
Unique identifier for the connection that uses this route.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct RouteDirection prev
Information about the previous hop on this route.
struct CadetPeer * hop
Target peer.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct RouteDirection next
Information about the next hop on this route.
struct GNUNET_ShortHashCode connection_of_tunnel
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
const struct GNUNET_PeerIdentity * GCP_get_id(struct CadetPeer *cp)
Obtain the peer identity for a struct CadetPeer.
static struct GNUNET_CONTAINER_MultiShortmap * routes
Routes on which this peer is an intermediate.
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
targetwhere to send the message
cidconnection identifier to use
peer1one of the peers where a link is broken
peer2another one of the peers where a link is broken

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

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().

555 {
556  struct GNUNET_MQ_Envelope *env;
558 
559  if (NULL == target->mqm)
560  return; /* Can't send notification, connection is down! */
562  "Notifying %s about BROKEN route at %s-%s of connection %s\n",
563  GCP_2s (target->hop),
564  GNUNET_i2s (peer1),
565  GNUNET_i2s2 (peer2),
567 
569  bm->cid = *cid;
570  if (NULL != peer1)
571  bm->peer1 = *peer1;
572  if (NULL != peer2)
573  bm->peer2 = *peer2;
574  GCP_request_mq_cancel (target->mqm, env);
575  target->mqm = NULL;
576 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
const char * GNUNET_i2s2(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG(level,...)
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_PeerIdentity peer2
ID of the endpoint.
const char * GCP_2s(const struct CadetPeer *cp)
Get the static string for a peer ID.
struct CadetPeer * hop
Target peer.
Message for notifying a disconnection in a path.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
struct GNUNET_PeerIdentity peer1
ID of the endpoint.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GCP_MessageQueueManager * mqm
Message queue manager for hop.
void GCP_request_mq_cancel(struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *last_env)
Stops message queue change notifications.
struct GNUNET_ShortHashCode connection_of_tunnel
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
Notify that a connection is no longer valid.
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
clsNULL

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

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, and send_broken().

Referenced by handle_connection_create().

588 {
589  struct CadetRoute *r;
590  struct GNUNET_TIME_Relative linger;
591  struct GNUNET_TIME_Absolute exp;
592 
593  timeout_task = NULL;
595  while (NULL != (r = GNUNET_CONTAINER_heap_peek (route_heap)))
596  {
597  exp = GNUNET_TIME_absolute_add (r->last_use, linger);
598  if (0 != GNUNET_TIME_absolute_get_remaining (exp).rel_value_us)
599  {
600  /* Route not yet timed out, wait until it does. */
601  timeout_task = GNUNET_SCHEDULER_add_at (exp, &timeout_cb, NULL);
602  return;
603  }
605  "Sending BROKEN due to timeout (%s was last use, %s linger)\n",
608  send_broken (&r->prev, &r->cid, NULL, NULL);
609  send_broken (&r->next, &r->cid, NULL, NULL);
610  destroy_route (r);
611  }
612  /* No more routes left, so no need for a #timeout_task */
613 }
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:395
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
Unique identifier for the connection that uses this route.
static void destroy_route(struct CadetRoute *route)
Destroy our state for route.
struct RouteDirection prev
Information about the previous hop on this route.
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:702
Description of a segment of a struct CadetConnection at the intermediate peers.
struct GNUNET_TIME_Absolute last_use
When was this route last in use?
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
struct RouteDirection next
Information about the next hop on this 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 struct GNUNET_CONTAINER_Heap * route_heap
Heap of routes, MIN-sorted by last activity.
static struct GNUNET_SCHEDULER_Task * timeout_task
Task to timeout routes.
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative keepalive_period
How frequently do we send KEEPALIVE messages on idle connections?
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
Time for absolute times used by GNUnet, in microseconds.
static void timeout_cb(void *cls)
Function called to check if any routes have timed out, and if so, to clean them up.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:757
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run at the specified time.
Definition: scheduler.c:1246
Time for relative time used by GNUnet, in microseconds.
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
clsthe struct RouteDirection
availableGNUNET_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.

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

Referenced by dir_init().

630 {
631  struct RouteDirection *dir = cls;
632  struct CadetRoute *route = dir->my_route;
633  struct RouteDirection *odir;
634 
635  if (GNUNET_YES == ready)
636  {
637  struct GNUNET_MQ_Envelope *env;
638 
639  dir->is_ready = GNUNET_YES;
640  if (NULL != (env = dir->env_head))
641  {
642  GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env);
643  cur_buffers--;
644  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
645  lower_rung (dir);
646  dir->is_ready = GNUNET_NO;
647  GCP_send (dir->mqm, env);
648  }
649  return;
650  }
651  odir = (dir == &route->next) ? &route->prev : &route->next;
652  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending BROKEN due to MQ going down\n");
653  send_broken (&route->next, &route->cid, GCP_get_id (odir->hop), &my_full_id);
654  destroy_route (route);
655 }
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
struct GNUNET_MQ_Envelope * env_head
Head of DLL of envelopes we have in the buffer for this direction.
Information we keep per direction for a route.
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
static unsigned long long cur_buffers
Current number of envelopes we have buffered at this peer.
void GCP_send(struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *env)
Send the message in env to cp.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
Unique identifier for the connection that uses this route.
struct CadetRoute * my_route
Route this direction is part of.
static void destroy_route(struct CadetRoute *route)
Destroy our state for route.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct RouteDirection prev
Information about the previous hop on this route.
Description of a segment of a struct CadetConnection at the intermediate peers.
struct CadetPeer * hop
Target peer.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct RouteDirection next
Information about the next hop on this route.
void GNUNET_MQ_dll_remove(struct GNUNET_MQ_Envelope **env_head, struct GNUNET_MQ_Envelope **env_tail, struct GNUNET_MQ_Envelope *env)
Remove env from the envelope DLL starting at env_head.
Definition: mq.c:1212
static void lower_rung(struct RouteDirection *dir)
Lower the rung in which dir is by 1.
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.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GCP_MessageQueueManager * mqm
Message queue manager for hop.
#define GNUNET_log(kind,...)
int is_ready
Is mqm currently ready for transmission?
struct GNUNET_MQ_Envelope * env_tail
Tail of DLL of envelopes we have in the buffer for this direction.
const struct GNUNET_PeerIdentity * GCP_get_id(struct CadetPeer *cp)
Obtain the peer identity for a struct CadetPeer.
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
routeroute the direction belongs to
dirdirection to initialize
hopnext hop on in the dir

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

References dir_ready_cb(), GCP_request_mq(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_YES, RouteDirection::hop, RouteDirection::is_ready, RouteDirection::mqm, RouteDirection::my_route, Rung::rd_head, Rung::rd_tail, RouteDirection::rung, and rung_head.

Referenced by handle_connection_create().

669 {
670  dir->hop = hop;
671  dir->my_route = route;
672  dir->mqm = GCP_request_mq (hop, &dir_ready_cb, dir);
674  dir->rung = rung_head;
676 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct CadetRoute * my_route
Route this direction is part of.
struct RouteDirection * rd_head
DLL of route directions with a number of buffer entries matching this rung.
struct CadetPeer * hop
Target peer.
static struct Rung * rung_head
DLL of rungs, with the head always point to a rung of route directions with no messages in the queue...
static void dir_ready_cb(void *cls, int ready)
Function called when the message queue to the previous hop becomes available/unavailable.
struct RouteDirection * rd_tail
DLL of route directions with a number of buffer entries matching this rung.
struct GCP_MessageQueueManager * mqm
Message queue manager for hop.
struct Rung * rung
Rung of this route direction (matches length of the buffer DLL).
int is_ready
Is mqm currently ready for transmission?
struct GCP_MessageQueueManager * GCP_request_mq(struct CadetPeer *cp, GCP_MessageQueueNotificationCallback cb, void *cb_cls)
Start message queue change notifications.
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
targetwho should receive the message
cididentifier of the connection/route that failed
failure_atneighbour with which we failed to route, or NULL.

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

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().

694 {
695  struct GNUNET_MQ_Envelope *env;
697 
699  bm->cid = *cid;
700  bm->peer1 = my_full_id;
701  if (NULL != failure_at)
702  bm->peer2 = *failure_at;
703  GCP_send_ooo (target, env);
704 }
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_PeerIdentity peer2
ID of the endpoint.
void GCP_send_ooo(struct CadetPeer *cp, struct GNUNET_MQ_Envelope *env)
Send the message in env to cp, overriding queueing logic.
Message for notifying a disconnection in a path.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
struct GNUNET_PeerIdentity peer1
ID of the endpoint.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
Notify that a connection is no longer valid.
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
clsClosure (CadetPeer for neighbor that sent the message).
msgMessage itself.

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

References GNUNET_TIME_Absolute::abs_value_us, CADET_TUNNEL_KEY_OK, CADET_TUNNEL_KEY_UNINITIALIZED, GNUNET_CADET_ConnectionCreateMessage::cid, 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, GNUNET_CADET_ConnectionCreateMessage::has_monotime, GNUNET_CADET_ConnectionCreateMessage::header, CadetRoute::hn, keepalive_period, CadetRoute::last_use, LOG, map, max_routes, GNUNET_CADET_ConnectionCreateMessage::monotime, my_full_id, Rung::next, CadetRoute::next, CadetRoute::prev, route_message(), send_broken_without_mqm(), size, GNUNET_MessageHeader::size, stats, t, and timeout_cb().

717 {
718  struct CadetPeer *sender = cls;
719  struct CadetPeer *next;
720  const struct GNUNET_PeerIdentity *pids =
721  (const struct GNUNET_PeerIdentity *) &msg[1];
722  struct CadetRoute *route;
723  uint16_t size = ntohs (msg->header.size) - sizeof(*msg);
724  unsigned int path_length;
725  unsigned int off;
726  struct CadetTunnel *t;
727 
728  path_length = size / sizeof(struct GNUNET_PeerIdentity);
729  if (0 == path_length)
730  {
732  "Dropping CADET_CONNECTION_CREATE with empty path\n");
733  GNUNET_break_op (0);
734  return;
735  }
737  "Handling CADET_CONNECTION_CREATE from %s for CID %s with %u hops\n",
738  GCP_2s (sender),
740  path_length);
741  /* Check for loops */
742  {
744 
745  map = GNUNET_CONTAINER_multipeermap_create (path_length * 2, GNUNET_YES);
746  GNUNET_assert (NULL != map);
747  for (unsigned int i = 0; i < path_length; i++)
748  {
750  "CADET_CONNECTION_CREATE has peer %s at offset %u\n",
751  GNUNET_i2s (&pids[i]),
752  i);
754  map,
755  &pids[i],
756  NULL,
758  {
759  /* bogus request */
762  "Dropping CADET_CONNECTION_CREATE with cyclic path\n");
763  GNUNET_break_op (0);
764  return;
765  }
766  }
768  }
769  /* Initiator is at offset 0, find us */
770  for (off = 1; off < path_length; off++)
771  if (0 == GNUNET_memcmp (&my_full_id, &pids[off]))
772  break;
773  if (off == path_length)
774  {
776  "Dropping CADET_CONNECTION_CREATE without us in the path\n");
777  GNUNET_break_op (0);
778  return;
779  }
780  /* Check previous hop */
781  if (sender != GCP_get (&pids[off - 1], GNUNET_NO))
782  {
784  "Dropping CADET_CONNECTION_CREATE without sender at previous hop in the path\n");
785  GNUNET_break_op (0);
786  return;
787  }
788  if (NULL != (route = get_route (&msg->cid)))
789  {
790  /* Duplicate CREATE, pass it on, previous one might have been lost! */
791 
793  "Passing on duplicate CADET_CONNECTION_CREATE message on connection %s\n",
795  route_message (sender,
796  &msg->cid,
797  &msg->header,
800  return;
801  }
802  if (off == path_length - 1)
803  {
804  /* We are the destination, create connection */
805  struct CadetConnection *cc;
806  struct CadetPeerPath *path;
807  struct CadetPeer *origin;
808 
809  cc = GCC_lookup (&msg->cid);
810  if (NULL != cc)
811  {
813  "Received duplicate CADET_CONNECTION_CREATE message on connection %s\n",
816  return;
817  }
818 
819  origin = GCP_get (&pids[0], GNUNET_YES);
821  "I am destination for CADET_CONNECTION_CREATE message from %s for connection %s, building inverse path\n",
822  GCP_2s (origin),
824  path = GCPP_get_path_from_route (path_length - 1, pids);
825  t = GCP_get_tunnel (origin, GNUNET_YES);
826 
827  // Check for CADET state in case the other side has lost the tunnel (xrs,t3ss)
828  if ((GNUNET_YES == msg->has_monotime) &&
829  (GNUNET_YES == GCP_check_and_update_monotime (origin, msg->monotime)) &&
830  (GNUNET_OK == GCP_check_monotime_sig (origin, msg)) &&
832  {
834  }
835 
836  if (GNUNET_OK !=
838  &msg->cid,
839  path))
840  {
841  /* Send back BROKEN: duplicate connection on the same path,
842  we will use the other one. */
844  "Received CADET_CONNECTION_CREATE from %s for %s, but %s already has a connection. Sending BROKEN\n",
845  GCP_2s (sender),
847  GCPP_2s (path));
848  send_broken_without_mqm (sender, &msg->cid, NULL);
849  return;
850  }
851  return;
852  }
853  /* We are merely a hop on the way, check if we can support the route */
854  next = GCP_get (&pids[off + 1], GNUNET_NO);
855  if ((NULL == next) || (GNUNET_NO == GCP_has_core_connection (next)))
856  {
857  /* unworkable, send back BROKEN notification */
859  "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is down. Sending BROKEN\n",
860  GCP_2s (sender),
862  GNUNET_i2s (&pids[off + 1]),
863  off + 1);
864  send_broken_without_mqm (sender, &msg->cid, &pids[off + 1]);
865  return;
866  }
868  {
870  "Received CADET_CONNECTION_CREATE from %s for %s. We have reached our route limit. Sending BROKEN\n",
871  GCP_2s (sender),
873  send_broken_without_mqm (sender, &msg->cid, &pids[off - 1]);
874  return;
875  }
876 
877  /* Workable route, create routing entry */
879  "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is up. Creating route\n",
880  GCP_2s (sender),
882  GNUNET_i2s (&pids[off + 1]),
883  off + 1);
884  route = GNUNET_new (struct CadetRoute);
885  route->cid = msg->cid;
887  dir_init (&route->prev, route, sender);
888  dir_init (&route->next, route, next);
891  routes,
892  &route->cid.connection_of_tunnel,
893  route,
896  "# routes",
898  GNUNET_NO);
900  route,
901  route->last_use.abs_value_us);
902  if (NULL == timeout_task)
903  timeout_task =
906  3),
907  &timeout_cb,
908  NULL);
909  /* also pass CREATE message along to next hop */
910  route_message (sender,
911  &msg->cid,
912  &msg->header,
914 }
struct GNUNET_TIME_AbsoluteNBO monotime
This monotonic time is set, if a peer likes to trigger a KX, but is not the peer that should start th...
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
static void dir_init(struct RouteDirection *dir, struct CadetRoute *route, struct CadetPeer *hop)
Initialize one of the directions of a route.
Peer description.
Low-level connection to a destination.
enum CadetTunnelEState GCT_get_estate(struct CadetTunnel *t)
Get the encryption state of a tunnel.
struct CadetTunnel * GCP_get_tunnel(struct CadetPeer *cp, int create)
Get the tunnel towards a peer.
unsigned int GNUNET_CONTAINER_multishortmap_size(const struct GNUNET_CONTAINER_MultiShortmap *map)
Get the number of key-value pairs in the map.
struct GNUNET_CONTAINER_HeapNode * GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap, void *element, GNUNET_CONTAINER_HeapCostType cost)
Inserts a new element into the heap.
struct GNUNET_CONTAINER_HeapNode * hn
Position of this route in the route_heap.
static unsigned long long max_routes
Maximum number of concurrent routes this peer will support.
#define LOG(level,...)
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE.
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct GNUNET_SCHEDULER_Task * t
Main task.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
uint64_t abs_value_us
The actual value.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GCP_check_monotime_sig(struct CadetPeer *peer, const struct GNUNET_CADET_ConnectionCreateMessage *msg)
Checking the signature for a monotime of a GNUNET_CADET_ConnectionCreateMessage.
static struct GNUNET_CONTAINER_MultiPeerMap * map
Handle to the map used to store old latency values for peers.
const char * GCP_2s(const struct CadetPeer *cp)
Get the static string for a peer ID.
Flag to indicate that low latency is important.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
Unique identifier for the connection that uses this route.
const char * GCPP_2s(struct CadetPeerPath *path)
Convert a path to a human-readable string.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
static struct CadetRoute * get_route(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Get the route corresponding to a hash.
struct CadetPeerPath * GCPP_get_path_from_route(unsigned int path_length, const struct GNUNET_PeerIdentity *pids)
We got an incoming connection, obtain the corresponding path.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
int GCT_add_inbound_connection(struct CadetTunnel *t, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, struct CadetPeerPath *path)
Add a connection to the tunnel.
struct RouteDirection prev
Information about the previous hop on this route.
Description of a segment of a struct CadetConnection at the intermediate peers.
struct GNUNET_TIME_Absolute last_use
When was this route last in use?
int GNUNET_CONTAINER_multishortmap_put(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
Internal representation of the hash map.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct RouteDirection next
Information about the next hop on this route.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
int has_monotime
This flag indicates the peer sending the connection create meassage likes to trigger a KX handshake...
void GCC_handle_duplicate_create(struct CadetConnection *cc)
We got a GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE for a connection that we already have...
Struct containing all information regarding a tunnel to a peer.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
static unsigned int size
Size of the "table".
Definition: peer.c:67
Handshake completed: session key available.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
int GCP_has_core_connection(struct CadetPeer *cp)
Test if cp has a core-level connection.
void GCT_change_estate(struct CadetTunnel *t, enum CadetTunnelEState state)
Change the tunnel encryption state.
struct CadetConnection * GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Lookup a connection by its identifier.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
The identity of the host (wraps the signing key of the peer).
static struct GNUNET_CONTAINER_Heap * route_heap
Heap of routes, MIN-sorted by last activity.
static struct GNUNET_SCHEDULER_Task * timeout_task
Task to timeout routes.
struct CadetPeer * GCP_get(const struct GNUNET_PeerIdentity *peer_id, int create)
Retrieve the CadetPeer stucture associated with the peer.
int GCP_check_and_update_monotime(struct CadetPeer *peer, struct GNUNET_TIME_AbsoluteNBO monotime)
Checking if a monotime value is newer than the last monotime value received from a peer...
struct GNUNET_TIME_Relative keepalive_period
How frequently do we send KEEPALIVE messages on idle connections?
Uninitialized status, we need to send KX.
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 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 timeout_cb(void *cls)
Function called to check if any routes have timed out, and if so, to clean them up.
Highest priority, control traffic (i.e.
Information regarding a possible path to reach a peer.
struct GNUNET_ShortHashCode connection_of_tunnel
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static struct GNUNET_CONTAINER_MultiShortmap * routes
Routes on which this peer is an intermediate.
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
clsClosure (CadetPeer for neighbor that sent the message).
msgMessage itself.

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

References GNUNET_CADET_ConnectionCreateAckMessage::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, 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(), GNUNET_CADET_ConnectionCreateAckMessage::header, len, LOG, peer, and route_message().

927 {
928  struct CadetPeer *peer = cls;
929  struct CadetConnection *cc;
930 
931  /* First, check if ACK belongs to a connection that ends here. */
932  cc = GCC_lookup (&msg->cid);
933  if (NULL != cc)
934  {
935  /* verify ACK came from the right direction */
936  unsigned int len;
937  struct CadetPeerPath *path = GCC_get_path (cc, &len);
938 
939  if (peer != GCPP_get_peer_at_offset (path, 0))
940  {
941  /* received ACK from unexpected direction, ignore! */
942  GNUNET_break_op (0);
943  return;
944  }
946  "Received CONNECTION_CREATE_ACK for connection %s.\n",
949  return;
950  }
951 
952  /* We're just an intermediary peer, route the message along its path */
953  route_message (peer,
954  &msg->cid,
955  &msg->header,
957 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
Peer description.
Low-level connection to a destination.
#define LOG(level,...)
void GCC_handle_connection_create_ack(struct CadetConnection *cc)
A GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK was received for this connection, implying that the end-to-end connection is up.
Flag to indicate that low latency is important.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct CadetPeerPath * GCC_get_path(struct CadetConnection *cc, unsigned int *off)
Obtain the path used by this connection.
struct CadetConnection * GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Lookup a connection by its identifier.
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
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.
Highest priority, control traffic (i.e.
Information regarding a possible path to reach a peer.
struct GNUNET_ShortHashCode connection_of_tunnel
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
clsClosure (CadetPeer for neighbor that sent the message).
msgMessage itself.
Deprecated:
duplicate logic with #handle_destroy(); dedup!

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

References GNUNET_CADET_ConnectionBrokenMessage::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, 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(), GNUNET_CADET_ConnectionBrokenMessage::header, len, LOG, peer, and route_message().

971 {
972  struct CadetPeer *peer = cls;
973  struct CadetConnection *cc;
974  struct CadetRoute *route;
975 
976  /* First, check if message belongs to a connection that ends here. */
977  cc = GCC_lookup (&msg->cid);
978  if (NULL != cc)
979  {
980  /* verify message came from the right direction */
981  unsigned int len;
982  struct CadetPeerPath *path = GCC_get_path (cc, &len);
983 
984  if (peer != GCPP_get_peer_at_offset (path, 0))
985  {
986  /* received message from unexpected direction, ignore! */
987  GNUNET_break_op (0);
988  return;
989  }
991  "Received CONNECTION_BROKEN for connection %s. Destroying it.\n",
994 
995  /* FIXME: also destroy the path up to the specified link! */
996  return;
997  }
998 
999  /* We're just an intermediary peer, route the message along its path */
1000  route_message (peer,
1001  &msg->cid,
1002  &msg->header,
1004  route = get_route (&msg->cid);
1005  if (NULL != route)
1006  destroy_route (route);
1007  /* FIXME: also destroy paths we MAY have up to the specified link! */
1008 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
Peer description.
Low-level connection to a destination.
#define LOG(level,...)
void GCC_destroy_without_core(struct CadetConnection *cc)
Destroy a connection, called when the CORE layer is already done (i.e.
Flag to indicate that low latency is important.
static void destroy_route(struct CadetRoute *route)
Destroy our state for route.
static struct CadetRoute * get_route(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Get the route corresponding to a hash.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Description of a segment of a struct CadetConnection at the intermediate peers.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct CadetPeerPath * GCC_get_path(struct CadetConnection *cc, unsigned int *off)
Obtain the path used by this connection.
struct CadetConnection * GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Lookup a connection by its identifier.
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
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.
Highest priority, control traffic (i.e.
Information regarding a possible path to reach a peer.
struct GNUNET_ShortHashCode connection_of_tunnel
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
clsClosure (CadetPeer for neighbor that sent the message).
msgMessage itself.

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

References GNUNET_CADET_ConnectionDestroyMessage::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, 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(), GNUNET_CADET_ConnectionDestroyMessage::header, len, LOG, peer, and route_message().

1021 {
1022  struct CadetPeer *peer = cls;
1023  struct CadetConnection *cc;
1024  struct CadetRoute *route;
1025 
1026  /* First, check if message belongs to a connection that ends here. */
1027  cc = GCC_lookup (&msg->cid);
1028  if (NULL != cc)
1029  {
1030  /* verify message came from the right direction */
1031  unsigned int len;
1032  struct CadetPeerPath *path = GCC_get_path (cc, &len);
1033 
1034  if (peer != GCPP_get_peer_at_offset (path, 0))
1035  {
1036  /* received message from unexpected direction, ignore! */
1037  GNUNET_break_op (0);
1038  return;
1039  }
1041  "Received CONNECTION_DESTROY for connection %s. Destroying connection.\n",
1043 
1045  return;
1046  }
1047 
1048  /* We're just an intermediary peer, route the message along its path */
1050  "Received CONNECTION_DESTROY for connection %s. Destroying route.\n",
1052  route_message (peer,
1053  &msg->cid,
1054  &msg->header,
1056  route = get_route (&msg->cid);
1057  if (NULL != route)
1058  destroy_route (route);
1059 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
Peer description.
Low-level connection to a destination.
#define LOG(level,...)
void GCC_destroy_without_core(struct CadetConnection *cc)
Destroy a connection, called when the CORE layer is already done (i.e.
Flag to indicate that low latency is important.
static void destroy_route(struct CadetRoute *route)
Destroy our state for route.
static struct CadetRoute * get_route(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Get the route corresponding to a hash.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Description of a segment of a struct CadetConnection at the intermediate peers.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct CadetPeerPath * GCC_get_path(struct CadetConnection *cc, unsigned int *off)
Obtain the path used by this connection.
struct CadetConnection * GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Lookup a connection by its identifier.
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
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.
Highest priority, control traffic (i.e.
Information regarding a possible path to reach a peer.
struct GNUNET_ShortHashCode connection_of_tunnel
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY.
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
clsClosure (CadetPeer for neighbor that sent the message).
msgMessage itself.

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

References GNUNET_CADET_TunnelKeyExchangeMessage::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, GNUNET_CADET_TunnelKeyExchangeMessage::ephemeral_key, 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(), GNUNET_CADET_TunnelKeyExchangeMessage::header, len, LOG, peer, and route_message().

1071 {
1072  struct CadetPeer *peer = cls;
1073  struct CadetConnection *cc;
1074 
1075  /* First, check if message belongs to a connection that ends here. */
1077  "Routing KX with ephemeral %s on CID %s\n",
1078  GNUNET_e2s (&msg->ephemeral_key),
1080 
1081 
1082  cc = GCC_lookup (&msg->cid);
1083  if (NULL != cc)
1084  {
1085  /* verify message came from the right direction */
1086  unsigned int len;
1087  struct CadetPeerPath *path = GCC_get_path (cc, &len);
1088 
1089  if (peer != GCPP_get_peer_at_offset (path, 0))
1090  {
1091  /* received message from unexpected direction, ignore! */
1092  GNUNET_break_op (0);
1093  return;
1094  }
1095  GCC_handle_kx (cc, msg);
1096  return;
1097  }
1098 
1099  /* We're just an intermediary peer, route the message along its path */
1100  route_message (peer,
1101  &msg->cid,
1102  &msg->header,
1104 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
Peer description.
Low-level connection to a destination.
#define LOG(level,...)
void GCC_handle_kx(struct CadetConnection *cc, const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg)
Handle KX message.
Flag to indicate that low latency is important.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct CadetPeerPath * GCC_get_path(struct CadetConnection *cc, unsigned int *off)
Obtain the path used by this connection.
struct CadetConnection * GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Lookup a connection by its identifier.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX or GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH as part of stru...
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
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.
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key
Sender&#39;s ephemeral public ECC key encoded in a format suitable for network transmission, as created using &#39;gcry_sexp_sprint&#39;.
Highest priority, control traffic (i.e.
const char * GNUNET_e2s(const struct GNUNET_CRYPTO_EcdhePublicKey *p)
Convert a public key value to a string (for printing debug messages).
Information regarding a possible path to reach a peer.
struct GNUNET_ShortHashCode connection_of_tunnel
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
clsClosure (CadetPeer for neighbor that sent the message).
msgMessage itself.

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

References GNUNET_CADET_TunnelKeyExchangeMessage::cid, 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, GNUNET_CADET_TunnelKeyExchangeMessage::header, GNUNET_CADET_TunnelKeyExchangeAuthMessage::kx, len, peer, and route_message().

1117 {
1118  struct CadetPeer *peer = cls;
1119  struct CadetConnection *cc;
1120 
1121  /* First, check if message belongs to a connection that ends here. */
1122  cc = GCC_lookup (&msg->kx.cid);
1123  if (NULL != cc)
1124  {
1125  /* verify message came from the right direction */
1126  unsigned int len;
1127  struct CadetPeerPath *path = GCC_get_path (cc, &len);
1128 
1129  if (peer != GCPP_get_peer_at_offset (path, 0))
1130  {
1131  /* received message from unexpected direction, ignore! */
1132  GNUNET_break_op (0);
1133  return;
1134  }
1135  GCC_handle_kx_auth (cc, msg);
1136  return;
1137  }
1138 
1139  /* We're just an intermediary peer, route the message along its path */
1140  route_message (peer,
1141  &msg->kx.cid,
1142  &msg->kx.header,
1144 }
Peer description.
Low-level connection to a destination.
struct GNUNET_CADET_TunnelKeyExchangeMessage kx
Message header with key material.
Flag to indicate that low latency is important.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct CadetPeerPath * GCC_get_path(struct CadetConnection *cc, unsigned int *off)
Obtain the path used by this connection.
struct CadetConnection * GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Lookup a connection by its identifier.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX or GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH as part of stru...
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
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.
void GCC_handle_kx_auth(struct CadetConnection *cc, const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
Handle KX_AUTH message.
Highest priority, control traffic (i.e.
Information regarding a possible path to reach a peer.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
clsClosure (unused).
msgMessage to check.
Returns
GNUNET_YES if size is correct, GNUNET_NO otherwise.

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

References GNUNET_YES.

1158 {
1159  return GNUNET_YES;
1160 }

◆ 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
clsClosure (CadetPeer for neighbor that sent the message).
msgMessage itself.

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

References GNUNET_CADET_TunnelEncryptedMessage::cid, GCC_get_path(), GCC_handle_encrypted(), GCC_lookup(), GCPP_get_peer_at_offset(), GNUNET_break_op, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_CADET_TunnelEncryptedMessage::header, len, peer, and route_message().

1172 {
1173  struct CadetPeer *peer = cls;
1174  struct CadetConnection *cc;
1175 
1176  /* First, check if message belongs to a connection that ends here. */
1177  cc = GCC_lookup (&msg->cid);
1178  if (NULL != cc)
1179  {
1180  /* verify message came from the right direction */
1181  unsigned int len;
1182  struct CadetPeerPath *path = GCC_get_path (cc, &len);
1183 
1184  if (peer != GCPP_get_peer_at_offset (path, 0))
1185  {
1186  /* received message from unexpected direction, ignore! */
1187  GNUNET_break_op (0);
1188  return;
1189  }
1190  GCC_handle_encrypted (cc, msg);
1191  return;
1192  }
1193  /* We're just an intermediary peer, route the message along its path */
1194  route_message (peer, &msg->cid, &msg->header, GNUNET_MQ_PRIO_BEST_EFFORT);
1195 }
Peer description.
Low-level connection to a destination.
Best-effort traffic (i.e.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct CadetPeerPath * GCC_get_path(struct CadetConnection *cc, unsigned int *off)
Obtain the path used by this connection.
struct CadetConnection * GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Lookup a connection by its identifier.
void GCC_handle_encrypted(struct CadetConnection *cc, const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
Handle encrypted message.
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
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.
Information regarding a possible path to reach a peer.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
clsclosure
my_identityID of this peer, NULL if we failed

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

References GNUNET_break, GNUNET_memcmp, and my_full_id.

Referenced by GCO_init().

1212 {
1213  if (NULL == my_identity)
1214  {
1215  GNUNET_break (0);
1216  return;
1217  }
1218  GNUNET_break (0 == GNUNET_memcmp (my_identity, &my_full_id));
1219 }
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
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
clsclosure
peerpeer identity this notification is about

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

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

Referenced by GCO_init().

1232 {
1233  struct CadetPeer *cp;
1234 
1236  "CORE connection to peer %s was established.\n",
1237  GNUNET_i2s (peer));
1238  cp = GCP_get (peer, GNUNET_YES);
1239  GCP_set_mq (cp, mq);
1240  return cp;
1241 }
Peer description.
#define LOG(level,...)
void GCP_set_mq(struct CadetPeer *cp, struct GNUNET_MQ_Handle *mq)
Set the message queue to mq for peer cp and notify watchers.
struct CadetPeer * GCP_get(const struct GNUNET_PeerIdentity *peer_id, int create)
Retrieve the CadetPeer stucture associated with the peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
clsclosure
peerpeer identity this notification is about

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

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

Referenced by GCO_init().

1254 {
1255  struct CadetPeer *cp = peer_cls;
1256 
1258  "CORE connection to peer %s went down.\n",
1259  GNUNET_i2s (peer));
1260  GCP_set_mq (cp, NULL);
1261 }
Peer description.
#define LOG(level,...)
void GCP_set_mq(struct CadetPeer *cp, struct GNUNET_MQ_Handle *mq)
Set the message queue to mq for peer cp and notify watchers.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
cConfiguration.

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

References connection_create(), 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, max_buffers, and max_routes.

Referenced by run().

1271 {
1276  NULL),
1277  GNUNET_MQ_hd_fixed_size (connection_create_ack,
1280  NULL),
1281  GNUNET_MQ_hd_fixed_size (connection_broken,
1284  NULL),
1285  GNUNET_MQ_hd_fixed_size (connection_destroy,
1288  NULL),
1289  GNUNET_MQ_hd_fixed_size (tunnel_kx,
1292  NULL),
1293  GNUNET_MQ_hd_fixed_size (tunnel_kx_auth,
1296  NULL),
1297  GNUNET_MQ_hd_var_size (tunnel_encrypted,
1300  NULL),
1301  GNUNET_MQ_handler_end () };
1302 
1304  "CADET",
1305  "MAX_ROUTES",
1306  &max_routes))
1307  max_routes = 5000;
1309  "CADET",
1310  "MAX_MSGS_QUEUE",
1311  &max_buffers))
1312  max_buffers = 10000;
1316  NULL,
1317  &core_init_cb,
1318  &core_connect_cb,
1320  handlers);
1321 }
Axolotl-encrypted tunnel message with application payload.
#define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED
Axolotl encrypted data.
static unsigned long long max_buffers
Maximum number of envelopes we will buffer at this peer.
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
Message to destroy a connection.
static unsigned long long max_routes
Maximum number of concurrent routes this peer will support.
static void core_disconnect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
Method called whenever a peer disconnects.
Message for ack&#39;ing a connection.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static struct CadetConnection * connection_create(struct CadetPeer *destination, struct CadetPeerPath *path, unsigned int off, struct CadetTConnection *ct, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, enum CadetConnectionState init_state, GCC_ReadyCallback ready_cb, void *ready_cb_cls)
Create a connection to destination via path and notify cb whenever we are ready for more data...
static void * core_connect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
Message for a Key eXchange for a tunnel, with authentication.
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE
Request the creation of a connection.
Message for notifying a disconnection in a path.
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK
Send origin an ACK that the connection is complete.
struct GNUNET_CONTAINER_MultiShortmap * GNUNET_CONTAINER_multishortmap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
Heap with the minimum cost at the root.
Message handler for a specific message type.
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).
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:692
struct GNUNET_CONTAINER_Heap * GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
Create a new heap.
static struct GNUNET_CONTAINER_Heap * route_heap
Heap of routes, MIN-sorted by last activity.
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY
Request the destuction of a connection.
Message for a Key eXchange for a tunnel.
#define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH
Axolotl key exchange response with authentication.
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
Notify that a connection is no longer valid.
Message for cadet connection creation.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static struct GNUNET_CORE_Handle * core
Handle to the CORE service.
#define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX
Axolotl key exchange.
static struct GNUNET_CONTAINER_MultiShortmap * routes
Routes on which this peer is an intermediate.
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 1328 of file gnunet-service-cadet_core.c.

References GNUNET_assert, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_CORE_disconnect(), and GNUNET_SCHEDULER_cancel().

Referenced by shutdown_task().

1329 {
1330  if (NULL != core)
1331  {
1333  core = NULL;
1334  }
1337  routes = NULL;
1339  route_heap = NULL;
1340  if (NULL != timeout_task)
1341  {
1343  timeout_task = NULL;
1344  }
1345 }
unsigned int GNUNET_CONTAINER_multishortmap_size(const struct GNUNET_CONTAINER_MultiShortmap *map)
Get the number of key-value pairs in the map.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:730
void GNUNET_CONTAINER_multishortmap_destroy(struct GNUNET_CONTAINER_MultiShortmap *map)
Destroy a hash map.
static struct GNUNET_CONTAINER_Heap * route_heap
Heap of routes, MIN-sorted by last activity.
static struct GNUNET_SCHEDULER_Task * timeout_task
Task to timeout routes.
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.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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 182 of file gnunet-service-cadet_core.c.

Referenced by inittransport_smtp().

◆ routes

struct GNUNET_CONTAINER_MultiShortmap* routes
static

Routes on which this peer is an intermediate.

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

◆ route_heap

struct GNUNET_CONTAINER_Heap* route_heap
static

Heap of routes, MIN-sorted by last activity.

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

◆ rung_zero

struct Rung rung_zero
static

Rung zero (always pointed to by rung_head).

Definition at line 197 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 203 of file gnunet-service-cadet_core.c.

Referenced by dir_init().

◆ rung_tail

struct Rung* rung_tail = &rung_zero
static

Tail of the rung_head DLL.

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

Referenced by discard_all_from_rung_tail().

◆ max_routes

unsigned long long max_routes
static

Maximum number of concurrent routes this peer will support.

Definition at line 213 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 218 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 223 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 228 of file gnunet-service-cadet_core.c.