GNUnet  0.10.x
Data Structures | Macros | Functions | Variables
gnunet-service-cadet.c File Reference

GNUnet CADET service with encryption. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "cadet.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-cadet.h"
#include "gnunet-service-cadet_channel.h"
#include "gnunet-service-cadet_connection.h"
#include "gnunet-service-cadet_core.h"
#include "gnunet-service-cadet_dht.h"
#include "gnunet-service-cadet_hello.h"
#include "gnunet-service-cadet_tunnels.h"
#include "gnunet-service-cadet_peer.h"
#include "gnunet-service-cadet_paths.h"
Include dependency graph for gnunet-service-cadet.c:

Go to the source code of this file.

Data Structures

struct  CadetClient
 Struct containing information about a client of the service. More...
 

Macros

#define LOG(level, ...)   GNUNET_log (level,__VA_ARGS__)
 

Functions

void GSC_send_to_client (struct CadetClient *c, struct GNUNET_MQ_Envelope *env)
 Send a message to a client. More...
 
const char * GSC_2s (struct CadetClient *c)
 Return identifier for a client as a string. More...
 
static struct CadetChannellookup_channel (struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
 Lookup channel of client c by ccn. More...
 
static struct GNUNET_CADET_ClientChannelNumber client_get_next_ccn (struct CadetClient *c)
 Obtain the next LID to use for incoming connections to the given client. More...
 
struct GNUNET_CADET_ClientChannelNumber GSC_bind (struct CadetClient *c, struct CadetChannel *ch, struct CadetPeer *dest, const struct GNUNET_HashCode *port, uint32_t options)
 Bind incoming channel to this client, and notify client about incoming connection. More...
 
static int destroy_tunnels_now (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Callback invoked on all peers to destroy all tunnels that may still exist. More...
 
static int destroy_paths_now (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Callback invoked on all peers to destroy all tunnels that may still exist. More...
 
static void shutdown_rest ()
 Shutdown everything once the clients have disconnected. More...
 
static void shutdown_task (void *cls)
 Task run during shutdown. More...
 
static int bind_loose_channel (void *cls, const struct GNUNET_HashCode *port, void *value)
 We had a remote connection value to port h_port before client cls opened port port. More...
 
static void handle_port_open (void *cls, const struct GNUNET_CADET_PortMessage *pmsg)
 Handle port open request. More...
 
static void handle_port_close (void *cls, const struct GNUNET_CADET_PortMessage *pmsg)
 Handler for port close requests. More...
 
static void handle_channel_create (void *cls, const struct GNUNET_CADET_LocalChannelCreateMessage *tcm)
 Handler for requests for us creating a new channel to another peer and port. More...
 
static void handle_channel_destroy (void *cls, const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
 Handler for requests of destroying an existing channel. More...
 
static int check_local_data (void *cls, const struct GNUNET_CADET_LocalData *msg)
 Check for client traffic data message is well-formed. More...
 
static void handle_local_data (void *cls, const struct GNUNET_CADET_LocalData *msg)
 Handler for client payload traffic to be send on a channel to another peer. More...
 
static void handle_local_ack (void *cls, const struct GNUNET_CADET_LocalAck *msg)
 Handler for client's ACKs for payload traffic. More...
 
static int get_all_peers_iterator (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
 Iterator over all peers to send a monitoring client info about each peer. More...
 
static void handle_get_peers (void *cls, const struct GNUNET_MessageHeader *message)
 Handler for client's INFO PEERS request. More...
 
static int path_info_iterator (void *cls, struct CadetPeerPath *path, unsigned int off)
 Iterator over all paths of a peer to build an InfoPeer message. More...
 
static void handle_show_path (void *cls, const struct GNUNET_CADET_RequestPathInfoMessage *msg)
 Handler for client's GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH request. More...
 
static int get_all_tunnels_iterator (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
 Iterator over all tunnels to send a monitoring client info about each tunnel. More...
 
static void handle_info_tunnels (void *cls, const struct GNUNET_MessageHeader *message)
 Handler for client's GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS request. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 Callback called when a client connects to the service. More...
 
void GSC_handle_remote_channel_destroy (struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn, struct CadetChannel *ch)
 A channel was destroyed by the other peer. More...
 
void GSC_drop_loose_channel (const struct GNUNET_HashCode *h_port, struct CadetChannel *ch)
 A client that created a loose channel that was not bound to a port disconnected, drop it from the loose_channels list. More...
 
static int channel_destroy_iterator (void *cls, uint32_t key, void *value)
 Iterator for deleting each channel whose client endpoint disconnected. More...
 
static int client_release_ports (void *cls, const struct GNUNET_HashCode *port, void *value)
 Remove client's ports from the global hashmap on disconnect. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *internal_cls)
 Callback called when a client disconnected from the service. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Setup CADET internals. More...
 
 GNUNET_SERVICE_MAIN ("cadet", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(port_open, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN, struct GNUNET_CADET_PortMessage, NULL), GNUNET_MQ_hd_fixed_size(port_close, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE, struct GNUNET_CADET_PortMessage, NULL), GNUNET_MQ_hd_fixed_size(channel_create, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, struct GNUNET_CADET_LocalChannelCreateMessage, NULL), GNUNET_MQ_hd_fixed_size(channel_destroy, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, struct GNUNET_CADET_LocalChannelDestroyMessage, NULL), GNUNET_MQ_hd_var_size(local_data, GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, struct GNUNET_CADET_LocalData, NULL), GNUNET_MQ_hd_fixed_size(local_ack, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, struct GNUNET_CADET_LocalAck, NULL), GNUNET_MQ_hd_fixed_size(get_peers, GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PEERS, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(show_path, GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH, struct GNUNET_CADET_RequestPathInfoMessage, NULL), GNUNET_MQ_hd_fixed_size(info_tunnels, GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_handler_end())
 Define "main" method using service macro. More...
 

Variables

const struct GNUNET_CONFIGURATION_Handlecfg
 Handle to our configuration. More...
 
struct GNUNET_STATISTICS_Handlestats
 Handle to the statistics service. More...
 
struct GNUNET_ATS_ConnectivityHandleats_ch
 Handle to communicate with ATS. More...
 
struct GNUNET_PeerIdentity my_full_id
 Local peer own ID. More...
 
struct GNUNET_CRYPTO_EddsaPrivateKeymy_private_key
 Own private key. More...
 
int shutting_down
 Signal that shutdown is happening: prevent recovery measures. More...
 
static struct CadetClientclients_head
 DLL with all the clients, head. More...
 
static struct CadetClientclients_tail
 DLL with all the clients, tail. More...
 
static unsigned int next_client_id
 Next ID to assign to a client. More...
 
struct GNUNET_CONTAINER_MultiHashMapopen_ports
 All ports clients of this peer have opened. More...
 
struct GNUNET_CONTAINER_MultiHashMaploose_channels
 Map from ports to channels where the ports were closed at the time we got the inbound connection. More...
 
struct GNUNET_CONTAINER_MultiPeerMappeers
 Map from PIDs to struct CadetPeer entries. More...
 
struct GNUNET_CONTAINER_MultiShortmapconnections
 Map from struct GNUNET_CADET_ConnectionTunnelIdentifier hash codes to struct CadetConnection objects. More...
 
unsigned long long ratchet_messages
 How many messages are needed to trigger an AXOLOTL ratchet advance. More...
 
struct GNUNET_TIME_Relative ratchet_time
 How long until we trigger a ratched advance due to time. More...
 
struct GNUNET_TIME_Relative keepalive_period
 How frequently do we send KEEPALIVE messages on idle connections? More...
 
unsigned long long drop_percent
 Set to non-zero values to create random drops to test retransmissions. More...
 

Detailed Description

GNUnet CADET service with encryption.

Author
Bartlomiej Polot
Christian Grothoff

Dictionary:

Definition in file gnunet-service-cadet.c.

Macro Definition Documentation

◆ LOG

#define LOG (   level,
  ... 
)    GNUNET_log (level,__VA_ARGS__)

Function Documentation

◆ GSC_send_to_client()

void GSC_send_to_client ( struct CadetClient c,
struct GNUNET_MQ_Envelope env 
)

Send a message to a client.

Parameters
cclient to get the message
envenvelope with the message

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

References GNUNET_MQ_send(), and CadetClient::mq.

Referenced by GCCH_handle_channel_plaintext_data(), GCCH_handle_local_ack(), GCCH_handle_local_data(), GSC_bind(), GSC_handle_remote_channel_destroy(), and send_ack_to_client().

207 {
208  GNUNET_MQ_send (c->mq,
209  env);
210 }
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_MQ_Handle * mq
Handle to communicate with the client.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_2s()

const char* GSC_2s ( struct CadetClient c)

Return identifier for a client as a string.

Parameters
cclient to identify
Returns
string for debugging

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

References buf, GNUNET_snprintf(), and CadetClient::id.

Referenced by channel_destroy_iterator(), client_connect_cb(), client_disconnect_cb(), client_release_ports(), GCCH_bind(), GCCH_channel_local_destroy(), GCCH_channel_local_new(), GCCH_debug(), GCCH_handle_channel_plaintext_data(), GCCH_handle_local_ack(), handle_channel_create(), handle_channel_destroy(), handle_local_ack(), handle_local_data(), handle_port_close(), handle_port_open(), and send_ack_to_client().

221 {
222  static char buf[32];
223 
224  GNUNET_snprintf (buf,
225  sizeof (buf),
226  "Client(%u)",
227  c->id);
228  return buf;
229 }
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
unsigned int id
ID of the client, mainly for debug messages.
static char buf[2048]
Here is the call graph for this function:
Here is the caller graph for this function:

◆ lookup_channel()

static struct CadetChannel* lookup_channel ( struct CadetClient c,
struct GNUNET_CADET_ClientChannelNumber  ccn 
)
static

Lookup channel of client c by ccn.

Parameters
cclient to look in
ccnchannel ID to look up
Returns
NULL if no such channel exists

Definition at line 240 of file gnunet-service-cadet.c.

References GNUNET_CADET_ClientChannelNumber::channel_of_client, CadetClient::channels, and GNUNET_CONTAINER_multihashmap32_get().

Referenced by client_get_next_ccn(), handle_channel_create(), handle_channel_destroy(), handle_local_ack(), and handle_local_data().

242 {
244  ntohl (ccn.channel_of_client));
245 }
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
void * GNUNET_CONTAINER_multihashmap32_get(const struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key)
Given a key find a value in the map matching the key.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_get_next_ccn()

static struct GNUNET_CADET_ClientChannelNumber client_get_next_ccn ( struct CadetClient c)
static

Obtain the next LID to use for incoming connections to the given client.

Parameters
cclient handle

Definition at line 255 of file gnunet-service-cadet.c.

References GNUNET_CADET_ClientChannelNumber::channel_of_client, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI, and lookup_channel().

Referenced by GSC_bind().

256 {
258 
259  /* increment until we have a free one... */
260  while (NULL !=
261  lookup_channel (c,
262  ccn))
263  {
265  = htonl (1 + (ntohl (ccn.channel_of_client)));
266  if (ntohl (ccn.channel_of_client) >=
268  ccn.channel_of_client = htonl (0);
269  }
271  = htonl (1 + (ntohl (ccn.channel_of_client)));
272  return ccn;
273 }
static struct CadetChannel * lookup_channel(struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
Lookup channel of client c by ccn.
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
Number uniquely identifying a channel of a client.
Definition: cadet.h:102
#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
Minimum value for channel IDs of local clients.
Definition: cadet.h:71
struct GNUNET_CADET_ClientChannelNumber next_ccn
Channel ID to use for the next incoming channel for this client.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_bind()

struct GNUNET_CADET_ClientChannelNumber GSC_bind ( struct CadetClient c,
struct CadetChannel ch,
struct CadetPeer dest,
const struct GNUNET_HashCode port,
uint32_t  options 
)

Bind incoming channel to this client, and notify client about incoming connection.

Caller is responsible for notifying the other peer about our acceptance of the channel.

Parameters
cclient to bind to
chchannel to be bound
destpeer that establishes the connection
portport number
optionsoptions
Returns
local channel number assigned to the new client

Definition at line 289 of file gnunet-service-cadet.c.

References GNUNET_CADET_LocalChannelCreateMessage::ccn, client_get_next_ccn(), env, GCCH_2s(), GCP_2s(), GCP_get_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, GNUNET_MQ_msg, GNUNET_YES, GSC_send_to_client(), LOG, GNUNET_CADET_LocalChannelCreateMessage::opt, options, GNUNET_CADET_LocalChannelCreateMessage::peer, port, and GNUNET_CADET_LocalChannelCreateMessage::port.

Referenced by GCCH_bind().

294 {
295  struct GNUNET_MQ_Envelope *env;
298 
299  ccn = client_get_next_ccn (c);
302  ntohl (ccn.channel_of_client),
303  ch,
306  "Accepting incoming %s from %s on open port %s (%u), assigning ccn %X\n",
307  GCCH_2s (ch),
308  GCP_2s (dest),
309  GNUNET_h2s (port),
310  (uint32_t) ntohl (options),
311  (uint32_t) ntohl (ccn.channel_of_client));
312  /* notify local client about incoming connection! */
313  env = GNUNET_MQ_msg (cm,
315  cm->ccn = ccn;
316  cm->port = *port;
317  cm->opt = htonl (options);
318  cm->peer = *GCP_get_id (dest);
320  env);
321  return ccn;
322 }
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:150
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE
Ask the cadet service to create a new channel.
static struct GNUNET_CADET_ClientChannelNumber client_get_next_ccn(struct CadetClient *c)
Obtain the next LID to use for incoming connections to the given client.
int GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
const char * GCP_2s(const struct CadetPeer *cp)
Get the static string for a peer ID.
#define LOG(level,...)
Number uniquely identifying a channel of a client.
Definition: cadet.h:102
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Message for a client to create channels.
Definition: cadet.h:138
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
const char * GCCH_2s(const struct CadetChannel *ch)
Get the static string for identification of the channel.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:79
void GSC_send_to_client(struct CadetClient *c, struct GNUNET_MQ_Envelope *env)
Send a message to a client.
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_PeerIdentity peer
Channel's peer.
Definition: cadet.h:155
struct GNUNET_HashCode port
Port of the channel.
Definition: cadet.h:160
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:

◆ destroy_tunnels_now()

static int destroy_tunnels_now ( void *  cls,
const struct GNUNET_PeerIdentity pid,
void *  value 
)
static

Callback invoked on all peers to destroy all tunnels that may still exist.

Parameters
clsNULL
pididentify of a peer
valuea struct CadetPeer that may still have a tunnel
Returns
GNUNET_OK (iterate over all entries)

Definition at line 335 of file gnunet-service-cadet.c.

References GCP_get_tunnel(), GCT_destroy_tunnel_now(), GNUNET_NO, GNUNET_OK, t, and value.

Referenced by shutdown_rest().

338 {
339  struct CadetPeer *cp = value;
340  struct CadetTunnel *t = GCP_get_tunnel (cp,
341  GNUNET_NO);
342 
343  if (NULL != t)
345  return GNUNET_OK;
346 }
Peer description.
struct CadetTunnel * GCP_get_tunnel(struct CadetPeer *cp, int create)
Get the tunnel towards a peer.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static struct GNUNET_SCHEDULER_Task * t
Main task.
static char * value
Value of the record to add/remove.
Struct containing all information regarding a tunnel to a peer.
void GCT_destroy_tunnel_now(struct CadetTunnel *t)
Destroys the tunnel t now, without delay.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ destroy_paths_now()

static int destroy_paths_now ( void *  cls,
const struct GNUNET_PeerIdentity pid,
void *  value 
)
static

Callback invoked on all peers to destroy all tunnels that may still exist.

Parameters
clsNULL
pididentify of a peer
valuea struct CadetPeer that may still have a tunnel
Returns
GNUNET_OK (iterate over all entries)

Definition at line 359 of file gnunet-service-cadet.c.

References GCP_drop_owned_paths(), GNUNET_OK, and value.

Referenced by shutdown_rest().

362 {
363  struct CadetPeer *cp = value;
364 
366  return GNUNET_OK;
367 }
Peer description.
void GCP_drop_owned_paths(struct CadetPeer *cp)
Drop all paths owned by this peer, and do not allow new ones to be added: We are shutting down...
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static char * value
Value of the record to add/remove.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ shutdown_rest()

static void shutdown_rest ( )
static

Shutdown everything once the clients have disconnected.

Definition at line 374 of file gnunet-service-cadet.c.

References destroy_paths_now(), destroy_tunnels_now(), GCD_shutdown(), GCH_shutdown(), GCP_destroy_all_peers(), GCP_iterate_all(), GNUNET_ATS_connectivity_done(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_free_non_null, GNUNET_NO, and GNUNET_STATISTICS_destroy().

Referenced by client_disconnect_cb(), and shutdown_task().

375 {
376  if (NULL != stats)
377  {
379  GNUNET_NO);
380  stats = NULL;
381  }
382  /* Destroy tunnels. Note that all channels must be destroyed first! */
384  NULL);
385  /* All tunnels, channels, connections and CORE must be down before this point. */
387  NULL);
388  /* All paths, tunnels, channels, connections and CORE must be down before this point. */
390  if (NULL != open_ports)
391  {
393  open_ports = NULL;
394  }
395  if (NULL != loose_channels)
396  {
398  loose_channels = NULL;
399  }
400  if (NULL != peers)
401  {
403  peers = NULL;
404  }
405  if (NULL != connections)
406  {
408  connections = NULL;
409  }
410  if (NULL != ats_ch)
411  {
413  ats_ch = NULL;
414  }
415  GCD_shutdown ();
416  GCH_shutdown ();
418  my_private_key = NULL;
419 }
struct GNUNET_CONTAINER_MultiPeerMap * peers
Map from PIDs to struct CadetPeer entries.
static int destroy_tunnels_now(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Callback invoked on all peers to destroy all tunnels that may still exist.
void GCD_shutdown(void)
Shut down the DHT subsystem.
struct GNUNET_ATS_ConnectivityHandle * ats_ch
Handle to communicate with ATS.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
void GCH_shutdown()
Shut down the hello subsystem.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
struct GNUNET_CONTAINER_MultiShortmap * connections
Map from struct GNUNET_CADET_ConnectionTunnelIdentifier hash codes to struct CadetConnection objects...
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_MultiHashMap * open_ports
All ports clients of this peer have opened.
struct GNUNET_CONTAINER_MultiHashMap * loose_channels
Map from ports to channels where the ports were closed at the time we got the inbound connection...
void GCP_destroy_all_peers()
Clean up all entries about all peers.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
static int destroy_paths_now(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Callback invoked on all peers to destroy all tunnels that may still exist.
void GNUNET_CONTAINER_multishortmap_destroy(struct GNUNET_CONTAINER_MultiShortmap *map)
Destroy a hash map.
struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Own private key.
void GCP_iterate_all(GNUNET_CONTAINER_PeerMapIterator iter, void *cls)
Iterate over all known peers.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsunused

Definition at line 428 of file gnunet-service-cadet.c.

References GCO_shutdown(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_YES, shutdown_rest(), and shutting_down.

Referenced by run().

429 {
431  "Shutting down\n");
433  GCO_shutdown ();
434  if (NULL == clients_head)
435  shutdown_rest ();
436 }
static struct CadetClient * clients_head
DLL with all the clients, head.
static void shutdown_rest()
Shutdown everything once the clients have disconnected.
void GCO_shutdown()
Shut down the CORE subsystem.
int shutting_down
Signal that shutdown is happening: prevent recovery measures.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
Here is the call graph for this function:
Here is the caller graph for this function:

◆ bind_loose_channel()

static int bind_loose_channel ( void *  cls,
const struct GNUNET_HashCode port,
void *  value 
)
static

We had a remote connection value to port h_port before client cls opened port port.

Bind them now.

Parameters
clsthe struct CadetClient
h_portthe hashed port
valuethe struct CadetChannel
Returns
GNUNET_YES (iterate over all such channels)

Definition at line 449 of file gnunet-service-cadet.c.

References OpenPort::c, GCCH_bind(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_YES, OpenPort::h_port, op, OpenPort::port, and value.

Referenced by handle_port_open().

452 {
453  struct OpenPort *op = cls;
454  struct CadetChannel *ch = value;
455 
456  GCCH_bind (ch,
457  op->c,
458  &op->port);
461  &op->h_port,
462  ch));
463  return GNUNET_YES;
464 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_CONTAINER_MultiHashMap * loose_channels
Map from ports to channels where the ports were closed at the time we got the inbound connection...
static char * value
Value of the record to add/remove.
struct GNUNET_HashCode h_port
Port hashed with our PID (matches incoming OPEN messages).
Struct containing all information regarding a channel to a remote client.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
struct GNUNET_HashCode port
Port number.
#define GNUNET_YES
Definition: gnunet_common.h:80
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
struct CadetClient * c
Client that opened the port.
Port opened by a client.
void GCCH_bind(struct CadetChannel *ch, struct CadetClient *c, const struct GNUNET_HashCode *port)
A client is bound to the port that we have a channel open to.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_port_open()

static void handle_port_open ( void *  cls,
const struct GNUNET_CADET_PortMessage pmsg 
)
static

Handle port open request.

Creates a mapping from the port to the respective client and checks whether we have loose channels trying to bind to the port. If so, those are bound.

Parameters
clsIdentification of the client.
pmsgThe actual message.

Definition at line 477 of file gnunet-service-cadet.c.

References bind_loose_channel(), OpenPort::c, CadetClient::client, GCCH_hash_port(), GNUNET_break, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GSC_2s(), OpenPort::h_port, LOG, my_full_id, op, GNUNET_CADET_PortMessage::port, OpenPort::port, and CadetClient::ports.

479 {
480  struct CadetClient *c = cls;
481  struct OpenPort *op;
482 
484  "Open port %s requested by %s\n",
485  GNUNET_h2s (&pmsg->port),
486  GSC_2s (c));
487  if (NULL == c->ports)
489  GNUNET_NO);
490  op = GNUNET_new (struct OpenPort);
491  op->c = c;
492  op->port = pmsg->port;
493  GCCH_hash_port (&op->h_port,
494  &pmsg->port,
495  &my_full_id);
496  if (GNUNET_OK !=
498  &op->port,
499  op,
501  {
502  GNUNET_break (0);
504  return;
505  }
507  &op->h_port,
508  op,
511  &op->h_port,
513  op);
515 }
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GCCH_hash_port(struct GNUNET_HashCode *h_port, const struct GNUNET_HashCode *port, const struct GNUNET_PeerIdentity *listener)
Hash the port and initiator and listener to calculate the "challenge" h_port we send to the other pee...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_CONTAINER_MultiHashMap * open_ports
All ports clients of this peer have opened.
struct GNUNET_CONTAINER_MultiHashMap * loose_channels
Map from ports to channels where the ports were closed at the time we got the inbound connection...
struct GNUNET_HashCode h_port
Port hashed with our PID (matches incoming OPEN messages).
struct GNUNET_SERVICE_Client * client
Client handle.
#define LOG(level,...)
struct GNUNET_HashCode port
Port number.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Struct containing information about a client of the service.
struct GNUNET_HashCode port
Port to open/close.
Definition: cadet.h:131
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_MultiHashMap * ports
Ports that this client has declared interest in.
Allow multiple values with the same key.
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_HashMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
static int bind_loose_channel(void *cls, const struct GNUNET_HashCode *port, void *value)
We had a remote connection value to port h_port before client cls opened port port.
struct CadetClient * c
Client that opened the port.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
Port opened by a client.
Here is the call graph for this function:

◆ handle_port_close()

static void handle_port_close ( void *  cls,
const struct GNUNET_CADET_PortMessage pmsg 
)
static

Handler for port close requests.

Marks this port as closed (unless of course we have another client with the same port open). Note that existing channels accepted on the port are not affected.

Parameters
clsIdentification of the client.
pmsgThe actual message.

Definition at line 528 of file gnunet-service-cadet.c.

References CadetClient::client, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, GSC_2s(), OpenPort::h_port, LOG, op, GNUNET_CADET_PortMessage::port, OpenPort::port, and CadetClient::ports.

530 {
531  struct CadetClient *c = cls;
532  struct OpenPort *op;
533 
535  "Closing port %s as requested by %s\n",
536  GNUNET_h2s (&pmsg->port),
537  GSC_2s (c));
538  if (NULL == c->ports)
539  {
540  /* Client closed a port despite _never_ having opened one? */
541  GNUNET_break (0);
543  return;
544  }
546  &pmsg->port);
547  if (NULL == op)
548  {
549  GNUNET_break (0);
551  return;
552  }
555  &op->port,
556  op));
559  &op->h_port,
560  op));
561  GNUNET_free (op);
563 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
struct GNUNET_CONTAINER_MultiHashMap * open_ports
All ports clients of this peer have opened.
struct GNUNET_HashCode h_port
Port hashed with our PID (matches incoming OPEN messages).
struct GNUNET_SERVICE_Client * client
Client handle.
#define LOG(level,...)
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
struct GNUNET_HashCode port
Port number.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
Struct containing information about a client of the service.
struct GNUNET_HashCode port
Port to open/close.
Definition: cadet.h:131
struct GNUNET_CONTAINER_MultiHashMap * ports
Ports that this client has declared interest in.
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
#define GNUNET_YES
Definition: gnunet_common.h:80
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
Port opened by a client.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:

◆ handle_channel_create()

static void handle_channel_create ( void *  cls,
const struct GNUNET_CADET_LocalChannelCreateMessage tcm 
)
static

Handler for requests for us creating a new channel to another peer and port.

Parameters
clsIdentification of the client.
tcmThe actual message.

Definition at line 573 of file gnunet-service-cadet.c.

References GNUNET_CADET_LocalChannelCreateMessage::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, CadetClient::channels, CadetClient::client, GCCH_channel_local_new(), GCP_get(), GNUNET_assert, GNUNET_break, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI, GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, GSC_2s(), LOG, lookup_channel(), GNUNET_CADET_LocalChannelCreateMessage::opt, GNUNET_CADET_LocalChannelCreateMessage::peer, and GNUNET_CADET_LocalChannelCreateMessage::port.

575 {
576  struct CadetClient *c = cls;
577  struct CadetChannel *ch;
578 
580  {
581  /* Channel ID not in allowed range. */
582  GNUNET_break (0);
584  return;
585  }
586  ch = lookup_channel (c,
587  tcm->ccn);
588  if (NULL != ch)
589  {
590  /* Channel ID already in use. Not allowed. */
591  GNUNET_break (0);
593  return;
594  }
596  "New channel to %s at port %s requested by %s\n",
597  GNUNET_i2s (&tcm->peer),
598  GNUNET_h2s (&tcm->port),
599  GSC_2s (c));
600 
601  /* Create channel */
602  ch = GCCH_channel_local_new (c,
603  tcm->ccn,
604  GCP_get (&tcm->peer,
605  GNUNET_YES),
606  &tcm->port,
607  ntohl (tcm->opt));
608  if (NULL == ch)
609  {
610  GNUNET_break (0);
612  return;
613  }
616  ntohl (tcm->ccn.channel_of_client),
617  ch,
619 
621 }
static struct CadetChannel * lookup_channel(struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
Lookup channel of client c by ccn.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:150
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct CadetChannel * GCCH_channel_local_new(struct CadetClient *owner, struct GNUNET_CADET_ClientChannelNumber ccn, struct CadetPeer *destination, const struct GNUNET_HashCode *port, uint32_t options)
Create a new channel.
int GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Struct containing all information regarding a channel to a remote client.
struct GNUNET_SERVICE_Client * client
Client handle.
#define LOG(level,...)
#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
Minimum value for channel IDs of local clients.
Definition: cadet.h:71
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Struct containing information about a client of the service.
struct CadetPeer * GCP_get(const struct GNUNET_PeerIdentity *peer_id, int create)
Retrieve the CadetPeer stucture associated with the peer.
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_PeerIdentity peer
Channel's peer.
Definition: cadet.h:155
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
struct GNUNET_HashCode port
Port of the channel.
Definition: cadet.h:160
Here is the call graph for this function:

◆ handle_channel_destroy()

static void handle_channel_destroy ( void *  cls,
const struct GNUNET_CADET_LocalChannelDestroyMessage msg 
)
static

Handler for requests of destroying an existing channel.

Parameters
clsclient identification of the client
msgthe actual message

Definition at line 631 of file gnunet-service-cadet.c.

References GNUNET_CADET_LocalChannelDestroyMessage::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, CadetClient::channels, CadetClient::client, GCCH_2s(), GCCH_channel_local_destroy(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_SERVICE_client_continue(), GNUNET_YES, GSC_2s(), LOG, and lookup_channel().

633 {
634  struct CadetClient *c = cls;
635  struct CadetChannel *ch;
636 
637  ch = lookup_channel (c,
638  msg->ccn);
639  if (NULL == ch)
640  {
641  /* Client attempted to destroy unknown channel.
642  Can happen if the other side went down at the same time.*/
644  "%s tried to destroy unknown channel %X\n",
645  GSC_2s(c),
646  (uint32_t) ntohl (msg->ccn.channel_of_client));
648  return;
649  }
651  "%s is destroying %s\n",
652  GSC_2s(c),
653  GCCH_2s (ch));
656  ntohl (msg->ccn.channel_of_client),
657  ch));
659  c,
660  msg->ccn);
662 }
static struct CadetChannel * lookup_channel(struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
Lookup channel of client c by ccn.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
Struct containing all information regarding a channel to a remote client.
struct GNUNET_SERVICE_Client * client
Client handle.
#define LOG(level,...)
Struct containing information about a client of the service.
void GCCH_channel_local_destroy(struct CadetChannel *ch, struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
Destroy locally created channel.
const char * GCCH_2s(const struct CadetChannel *ch)
Get the static string for identification of the channel.
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:182
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
#define GNUNET_YES
Definition: gnunet_common.h:80
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
Here is the call graph for this function:

◆ check_local_data()

static int check_local_data ( void *  cls,
const struct GNUNET_CADET_LocalData msg 
)
static

Check for client traffic data message is well-formed.

Parameters
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is OK, GNUNET_SYSERR if not

Definition at line 673 of file gnunet-service-cadet.c.

References buf, GNUNET_break, GNUNET_break_op, GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, GNUNET_CADET_LocalData::header, LOG, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

675 {
676  size_t payload_size;
677  size_t payload_claimed_size;
678  const char *buf;
679  struct GNUNET_MessageHeader pa;
680 
681  /* FIXME: what is the format we shall allow for @a msg?
682  ONE payload item or multiple? Seems current cadet_api
683  at least in theory allows more than one. Next-gen
684  cadet_api will likely no more, so we could then
685  simplify this mess again. */
686  /* Sanity check for message size */
687  payload_size = ntohs (msg->header.size) - sizeof (*msg);
688  buf = (const char *) &msg[1];
689  while (payload_size >= sizeof (struct GNUNET_MessageHeader))
690  {
691  /* need to memcpy() for alignment */
692  GNUNET_memcpy (&pa,
693  buf,
694  sizeof (pa));
695  payload_claimed_size = ntohs (pa.size);
696  if ( (payload_size < payload_claimed_size) ||
697  (payload_claimed_size < sizeof (struct GNUNET_MessageHeader)) ||
698  (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < payload_claimed_size) )
699  {
700  GNUNET_break (0);
702  "Local data of %u total size had sub-message %u at %u with %u bytes\n",
703  ntohs (msg->header.size),
704  ntohs (pa.type),
705  (unsigned int) (buf - (const char *) &msg[1]),
706  (unsigned int) payload_claimed_size);
707  return GNUNET_SYSERR;
708  }
709  payload_size -= payload_claimed_size;
710  buf += payload_claimed_size;
711  }
712  if (0 != payload_size)
713  {
714  GNUNET_break_op (0);
715  return GNUNET_SYSERR;
716  }
717  return GNUNET_OK;
718 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_memcpy(dst, src, n)
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define LOG(level,...)
static char buf[2048]
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
Header for all communications.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA.
Definition: cadet.h:194

◆ handle_local_data()

static void handle_local_data ( void *  cls,
const struct GNUNET_CADET_LocalData msg 
)
static

Handler for client payload traffic to be send on a channel to another peer.

Parameters
clsidentification of the client
msgthe actual message

Definition at line 729 of file gnunet-service-cadet.c.

References buf, GNUNET_CADET_LocalData::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, CadetClient::client, GCCH_2s(), GCCH_handle_local_data(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GSC_2s(), GNUNET_CADET_LocalData::header, LOG, lookup_channel(), and GNUNET_MessageHeader::size.

731 {
732  struct CadetClient *c = cls;
733  struct CadetChannel *ch;
734  size_t payload_size;
735  const char *buf;
736 
737  ch = lookup_channel (c,
738  msg->ccn);
739  if (NULL == ch)
740  {
741  /* Channel does not exist (anymore) */
743  "Dropping payload for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
744  (unsigned int) ntohl (msg->ccn.channel_of_client));
746  return;
747  }
748  payload_size = ntohs (msg->header.size) - sizeof (*msg);
750  "# payload received from clients",
751  payload_size,
752  GNUNET_NO);
753  buf = (const char *) &msg[1];
755  "Received %u bytes payload from %s for %s\n",
756  (unsigned int) payload_size,
757  GSC_2s (c),
758  GCCH_2s (ch));
759  if (GNUNET_OK !=
761  msg->ccn,
762  buf,
763  payload_size))
764  {
765  GNUNET_break (0);
767  return;
768  }
770 }
static struct CadetChannel * lookup_channel(struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
Lookup channel of client c by ccn.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
Struct containing all information regarding a channel to a remote client.
struct GNUNET_SERVICE_Client * client
Client handle.
#define LOG(level,...)
static char buf[2048]
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel.
Definition: cadet.h:199
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
Struct containing information about a client of the service.
const char * GCCH_2s(const struct CadetChannel *ch)
Get the static string for identification of the channel.
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA.
Definition: cadet.h:194
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
int GCCH_handle_local_data(struct CadetChannel *ch, struct GNUNET_CADET_ClientChannelNumber sender_ccn, const char *buf, size_t buf_len)
Handle data given by a client.
Here is the call graph for this function:

◆ handle_local_ack()

static void handle_local_ack ( void *  cls,
const struct GNUNET_CADET_LocalAck msg 
)
static

Handler for client's ACKs for payload traffic.

Parameters
clsidentification of the client.
msgThe actual message.

Definition at line 780 of file gnunet-service-cadet.c.

References GNUNET_CADET_LocalAck::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, CadetClient::client, GCCH_2s(), GCCH_handle_local_ack(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_SERVICE_client_continue(), GSC_2s(), LOG, and lookup_channel().

782 {
783  struct CadetClient *c = cls;
784  struct CadetChannel *ch;
785 
786  ch = lookup_channel (c,
787  msg->ccn);
788  if (NULL == ch)
789  {
790  /* Channel does not exist (anymore) */
792  "Ignoring local ACK for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
793  (unsigned int) ntohl (msg->ccn.channel_of_client));
795  return;
796  }
798  "Got a local ACK from %s for %s\n",
799  GSC_2s(c),
800  GCCH_2s (ch));
802  msg->ccn);
804 }
static struct CadetChannel * lookup_channel(struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
Lookup channel of client c by ccn.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
void GCCH_handle_local_ack(struct CadetChannel *ch, struct GNUNET_CADET_ClientChannelNumber client_ccn)
Handle ACK from client on local channel.
Struct containing all information regarding a channel to a remote client.
struct GNUNET_SERVICE_Client * client
Client handle.
#define LOG(level,...)
Struct containing information about a client of the service.
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel allowed to send more data.
Definition: cadet.h:227
const char * GCCH_2s(const struct CadetChannel *ch)
Get the static string for identification of the channel.
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
Here is the call graph for this function:

◆ get_all_peers_iterator()

static int get_all_peers_iterator ( void *  cls,
const struct GNUNET_PeerIdentity peer,
void *  value 
)
static

Iterator over all peers to send a monitoring client info about each peer.

Parameters
clsClosure ().
peerPeer ID (tunnel remote peer).
valuePeer info.
Returns
GNUNET_YES, to keep iterating.

Definition at line 816 of file gnunet-service-cadet.c.

References GNUNET_CADET_LocalInfoPeers::best_path_length, GNUNET_CADET_LocalInfoPeers::destination, env, GCP_count_paths(), GCP_get_tunnel(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_YES, CadetClient::mq, msg, p, GNUNET_CADET_LocalInfoPeers::paths, peer, GNUNET_CADET_LocalInfoPeers::tunnel, and value.

Referenced by handle_get_peers().

819 {
820  struct CadetClient *c = cls;
821  struct CadetPeer *p = value;
822  struct GNUNET_MQ_Envelope *env;
824 
825  env = GNUNET_MQ_msg (msg,
827  msg->destination = *peer;
828  msg->paths = htons (GCP_count_paths (p));
829  msg->tunnel = htons (NULL != GCP_get_tunnel (p,
830  GNUNET_NO));
831  msg->best_path_length = htonl (0); // FIXME: get length of shortest known path!
832  GNUNET_MQ_send (c->mq,
833  env);
834  return GNUNET_YES;
835 }
Peer description.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct CadetTunnel * GCP_get_tunnel(struct CadetPeer *cp, int create)
Get the tunnel towards a peer.
uint32_t best_path_length
Shortest known path.
Definition: cadet.h:359
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_NO
Definition: gnunet_common.h:81
uint16_t paths
Number of paths.
Definition: cadet.h:349
int16_t tunnel
Do we have a tunnel toward this peer?
Definition: cadet.h:354
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static char * value
Value of the record to add/remove.
Message to inform the client about one of the peers in the service.
Definition: cadet.h:339
Struct containing information about a client of the service.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS
Local information about all peers known to the service.
struct GNUNET_PeerIdentity destination
ID of the peer (can be local peer).
Definition: cadet.h:364
#define GNUNET_YES
Definition: gnunet_common.h:80
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
unsigned int GCP_count_paths(const struct CadetPeer *cp)
Count the number of known paths toward the peer.
struct GNUNET_MQ_Handle * mq
Handle to communicate with the client.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_get_peers()

static void handle_get_peers ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Handler for client's INFO PEERS request.

Parameters
clsIdentification of the client.
messageThe actual message.

Definition at line 845 of file gnunet-service-cadet.c.

References CadetClient::client, env, GCP_iterate_all(), get_all_peers_iterator(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), and CadetClient::mq.

847 {
848  struct CadetClient *c = cls;
849  struct GNUNET_MQ_Envelope *env;
850  struct GNUNET_MessageHeader *reply;
851 
853  c);
854  env = GNUNET_MQ_msg (reply,
856  GNUNET_MQ_send (c->mq,
857  env);
859 }
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS_END
End of local information about all peers known to the service.
struct GNUNET_SERVICE_Client * client
Client handle.
Struct containing information about a client of the service.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static int get_all_peers_iterator(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Iterator over all peers to send a monitoring client info about each peer.
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
void GCP_iterate_all(GNUNET_CONTAINER_PeerMapIterator iter, void *cls)
Iterate over all known peers.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
struct GNUNET_MQ_Handle * mq
Handle to communicate with the client.
Here is the call graph for this function:

◆ path_info_iterator()

static int path_info_iterator ( void *  cls,
struct CadetPeerPath path,
unsigned int  off 
)
static

Iterator over all paths of a peer to build an InfoPeer message.

Message contains blocks of peers, first not included.

Parameters
clsmessage queue for transmission
pathPath itself
offoffset of the peer on path
Returns
GNUNET_YES if should keep iterating. GNUNET_NO otherwise.

Definition at line 873 of file gnunet-service-cadet.c.

References env, GCP_get_id(), GCPP_get_length(), GCPP_get_peer_at_offset(), GNUNET_ERROR_TYPE_WARNING, GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH, GNUNET_MIN, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, CadetClient::id, LOG, CadetClient::mq, and GNUNET_CADET_LocalInfoPath::off.

Referenced by handle_show_path().

876 {
877  struct GNUNET_MQ_Handle *mq = cls;
878  struct GNUNET_MQ_Envelope *env;
879  struct GNUNET_CADET_LocalInfoPath *resp;
880  struct GNUNET_PeerIdentity *id;
881  size_t path_size;
882  unsigned int path_length;
883 
884  path_length = GCPP_get_length (path);
885  path_size = sizeof (struct GNUNET_PeerIdentity) * path_length;
886  if (sizeof (*resp) + path_size > UINT16_MAX)
887  {
888  /* try just giving the relevant path */
889  path_length = GNUNET_MIN ((UINT16_MAX - sizeof (*resp)) / sizeof (struct GNUNET_PeerIdentity),
890  off);
891  path_size = sizeof (struct GNUNET_PeerIdentity) * path_length;
892  }
893  if (sizeof (*resp) + path_size > UINT16_MAX)
894  {
896  "Path of %u entries is too long for info message\n",
897  path_length);
898  return GNUNET_YES;
899  }
900  env = GNUNET_MQ_msg_extra (resp,
901  path_size,
903  id = (struct GNUNET_PeerIdentity *) &resp[1];
904 
905  /* Don't copy first peer. First peer is always the local one. Last
906  * peer is always the destination (leave as 0, EOL).
907  */
908  for (unsigned int i = 0; i < path_length; i++)
909  id[i] = *GCP_get_id (GCPP_get_peer_at_offset (path,
910  i));
911  resp->off = htonl (off);
912  GNUNET_MQ_send (mq,
913  env);
914  return GNUNET_YES;
915 }
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH
Local information of service about a specific path.
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
Message to inform the client about one of the paths known to the service.
Definition: cadet.h:322
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:83
#define LOG(level,...)
uint32_t off
Offset of the peer that was requested.
Definition: cadet.h:332
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
Handle to a message queue.
Definition: mq.c:85
The identity of the host (wraps the signing key of the peer).
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
#define GNUNET_YES
Definition: gnunet_common.h:80
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
unsigned int GCPP_get_length(struct CadetPeerPath *path)
Return the length of the path.
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:

◆ handle_show_path()

static void handle_show_path ( void *  cls,
const struct GNUNET_CADET_RequestPathInfoMessage msg 
)
static

Handler for client's GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH request.

Parameters
clsIdentification of the client.
msgThe actual message.

Definition at line 925 of file gnunet-service-cadet.c.

References CadetClient::client, env, GCP_get(), GCP_iterate_indirect_paths(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_continue(), CadetClient::mq, p, path_info_iterator(), and GNUNET_CADET_RequestPathInfoMessage::peer.

927 {
928  struct CadetClient *c = cls;
929  struct CadetPeer *p;
930  struct GNUNET_MQ_Envelope *env;
931  struct GNUNET_MessageHeader *resp;
932 
933  p = GCP_get (&msg->peer,
934  GNUNET_NO);
935  if (NULL != p)
938  c->mq);
939  env = GNUNET_MQ_msg (resp,
941  GNUNET_MQ_send (c->mq,
942  env);
944 }
Peer description.
static int path_info_iterator(void *cls, struct CadetPeerPath *path, unsigned int off)
Iterator over all paths of a peer to build an InfoPeer message.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_PeerIdentity peer
ID of the destination of the channel (can be local peer).
Definition: cadet.h:274
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
struct GNUNET_SERVICE_Client * client
Client handle.
Struct containing information about a client of the service.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
unsigned int GCP_iterate_indirect_paths(struct CadetPeer *cp, GCP_PathIterator callback, void *callback_cls)
Iterate over the paths to a peer without direct link.
struct CadetPeer * GCP_get(const struct GNUNET_PeerIdentity *peer_id, int create)
Retrieve the CadetPeer stucture associated with the peer.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH_END
End of local information of service about a specific path.
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
struct GNUNET_MQ_Handle * mq
Handle to communicate with the client.
Here is the call graph for this function:

◆ get_all_tunnels_iterator()

static int get_all_tunnels_iterator ( void *  cls,
const struct GNUNET_PeerIdentity peer,
void *  value 
)
static

Iterator over all tunnels to send a monitoring client info about each tunnel.

Parameters
clsClosure ().
peerPeer ID (tunnel remote peer).
valuea struct CadetPeer
Returns
GNUNET_YES, to keep iterating.

Definition at line 956 of file gnunet-service-cadet.c.

References GNUNET_CADET_LocalInfoTunnel::channels, GNUNET_CADET_LocalInfoTunnel::connections, GNUNET_CADET_LocalInfoTunnel::cstate, GNUNET_CADET_LocalInfoTunnel::destination, env, GNUNET_CADET_LocalInfoTunnel::estate, GCP_get_tunnel(), GCT_count_any_connections(), GCT_count_channels(), GCT_get_estate(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_YES, CadetClient::mq, msg, p, peer, t, and value.

Referenced by handle_info_tunnels().

959 {
960  struct CadetClient *c = cls;
961  struct CadetPeer *p = value;
962  struct GNUNET_MQ_Envelope *env;
964  struct CadetTunnel *t;
965 
966  t = GCP_get_tunnel (p,
967  GNUNET_NO);
968  if (NULL == t)
969  return GNUNET_YES;
970  env = GNUNET_MQ_msg (msg,
972  msg->destination = *peer;
973  msg->channels = htonl (GCT_count_channels (t));
974  msg->connections = htonl (GCT_count_any_connections (t));
975  msg->cstate = htons (0);
976  msg->estate = htons ((uint16_t) GCT_get_estate (t));
977  GNUNET_MQ_send (c->mq,
978  env);
979  return GNUNET_YES;
980 }
uint16_t cstate
Connection state.
Definition: cadet.h:404
Peer description.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
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.
struct GNUNET_PeerIdentity destination
ID of the destination of the tunnel (can be local peer).
Definition: cadet.h:389
unsigned int GCT_count_any_connections(const struct CadetTunnel *t)
Count all created connections of a tunnel.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_NO
Definition: gnunet_common.h:81
static struct GNUNET_SCHEDULER_Task * t
Main task.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS
Local information about all tunnels of service.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static char * value
Value of the record to add/remove.
Message to inform the client about one of the tunnels in the service.
Definition: cadet.h:373
Struct containing all information regarding a tunnel to a peer.
Struct containing information about a client of the service.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
uint32_t connections
Number of connections.
Definition: cadet.h:394
uint32_t channels
Number of channels.
Definition: cadet.h:384
uint16_t estate
Encryption state.
Definition: cadet.h:399
unsigned int GCT_count_channels(struct CadetTunnel *t)
Count channels of a tunnel.
#define GNUNET_YES
Definition: gnunet_common.h:80
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_MQ_Handle * mq
Handle to communicate with the client.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_info_tunnels()

static void handle_info_tunnels ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Handler for client's GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS request.

Parameters
clsclient Identification of the client.
messageThe actual message.

Definition at line 990 of file gnunet-service-cadet.c.

References CadetClient::client, env, GCP_iterate_all(), get_all_tunnels_iterator(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), and CadetClient::mq.

992 {
993  struct CadetClient *c = cls;
994  struct GNUNET_MQ_Envelope *env;
995  struct GNUNET_MessageHeader *reply;
996 
998  c);
999  env = GNUNET_MQ_msg (reply,
1001  GNUNET_MQ_send (c->mq,
1002  env);
1004 }
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_SERVICE_Client * client
Client handle.
Struct containing information about a client of the service.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS_END
End of local information about all tunnels of service.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static int get_all_tunnels_iterator(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Iterator over all tunnels to send a monitoring client info about each tunnel.
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
void GCP_iterate_all(GNUNET_CONTAINER_PeerMapIterator iter, void *cls)
Iterate over all known peers.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
struct GNUNET_MQ_Handle * mq
Handle to communicate with the client.
Here is the call graph for this function:

◆ client_connect_cb()

static void* client_connect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
struct GNUNET_MQ_Handle mq 
)
static

Callback called when a client connects to the service.

Parameters
clsclosure for the service
clientthe new client that connected to the service
mqthe message queue used to send messages to the client
Returns
c

Definition at line 1016 of file gnunet-service-cadet.c.

References CadetClient::channels, CadetClient::client, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multihashmap32_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GSC_2s(), CadetClient::id, LOG, CadetClient::mq, and next_client_id.

Referenced by run().

1019 {
1020  struct CadetClient *c;
1021 
1022  c = GNUNET_new (struct CadetClient);
1023  c->client = client;
1024  c->mq = mq;
1025  c->id = next_client_id++; /* overflow not important: just for debug */
1026  c->channels
1029  clients_tail,
1030  c);
1032  "# clients",
1033  +1,
1034  GNUNET_NO);
1036  "%s connected\n",
1037  GSC_2s (c));
1038  return c;
1039 }
static unsigned int next_client_id
Next ID to assign to a client.
static struct CadetClient * clients_head
DLL with all the clients, head.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static struct CadetClient * clients_tail
DLL with all the clients, tail.
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
unsigned int id
ID of the client, mainly for debug messages.
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 GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct GNUNET_SERVICE_Client * client
Client handle.
#define LOG(level,...)
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
Struct containing information about a client of the service.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
struct GNUNET_MQ_Handle * mq
Handle to communicate with the client.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_handle_remote_channel_destroy()

void GSC_handle_remote_channel_destroy ( struct CadetClient c,
struct GNUNET_CADET_ClientChannelNumber  ccn,
struct CadetChannel ch 
)

A channel was destroyed by the other peer.

Tell our client.

Parameters
cclient that lost a channel
ccnchannel identification number for the client
chthe channel object

Definition at line 1050 of file gnunet-service-cadet.c.

References GNUNET_CADET_LocalChannelDestroyMessage::ccn, GNUNET_CADET_ClientChannelNumber::channel_of_client, CadetClient::channels, env, GNUNET_assert, GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, GNUNET_MQ_msg, GNUNET_YES, and GSC_send_to_client().

Referenced by GCCH_handle_remote_destroy(), and signal_remote_destroy_cb().

1053 {
1054  struct GNUNET_MQ_Envelope *env;
1056 
1057  env = GNUNET_MQ_msg (tdm,
1059  tdm->ccn = ccn;
1060  GSC_send_to_client (c,
1061  env);
1064  ntohl (ccn.channel_of_client),
1065  ch));
1066 }
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
Message for or to a client to destroy tunnel.
Definition: cadet.h:172
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY
Tell client that a channel was destroyed.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:182
void GSC_send_to_client(struct CadetClient *c, struct GNUNET_MQ_Envelope *env)
Send a message to a client.
#define GNUNET_YES
Definition: gnunet_common.h:80
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_drop_loose_channel()

void GSC_drop_loose_channel ( const struct GNUNET_HashCode h_port,
struct CadetChannel ch 
)

A client that created a loose channel that was not bound to a port disconnected, drop it from the loose_channels list.

Parameters
h_portthe hashed port the channel was trying to bind to
chthe channel that was lost

Definition at line 1077 of file gnunet-service-cadet.c.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), and GNUNET_YES.

Referenced by channel_destroy().

1079 {
1082  h_port,
1083  ch));
1084 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_CONTAINER_MultiHashMap * loose_channels
Map from ports to channels where the ports were closed at the time we got the inbound connection...
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_YES
Definition: gnunet_common.h:80
Here is the call graph for this function:
Here is the caller graph for this function:

◆ channel_destroy_iterator()

static int channel_destroy_iterator ( void *  cls,
uint32_t  key,
void *  value 
)
static

Iterator for deleting each channel whose client endpoint disconnected.

Parameters
clsClosure (client that has disconnected).
keyThe local channel id in host byte order
valueThe value stored at the key (channel to destroy).
Returns
GNUNET_OK, keep iterating.

Definition at line 1096 of file gnunet-service-cadet.c.

References GNUNET_CADET_ClientChannelNumber::channel_of_client, CadetClient::channels, GCCH_2s(), GCCH_channel_local_destroy(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_OK, GNUNET_YES, GSC_2s(), LOG, and value.

Referenced by client_disconnect_cb().

1099 {
1100  struct CadetClient *c = cls;
1102  struct CadetChannel *ch = value;
1103 
1105  "Destroying %s, due to %s disconnecting.\n",
1106  GCCH_2s (ch),
1107  GSC_2s (c));
1108  ccn.channel_of_client = htonl (key);
1110  c,
1111  ccn);
1114  key,
1115  ch));
1116  return GNUNET_OK;
1117 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
static char * value
Value of the record to add/remove.
Struct containing all information regarding a channel to a remote client.
#define LOG(level,...)
Number uniquely identifying a channel of a client.
Definition: cadet.h:102
Struct containing information about a client of the service.
struct GNUNET_HashCode key
The key used in the DHT.
void GCCH_channel_local_destroy(struct CadetChannel *ch, struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
Destroy locally created channel.
const char * GCCH_2s(const struct CadetChannel *ch)
Get the static string for identification of the channel.
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
#define GNUNET_YES
Definition: gnunet_common.h:80
Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_release_ports()

static int client_release_ports ( void *  cls,
const struct GNUNET_HashCode port,
void *  value 
)
static

Remove client's ports from the global hashmap on disconnect.

Parameters
clsthe struct CadetClient
portthe port.
valuethe struct OpenPort to remove
Returns
GNUNET_OK, keep iterating.

Definition at line 1129 of file gnunet-service-cadet.c.

References OpenPort::c, GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_OK, GNUNET_YES, GSC_2s(), OpenPort::h_port, LOG, op, CadetClient::ports, and value.

Referenced by client_disconnect_cb().

1132 {
1133  struct CadetClient *c = cls;
1134  struct OpenPort *op = value;
1135 
1136  GNUNET_assert (c == op->c);
1138  "Closing port %s due to %s disconnect.\n",
1139  GNUNET_h2s (port),
1140  GSC_2s (c));
1143  &op->h_port,
1144  op));
1147  port,
1148  op));
1149  GNUNET_free (op);
1150  return GNUNET_OK;
1151 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct GNUNET_CONTAINER_MultiHashMap * open_ports
All ports clients of this peer have opened.
static char * value
Value of the record to add/remove.
struct GNUNET_HashCode h_port
Port hashed with our PID (matches incoming OPEN messages).
#define LOG(level,...)
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
Struct containing information about a client of the service.
struct GNUNET_CONTAINER_MultiHashMap * ports
Ports that this client has declared interest in.
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
#define GNUNET_YES
Definition: gnunet_common.h:80
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
struct CadetClient * c
Client that opened the port.
Port opened by a client.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_disconnect_cb()

static void client_disconnect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
void *  internal_cls 
)
static

Callback called when a client disconnected from the service.

Parameters
clsclosure for the service
clientthe client that disconnected
internal_clsshould be equal to c

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

References channel_destroy_iterator(), CadetClient::channels, CadetClient::client, client_release_ports(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_CONTAINER_multihashmap32_size(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GSC_2s(), LOG, CadetClient::ports, shutdown_rest(), and shutting_down.

Referenced by run().

1165 {
1166  struct CadetClient *c = internal_cls;
1167 
1168  GNUNET_assert (c->client == client);
1170  "%s is disconnecting.\n",
1171  GSC_2s (c));
1172  if (NULL != c->channels)
1173  {
1176  c);
1179  }
1180  if (NULL != c->ports)
1181  {
1184  c);
1186  }
1188  clients_tail,
1189  c);
1191  "# clients",
1192  -1,
1193  GNUNET_NO);
1194  GNUNET_free (c);
1195  if ( (NULL == clients_head) &&
1196  (GNUNET_YES == shutting_down) )
1197  shutdown_rest ();
1198 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct CadetClient * clients_head
DLL with all the clients, head.
static void shutdown_rest()
Shutdown everything once the clients have disconnected.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct CadetClient * clients_tail
DLL with all the clients, tail.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_HashMapIterator it, void *it_cls)
Iterate over all entries in the map.
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
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 GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct GNUNET_SERVICE_Client * client
Client handle.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
#define LOG(level,...)
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
Struct containing information about a client of the service.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_HashMapIterator32 it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiHashMap * ports
Ports that this client has declared interest in.
int shutting_down
Signal that shutdown is happening: prevent recovery measures.
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
static int client_release_ports(void *cls, const struct GNUNET_HashCode *port, void *value)
Remove client&#39;s ports from the global hashmap on disconnect.
#define GNUNET_YES
Definition: gnunet_common.h:80
static int channel_destroy_iterator(void *cls, uint32_t key, void *value)
Iterator for deleting each channel whose client endpoint disconnected.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ run()

static void run ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle service 
)
static

Setup CADET internals.

Parameters
clsclosure
serverthe initialized server
cconfiguration to use

Definition at line 1209 of file gnunet-service-cadet.c.

References channel_destroy(), client_connect_cb(), client_disconnect_cb(), drop_percent, GCD_init(), GCH_init(), GCO_init(), get_peers(), GNUNET_ATS_connectivity_init(), GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multishortmap_create(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_log_config_invalid(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN, GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH, GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PEERS, GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_HOURS, GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, keepalive_period, LOG, my_full_id, GNUNET_PeerIdentity::public_key, ratchet_messages, ratchet_time, and shutdown_task().

1212 {
1213  cfg = c;
1214  if (GNUNET_OK !=
1216  "CADET",
1217  "RATCHET_MESSAGES",
1218  &ratchet_messages))
1219  {
1221  "CADET",
1222  "RATCHET_MESSAGES",
1223  "needs to be a number");
1224  ratchet_messages = 64;
1225  }
1226  if (GNUNET_OK !=
1228  "CADET",
1229  "RATCHET_TIME",
1230  &ratchet_time))
1231  {
1233  "CADET",
1234  "RATCHET_TIME",
1235  "need delay value");
1237  }
1238  if (GNUNET_OK !=
1240  "CADET",
1241  "REFRESH_CONNECTION_TIME",
1242  &keepalive_period))
1243  {
1245  "CADET",
1246  "REFRESH_CONNECTION_TIME",
1247  "need delay value");
1249  }
1250  if (GNUNET_OK !=
1252  "CADET",
1253  "DROP_PERCENT",
1254  &drop_percent))
1255  {
1256  drop_percent = 0;
1257  }
1258  else
1259  {
1260  LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1261  LOG (GNUNET_ERROR_TYPE_WARNING, "Cadet is running with DROP enabled.\n");
1262  LOG (GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n");
1263  LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
1264  LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1265  }
1267  if (NULL == my_private_key)
1268  {
1269  GNUNET_break (0);
1271  return;
1272  }
1275  stats = GNUNET_STATISTICS_create ("cadet",
1276  c);
1278  NULL);
1280  /* FIXME: optimize code to allow GNUNET_YES here! */
1282  GNUNET_NO);
1284  GNUNET_NO);
1286  GNUNET_YES);
1288  GNUNET_YES);
1289  GCH_init (c);
1290  GCD_init (c);
1291  GCO_init (c);
1293  "CADET started for peer %s\n",
1294  GNUNET_i2s (&my_full_id));
1295 
1296 }
int GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
#define GNUNET_TIME_UNIT_HOURS
One hour.
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.
struct GNUNET_CONTAINER_MultiPeerMap * peers
Map from PIDs to struct CadetPeer entries.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
struct GNUNET_ATS_ConnectivityHandle * ats_ch
Handle to communicate with ATS.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
void GNUNET_log_config_invalid(enum GNUNET_ErrorType kind, const char *section, const char *option, const char *required)
Log error message about invalid configuration option value.
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).
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
struct GNUNET_CONTAINER_MultiShortmap * connections
Map from struct GNUNET_CADET_ConnectionTunnelIdentifier hash codes to struct CadetConnection objects...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_CONTAINER_MultiHashMap * open_ports
All ports clients of this peer have opened.
struct GNUNET_CONTAINER_MultiHashMap * loose_channels
Map from ports to channels where the ports were closed at the time we got the inbound connection...
struct GNUNET_TIME_Relative ratchet_time
How long until we trigger a ratched advance due to time.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
#define LOG(level,...)
static void shutdown_task(void *cls)
Task run during shutdown.
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).
unsigned long long drop_percent
Set to non-zero values to create random drops to test retransmissions.
unsigned long long ratchet_messages
How many messages are needed to trigger an AXOLOTL ratchet advance.
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:272
struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Own private key.
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
void GCD_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize the DHT subsystem.
#define GNUNET_log(kind,...)
const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer&#39;s key from the file specified in the configuration...
struct GNUNET_TIME_Relative keepalive_period
How frequently do we send KEEPALIVE messages on idle connections?
#define GNUNET_YES
Definition: gnunet_common.h:80
void GCO_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize the CORE subsystem.
void GCH_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize the hello subsystem.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

Define "main" method using service macro.

Referenced by run().

Here is the caller graph for this function:

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

Handle to our configuration.

Definition at line 111 of file gnunet-service-cadet.c.

◆ stats

struct GNUNET_STATISTICS_Handle* stats

Handle to the statistics service.

Definition at line 116 of file gnunet-service-cadet.c.

◆ ats_ch

Handle to communicate with ATS.

Definition at line 121 of file gnunet-service-cadet.c.

◆ my_full_id

struct GNUNET_PeerIdentity my_full_id

◆ my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey* my_private_key

Own private key.

Definition at line 131 of file gnunet-service-cadet.c.

Referenced by GCT_handle_kx_auth(), send_kx(), send_kx_auth(), and update_ax_by_kx().

◆ shutting_down

int shutting_down

Signal that shutdown is happening: prevent recovery measures.

Definition at line 136 of file gnunet-service-cadet.c.

Referenced by client_disconnect_cb(), GCT_destroy_tunnel_now(), and shutdown_task().

◆ clients_head

struct CadetClient* clients_head
static

DLL with all the clients, head.

Definition at line 141 of file gnunet-service-cadet.c.

◆ clients_tail

struct CadetClient* clients_tail
static

DLL with all the clients, tail.

Definition at line 146 of file gnunet-service-cadet.c.

◆ next_client_id

unsigned int next_client_id
static

Next ID to assign to a client.

Definition at line 151 of file gnunet-service-cadet.c.

Referenced by client_connect_cb().

◆ open_ports

struct GNUNET_CONTAINER_MultiHashMap* open_ports

All ports clients of this peer have opened.

Maps from a hashed port to a struct OpenPort.

Definition at line 157 of file gnunet-service-cadet.c.

Referenced by GCCH_channel_incoming_new(), and GCCH_channel_local_new().

◆ loose_channels

struct GNUNET_CONTAINER_MultiHashMap* loose_channels

Map from ports to channels where the ports were closed at the time we got the inbound connection.

Indexed by h_port, contains struct CadetChannel.

Definition at line 164 of file gnunet-service-cadet.c.

Referenced by GCCH_channel_incoming_new(), and GCCH_channel_local_new().

◆ peers

Map from PIDs to struct CadetPeer entries.

Definition at line 169 of file gnunet-service-cadet.c.

◆ connections

struct GNUNET_CONTAINER_MultiShortmap* connections

Map from struct GNUNET_CADET_ConnectionTunnelIdentifier hash codes to struct CadetConnection objects.

Definition at line 175 of file gnunet-service-cadet.c.

Referenced by connect_nse_service(), connection_create(), GCC_destroy(), and GCC_lookup().

◆ ratchet_messages

unsigned long long ratchet_messages

How many messages are needed to trigger an AXOLOTL ratchet advance.

Definition at line 180 of file gnunet-service-cadet.c.

Referenced by run().

◆ ratchet_time

struct GNUNET_TIME_Relative ratchet_time

How long until we trigger a ratched advance due to time.

Definition at line 185 of file gnunet-service-cadet.c.

Referenced by run(), t_ax_encrypt(), and update_ax_by_kx().

◆ keepalive_period

struct GNUNET_TIME_Relative keepalive_period

How frequently do we send KEEPALIVE messages on idle connections?

Definition at line 190 of file gnunet-service-cadet.c.

Referenced by GCC_handle_connection_create_ack(), handle_connection_create(), keepalive_done(), manage_first_hop_mq(), run(), send_create_ack(), send_keepalive(), and timeout_cb().

◆ drop_percent

unsigned long long drop_percent

Set to non-zero values to create random drops to test retransmissions.

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

Referenced by get_channel_weight(), run(), and should_I_drop().