GNUnet 0.21.1
gnunet-service-cadet_connection.c File Reference

management of CORE-level end-to-end connections; establishes end-to-end routes and transmits messages along the route More...

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

Go to the source code of this file.

Data Structures

struct  CadetConnection
 Low-level connection to a destination. More...
 

Macros

#define LOG(level, ...)   GNUNET_log_from (level, "cadet-con", __VA_ARGS__)
 
#define INITIAL_CONNECTION_CREATE_RETRY_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 200)
 How long do we wait initially before retransmitting the KX? TODO: replace by 2 RTT if/once we have connection-level RTT data! More...
 
#define LOG2(level, ...)    GNUNET_log_from_nocheck (level, "cadet-con", __VA_ARGS__)
 

Enumerations

enum  CadetConnectionState {
  CADET_CONNECTION_NEW , CADET_CONNECTION_SENDING_CREATE , CADET_CONNECTION_SENT , CADET_CONNECTION_CREATE_RECEIVED ,
  CADET_CONNECTION_READY
}
 All the states a connection can be in. More...
 

Functions

struct CadetConnectionGCC_lookup (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
 Lookup a connection by its identifier. More...
 
static void update_state (struct CadetConnection *cc, enum CadetConnectionState new_state, int new_mqm_ready)
 Update the connection state. More...
 
static void GCC_destroy (struct CadetConnection *cc)
 Destroy a connection, part of the internal implementation. More...
 
void GCC_destroy_without_core (struct CadetConnection *cc)
 Destroy a connection, called when the CORE layer is already done (i.e. More...
 
void GCC_destroy_without_tunnel (struct CadetConnection *cc)
 Destroy a connection, called if the tunnel association with the connection was already broken, but we still need to notify the CORE layer about the breakage. More...
 
struct CadetTConnectionGCC_get_ct (struct CadetConnection *cc)
 Return the tunnel associated with this connection. More...
 
const struct CadetConnectionMetricsGCC_get_metrics (struct CadetConnection *cc)
 Obtain performance metrics from cc. More...
 
static void send_keepalive (void *cls)
 Send a GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE through the tunnel to prevent it from timing out. More...
 
static void keepalive_done (void *cls, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
 Keepalive was transmitted. More...
 
void GCC_ack_expected (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
 We sent a message for which we expect to receive an ACK via the connection identified by cti. More...
 
void GCC_ack_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
 We observed an ACK for a message that was originally sent via the connection identified by cid. More...
 
void GCC_latency_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, struct GNUNET_TIME_Relative latency)
 We observed some the given latency on the connection identified by cti. More...
 
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. More...
 
void GCC_handle_kx (struct CadetConnection *cc, const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg)
 Handle KX message. More...
 
void GCC_handle_kx_auth (struct CadetConnection *cc, const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
 Handle KX_AUTH message. More...
 
void GCC_handle_encrypted (struct CadetConnection *cc, const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
 Handle encrypted message. More...
 
void set_monotime_sig (struct GNUNET_CADET_ConnectionCreateMessage *msg)
 Set the signature for a monotime value on a GNUNET_CADET_ConnectionCreateMessage. More...
 
static void send_create (void *cls)
 Send a GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE message to the first hop. More...
 
static void send_create_ack (void *cls)
 Send a CREATE_ACK message towards the origin. More...
 
void GCC_handle_duplicate_create (struct CadetConnection *cc)
 We got a GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE for a connection that we already have. More...
 
static void manage_first_hop_mq (void *cls, int available)
 There has been a change in the message queue existence for our peer at the first hop. More...
 
static struct CadetConnectionconnection_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. More...
 
struct CadetConnectionGCC_create_inbound (struct CadetPeer *destination, struct CadetPeerPath *path, struct CadetTConnection *ct, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, 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. More...
 
struct CadetConnectionGCC_create (struct CadetPeer *destination, struct CadetPeerPath *path, unsigned int off, struct CadetTConnection *ct, 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. More...
 
void GCC_transmit (struct CadetConnection *cc, struct GNUNET_MQ_Envelope *env)
 Transmit message msg via connection cc. More...
 
struct CadetPeerPathGCC_get_path (struct CadetConnection *cc, unsigned int *off)
 Obtain the path used by this connection. More...
 
const struct GNUNET_CADET_ConnectionTunnelIdentifierGCC_get_id (struct CadetConnection *cc)
 Obtain unique ID for the connection. More...
 
const char * GCC_2s (const struct CadetConnection *cc)
 Get a (static) string for a connection. More...
 
void GCC_debug (struct CadetConnection *cc, enum GNUNET_ErrorType level)
 Log connection info. More...
 

Detailed Description

management of CORE-level end-to-end connections; establishes end-to-end routes and transmits messages along the route

Author
Bartlomiej Polot
Christian Grothoff

Definition in file gnunet-service-cadet_connection.c.

Macro Definition Documentation

◆ LOG

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

Definition at line 39 of file gnunet-service-cadet_connection.c.

◆ INITIAL_CONNECTION_CREATE_RETRY_DELAY

#define INITIAL_CONNECTION_CREATE_RETRY_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 200)

How long do we wait initially before retransmitting the KX? TODO: replace by 2 RTT if/once we have connection-level RTT data!

Definition at line 46 of file gnunet-service-cadet_connection.c.

◆ LOG2

#define LOG2 (   level,
  ... 
)     GNUNET_log_from_nocheck (level, "cadet-con", __VA_ARGS__)

Definition at line 1040 of file gnunet-service-cadet_connection.c.

Enumeration Type Documentation

◆ CadetConnectionState

All the states a connection can be in.

Enumerator
CADET_CONNECTION_NEW 

Uninitialized status, we have not yet even gotten the message queue.

CADET_CONNECTION_SENDING_CREATE 

Connection create message in queue, awaiting transmission by CORE.

CADET_CONNECTION_SENT 

Connection create message sent, waiting for ACK.

CADET_CONNECTION_CREATE_RECEIVED 

We are an inbound connection, and received a CREATE.

Need to send an CREATE_ACK back.

CADET_CONNECTION_READY 

Connection confirmed, ready to carry traffic.

Definition at line 53 of file gnunet-service-cadet_connection.c.

54{
59
64
69
75
80};
@ CADET_CONNECTION_NEW
Uninitialized status, we have not yet even gotten the message queue.
@ CADET_CONNECTION_READY
Connection confirmed, ready to carry traffic.
@ CADET_CONNECTION_SENDING_CREATE
Connection create message in queue, awaiting transmission by CORE.
@ CADET_CONNECTION_CREATE_RECEIVED
We are an inbound connection, and received a CREATE.
@ CADET_CONNECTION_SENT
Connection create message sent, waiting for ACK.

Function Documentation

◆ GCC_lookup()

struct CadetConnection * GCC_lookup ( const struct GNUNET_CADET_ConnectionTunnelIdentifier cid)

Lookup a connection by its identifier.

Parameters
cididentifier to resolve
Returns
NULL if connection was not found

Definition at line 186 of file gnunet-service-cadet_connection.c.

187{
190}
struct GNUNET_CONTAINER_MultiShortmap * connections
Map from struct GNUNET_CADET_ConnectionTunnelIdentifier hash codes to struct CadetConnection objects.
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

References CadetConnection::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, connections, and GNUNET_CONTAINER_multishortmap_get().

Referenced by data_sent_cb(), GCC_ack_expected(), GCC_ack_observed(), GCC_latency_observed(), handle_connection_broken(), handle_connection_create(), handle_connection_create_ack(), handle_connection_destroy(), handle_tunnel_encrypted(), handle_tunnel_kx(), and handle_tunnel_kx_auth().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ update_state()

static void update_state ( struct CadetConnection cc,
enum CadetConnectionState  new_state,
int  new_mqm_ready 
)
static

Update the connection state.

Also triggers the necessary MQM notifications.

Parameters
ccconnection to update the state for
new_statenew state for cc
new_mqm_readynew mqm_ready state for cc

Definition at line 202 of file gnunet-service-cadet_connection.c.

205{
206 int old_ready;
207 int new_ready;
208
210 "Trying to update connection state for %s having old state %d to new %d and mqm_ready old %d to mqm_ready new %d\n",
211 GCT_2s (cc->ct->t),
212 cc->state,
213 new_state,
214 cc->mqm_ready,
215 new_mqm_ready);
216
217 if ((new_state == cc->state) && (new_mqm_ready == cc->mqm_ready))
218 return; /* no change, nothing to do */
219 old_ready =
220 ((CADET_CONNECTION_READY == cc->state) && (GNUNET_YES == cc->mqm_ready));
221 new_ready =
222 ((CADET_CONNECTION_READY == new_state) && (GNUNET_YES == new_mqm_ready));
223 cc->state = new_state;
224 cc->mqm_ready = new_mqm_ready;
225
227 "Updating connection state for %s having old_ready %d and new_rady %d\n",
228 GCT_2s (cc->ct->t),
229 old_ready,
230 new_ready);
231
232 if (old_ready != new_ready)
233 cc->ready_cb (cc->ready_cb_cls, new_ready);
234}
#define LOG(level,...)
const char * GCT_2s(const struct CadetTunnel *t)
Get the static string for the peer this tunnel is directed.
@ GNUNET_YES
@ GNUNET_ERROR_TYPE_DEBUG
struct CadetTConnection * ct
Which tunnel is using this connection?
GCC_ReadyCallback ready_cb
Function to call once we are ready to transmit.
void * ready_cb_cls
Closure for ready_cb.
enum CadetConnectionState state
State of the connection.
int mqm_ready
Are we ready to transmit via mq_man right now?
struct CadetTunnel * t
Tunnel this connection belongs to.

References CADET_CONNECTION_READY, CadetConnection::ct, GCT_2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_YES, LOG, CadetConnection::mqm_ready, CadetConnection::ready_cb, CadetConnection::ready_cb_cls, CadetConnection::state, and CadetTConnection::t.

Referenced by GCC_handle_connection_create_ack(), GCC_handle_duplicate_create(), manage_first_hop_mq(), send_create(), and send_create_ack().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_destroy()

static void GCC_destroy ( struct CadetConnection cc)
static

Destroy a connection, part of the internal implementation.

Called only from #GCC_destroy_from_core() or #GCC_destroy_from_tunnel().

Parameters
ccconnection to destroy

Definition at line 244 of file gnunet-service-cadet_connection.c.

245{
246 LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying %s\n", GCC_2s (cc));
247 if (NULL != cc->mq_man)
248 {
249 GCP_request_mq_cancel (cc->mq_man, NULL);
250 cc->mq_man = NULL;
251 }
252 if (NULL != cc->task)
253 {
255 cc->task = NULL;
256 }
257 if (NULL != cc->keepalive_qe)
258 {
260 cc->keepalive_qe = NULL;
261 }
262 GCPP_del_connection (cc->path, cc->off, cc);
263 for (unsigned int i = 0; i < cc->off; i++)
266 GNUNET_YES ==
268 &GCC_get_id (cc)
269 ->connection_of_tunnel,
270 cc));
271 GNUNET_free (cc);
272}
const char * GCC_2s(const struct CadetConnection *cc)
Get a (static) string for a connection.
const struct GNUNET_CADET_ConnectionTunnelIdentifier * GCC_get_id(struct CadetConnection *cc)
Obtain unique ID for the connection.
void GCPP_del_connection(struct CadetPeerPath *path, unsigned int off, struct CadetConnection *cc)
Notify path that it is no longer used for connection cc which ended at the path's offset off.
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
void GCP_request_mq_cancel(struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *last_env)
Stops message queue change notifications.
void GCP_remove_connection(struct CadetPeer *cp, struct CadetConnection *cc)
Remove a connection that went via this cp.
void GCT_send_cancel(struct CadetTunnelQueueEntry *tq)
Cancel a previously sent message while it's in the queue.
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.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:981
struct GNUNET_SCHEDULER_Task * task
Task for connection maintenance.
struct CadetPeerPath * path
Path we are using to our destination.
unsigned int off
Offset of our destination in path.
struct GCP_MessageQueueManager * mq_man
Handle for calling GCP_request_mq_cancel() once we are finished.
struct CadetTunnelQueueEntry * keepalive_qe
Queue entry for keepalive messages.

References connections, GCC_2s(), GCC_get_id(), GCP_remove_connection(), GCP_request_mq_cancel(), GCPP_del_connection(), GCPP_get_peer_at_offset(), GCT_send_cancel(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_YES, CadetConnection::keepalive_qe, LOG, CadetConnection::mq_man, CadetConnection::off, CadetConnection::path, and CadetConnection::task.

Referenced by GCC_destroy_without_core(), and GCC_destroy_without_tunnel().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_destroy_without_core()

void GCC_destroy_without_core ( struct CadetConnection cc)

Destroy a connection, called when the CORE layer is already done (i.e.

has received a BROKEN message), but if we still have to communicate the destruction of the connection to the tunnel (if one exists).

Parameters
ccconnection to destroy

Definition at line 284 of file gnunet-service-cadet_connection.c.

285{
286 if (NULL != cc->ct)
287 {
289 cc->ct = NULL;
290 }
291 GCC_destroy (cc);
292}
static void GCC_destroy(struct CadetConnection *cc)
Destroy a connection, part of the internal implementation.
void GCT_connection_lost(struct CadetTConnection *ct)
We lost a connection, remove it from our list and clean up the connection object itself.

References CadetConnection::ct, GCC_destroy(), and GCT_connection_lost().

Referenced by handle_connection_broken(), and handle_connection_destroy().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_destroy_without_tunnel()

void GCC_destroy_without_tunnel ( struct CadetConnection cc)

Destroy a connection, called if the tunnel association with the connection was already broken, but we still need to notify the CORE layer about the breakage.

Parameters
ccconnection to destroy

Definition at line 303 of file gnunet-service-cadet_connection.c.

304{
305 cc->ct = NULL;
306 if ((CADET_CONNECTION_SENDING_CREATE != cc->state) && (NULL != cc->mq_man))
307 {
308 struct GNUNET_MQ_Envelope *env;
309 struct GNUNET_CADET_ConnectionDestroyMessage *destroy_msg;
310
311 /* Need to notify next hop that we are down. */
312 env =
314 destroy_msg->cid = cc->cid;
316 cc->mq_man = NULL;
317 }
318 GCC_destroy (cc);
319}
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY
Request the destruction of a connection.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
Message to destroy a connection.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.

References CADET_CONNECTION_SENDING_CREATE, GNUNET_CADET_ConnectionDestroyMessage::cid, CadetConnection::cid, CadetConnection::ct, env, GCC_destroy(), GCP_request_mq_cancel(), GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY, GNUNET_MQ_msg, CadetConnection::mq_man, and CadetConnection::state.

Referenced by destroy_t_connection(), and GCC_create_inbound().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_get_ct()

struct CadetTConnection * GCC_get_ct ( struct CadetConnection cc)

Return the tunnel associated with this connection.

Parameters
ccconnection to query
Returns
corresponding entry in the tunnel's connection list

Definition at line 329 of file gnunet-service-cadet_connection.c.

330{
331 return cc->ct;
332}

References CadetTConnection::cc, and CadetConnection::ct.

◆ GCC_get_metrics()

const struct CadetConnectionMetrics * GCC_get_metrics ( struct CadetConnection cc)

Obtain performance metrics from cc.

Parameters
ccconnection to query
Returns
the metrics

Definition at line 342 of file gnunet-service-cadet_connection.c.

343{
344 return &cc->metrics;
345}
struct CadetConnectionMetrics metrics
Performance metrics for this connection.

References CadetConnection::metrics.

Referenced by data_sent_cb(), and evaluate_connection().

Here is the caller graph for this function:

◆ send_keepalive()

static void send_keepalive ( void *  cls)
static

Send a GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE through the tunnel to prevent it from timing out.

Parameters
clsthe struct CadetConnection to keep alive.

Definition at line 386 of file gnunet-service-cadet_connection.c.

387{
388 struct CadetConnection *cc = cls;
390
391 cc->task = NULL;
393 {
394 /* Tunnel not yet ready, wait with keepalives... */
395 cc->task =
397 return;
398 }
399 GNUNET_assert (NULL != cc->ct);
401 GNUNET_assert (NULL == cc->keepalive_qe);
403 "Sending KEEPALIVE on behalf of %s via %s\n",
404 GCC_2s (cc),
405 GCT_2s (cc->ct->t));
406 GNUNET_STATISTICS_update (stats, "# keepalives sent", 1, GNUNET_NO);
407 msg.size = htons (sizeof(msg));
409
410 cc->keepalive_qe = GCT_send (cc->ct->t, &msg, &keepalive_done, cc, NULL);
411}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_TIME_Relative keepalive_period
How frequently do we send KEEPALIVE messages on idle connections?
static void keepalive_done(void *cls, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Keepalive was transmitted.
static void send_keepalive(void *cls)
Send a GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE through the tunnel to prevent it from timing out.
struct CadetTunnelQueueEntry * GCT_send(struct CadetTunnel *t, const struct GNUNET_MessageHeader *message, GCT_SendContinuation cont, void *cont_cls, struct GNUNET_CADET_ChannelTunnelNumber *ctn)
Sends an already built message on a tunnel, encrypting it and choosing the best connection if not pro...
enum CadetTunnelEState GCT_get_estate(struct CadetTunnel *t)
Get the encryption state of a tunnel.
@ CADET_TUNNEL_KEY_OK
Handshake completed: session key available.
static struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_NO
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE
Announce connection is still alive (direction sensitive).
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:1278
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
Low-level connection to a destination.
Header for all communications.

References CADET_TUNNEL_KEY_OK, CadetConnection::ct, GCC_2s(), GCT_2s(), GCT_get_estate(), GCT_send(), GNUNET_assert, GNUNET_ERROR_TYPE_INFO, GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_YES, keepalive_done(), keepalive_period, CadetConnection::keepalive_qe, LOG, CadetConnection::mqm_ready, msg, send_keepalive(), GNUNET_MessageHeader::size, stats, CadetTConnection::t, CadetConnection::task, and GNUNET_MessageHeader::type.

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ keepalive_done()

static void keepalive_done ( void *  cls,
const struct GNUNET_CADET_ConnectionTunnelIdentifier cid 
)
static

Keepalive was transmitted.

Remember this, and possibly schedule the next one.

Parameters
clsthe struct CadetConnection to keep alive.
cididentifier of the connection within the tunnel, NULL if transmission failed

Definition at line 367 of file gnunet-service-cadet_connection.c.

369{
370 struct CadetConnection *cc = cls;
371
372 cc->keepalive_qe = NULL;
373 if ((GNUNET_YES == cc->mqm_ready) && (NULL == cc->task))
374 cc->task =
376}

References GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, keepalive_period, CadetConnection::keepalive_qe, CadetConnection::mqm_ready, send_keepalive(), and CadetConnection::task.

Referenced by send_keepalive().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_ack_expected()

void GCC_ack_expected ( const struct GNUNET_CADET_ConnectionTunnelIdentifier cid)

We sent a message for which we expect to receive an ACK via the connection identified by cti.

Parameters
cidconnection identifier where we expect an ACK

Definition at line 421 of file gnunet-service-cadet_connection.c.

422{
423 struct CadetConnection *cc;
424
425 cc = GCC_lookup (cid);
426 if (NULL == cc)
427 return; /* whopise, connection already down? */
429}
struct CadetConnection * GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Lookup a connection by its identifier.
unsigned long long num_acked_transmissions
How many packets that ought to generate an ACK did we send via this connection?

References CadetConnection::cid, GCC_lookup(), CadetConnection::metrics, and CadetConnectionMetrics::num_acked_transmissions.

Referenced by data_sent_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_ack_observed()

void GCC_ack_observed ( const struct GNUNET_CADET_ConnectionTunnelIdentifier cid)

We observed an ACK for a message that was originally sent via the connection identified by cid.

We observed an ACK for a message that was originally sent via the connection identified by cti.

Parameters
cidconnection identifier where we got an ACK for a message that was originally sent via this connection (the ACK may have gotten back to us via a different connection).

Definition at line 441 of file gnunet-service-cadet_connection.c.

442{
443 struct CadetConnection *cc;
444
445 cc = GCC_lookup (cid);
446 if (NULL == cc)
447 return; /* whopise, connection already down? */
449}
unsigned long long num_successes
Number of packets that were sent via this connection did actually receive an ACK? (Note: ACKs may be ...

References CadetConnection::cid, GCC_lookup(), CadetConnection::metrics, and CadetConnectionMetrics::num_successes.

Referenced by handle_matching_ack().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_latency_observed()

void GCC_latency_observed ( const struct GNUNET_CADET_ConnectionTunnelIdentifier cti,
struct GNUNET_TIME_Relative  latency 
)

We observed some the given latency on the connection identified by cti.

(The same connection was taken in both directions.)

Parameters
cticonnection identifier where we measured latency
latencythe observed latency

Definition at line 453 of file gnunet-service-cadet_connection.c.

455{
456 struct CadetConnection *cc;
457 double weight;
458 double result;
459
460 cc = GCC_lookup (cid);
461 if (NULL == cc)
462 return; /* whopise, connection already down? */
463 GNUNET_STATISTICS_update (stats, "# latencies observed", 1, GNUNET_NO);
464 cc->latency_datapoints++;
465 if (cc->latency_datapoints >= 7)
466 weight = 7.0;
467 else
468 weight = cc->latency_datapoints;
469 /* Compute weighted average, giving at MOST weight 7 to the
470 existing values, or less if that value is based on fewer than 7
471 measurements. */
472 result = (weight * cc->metrics.aged_latency.rel_value_us)
473 + 1.0 * latency.rel_value_us;
474 result /= (weight + 1.0);
475 cc->metrics.aged_latency.rel_value_us = (uint64_t) result;
476}
static int result
Global testing status.
struct GNUNET_TIME_Relative aged_latency
Our current best estimate of the latency, based on a weighted average of at least latency_datapoints ...
unsigned int latency_datapoints
How many latency observations did we make for this connection?
uint64_t rel_value_us
The actual value.

References CadetConnectionMetrics::aged_latency, CadetConnection::cid, GCC_lookup(), GNUNET_NO, GNUNET_STATISTICS_update(), CadetConnection::latency_datapoints, CadetConnection::metrics, GNUNET_TIME_Relative::rel_value_us, result, and stats.

Referenced by handle_matching_ack().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_handle_connection_create_ack()

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.

Process it.

Parameters
ccthe connection that got the ACK.

Definition at line 480 of file gnunet-service-cadet_connection.c.

481{
483 "Received CADET_CONNECTION_CREATE_ACK for %s in state %d (%s)\n",
484 GCC_2s (cc),
485 cc->state,
486 (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy");
487 if (CADET_CONNECTION_READY == cc->state)
488 return; /* Duplicate ACK, ignore */
489 if (NULL != cc->task)
490 {
492 cc->task = NULL;
493 }
496 if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) &&
497 (NULL == cc->task))
498 cc->task =
500}
static void update_state(struct CadetConnection *cc, enum CadetConnectionState new_state, int new_mqm_ready)
Update the connection state.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_Absolute age
When was this connection first established? (by us sending or receiving the CREATE_ACK for the first ...

References CadetConnectionMetrics::age, CADET_CONNECTION_READY, GCC_2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), GNUNET_YES, keepalive_period, CadetConnection::keepalive_qe, LOG, CadetConnection::metrics, CadetConnection::mqm_ready, send_keepalive(), CadetConnection::state, CadetConnection::task, and update_state().

Referenced by GCC_handle_encrypted(), GCC_handle_kx(), GCC_handle_kx_auth(), and handle_connection_create_ack().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_handle_kx()

void GCC_handle_kx ( struct CadetConnection cc,
const struct GNUNET_CADET_TunnelKeyExchangeMessage msg 
)

Handle KX message.

Parameters
ccconnection that received encrypted message
msgthe key exchange message

Definition at line 510 of file gnunet-service-cadet_connection.c.

512{
514 "Received KX message with ephermal %s on CC %s in state %d\n",
515 GNUNET_e2s (&msg->ephemeral_key),
517 cc->state);
518 if (CADET_CONNECTION_SENT == cc->state)
519 {
520 /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine,
521 clearly something is working, so pretend we got an ACK. */
523 "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n",
524 GCC_2s (cc));
526 }
527 GCT_handle_kx (cc->ct, msg);
528}
void GCC_handle_connection_create_ack(struct CadetConnection *cc)
A GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK was received for this connection,...
void GCT_handle_kx(struct CadetTConnection *ct, const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg)
Handle KX message that lacks authentication (and which will thus only be considered authenticated aft...
const char * GNUNET_e2s(const struct GNUNET_CRYPTO_EcdhePublicKey *p)
Convert a public key value to a string (for printing debug messages).
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).

References CADET_CONNECTION_SENT, CadetConnection::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, CadetConnection::ct, GCC_2s(), GCC_handle_connection_create_ack(), GCT_handle_kx(), GNUNET_e2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_sh2s(), LOG, msg, and CadetConnection::state.

Referenced by handle_tunnel_kx().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_handle_kx_auth()

void GCC_handle_kx_auth ( struct CadetConnection cc,
const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage msg 
)

Handle KX_AUTH message.

Parameters
ccconnection that received encrypted message
msgthe key exchange message

Definition at line 538 of file gnunet-service-cadet_connection.c.

540{
542 "Received KX AUTH message with ephermal %s on CC %s in state %d\n",
543 GNUNET_e2s (&msg->kx.ephemeral_key),
545 cc->state);
546 if (CADET_CONNECTION_SENT == cc->state)
547 {
548 /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine,
549 clearly something is working, so pretend we got an ACK. */
551 "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n",
552 GCC_2s (cc));
554 }
556}
void GCT_handle_kx_auth(struct CadetTConnection *ct, const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
Handle KX_AUTH message.

References CADET_CONNECTION_SENT, CadetConnection::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, CadetConnection::ct, GCC_2s(), GCC_handle_connection_create_ack(), GCT_handle_kx_auth(), GNUNET_e2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_sh2s(), LOG, msg, and CadetConnection::state.

Referenced by handle_tunnel_kx_auth().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_handle_encrypted()

void GCC_handle_encrypted ( struct CadetConnection cc,
const struct GNUNET_CADET_TunnelEncryptedMessage msg 
)

Handle encrypted message.

Parameters
ccconnection that received encrypted message
msgthe encrypted message to decrypt

Definition at line 566 of file gnunet-service-cadet_connection.c.

568{
569 if (CADET_CONNECTION_SENT == cc->state)
570 {
571 /* We didn't get the CREATE_ACK, but instead got payload. That's fine,
572 clearly something is working, so pretend we got an ACK. */
574 "Faking connection ACK for %s due to ENCRYPTED payload\n",
575 GCC_2s (cc));
577 }
580}
void GCT_handle_encrypted(struct CadetTConnection *ct, const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
Handle encrypted message.
struct GNUNET_TIME_Absolute last_use
When was this connection last used? (by us sending or receiving a PAYLOAD message on it)

References CADET_CONNECTION_SENT, CadetConnection::ct, GCC_2s(), GCC_handle_connection_create_ack(), GCT_handle_encrypted(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_TIME_absolute_get(), CadetConnectionMetrics::last_use, LOG, CadetConnection::metrics, msg, and CadetConnection::state.

Referenced by handle_tunnel_encrypted().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ set_monotime_sig()

void set_monotime_sig ( struct GNUNET_CADET_ConnectionCreateMessage msg)

Set the signature for a monotime value on a GNUNET_CADET_ConnectionCreateMessage.

Parameters
msgThe GNUNET_CADET_ConnectionCreateMessage.

Definition at line 589 of file gnunet-service-cadet_connection.c.

590{
591
592 struct CadetConnectionCreatePS cp = { .purpose.purpose = htonl (
594 .purpose.size = htonl (sizeof(cp)),
595 .monotonic_time = msg->monotime};
596
598 &msg->monotime_sig);
599
600}
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Our private key.
Definition: gnunet-hello.c:96
#define GNUNET_CRYPTO_eddsa_sign(priv, ps, sig)
EdDSA sign a given block.
#define GNUNET_SIGNATURE_PURPOSE_CADET_CONNECTION_INITIATOR
Signature by a peer that like to create a connection.
Purpose for the signature of a monotime.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose is GNUNET_SIGNATURE_PURPOSE_CADET_CONNECTION_INITIATOR.
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...

References GNUNET_CRYPTO_eddsa_sign, GNUNET_SIGNATURE_PURPOSE_CADET_CONNECTION_INITIATOR, msg, my_private_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, and CadetConnectionCreatePS::purpose.

Referenced by send_create().

Here is the caller graph for this function:

◆ send_create()

static void send_create ( void *  cls)
static

Send a GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE message to the first hop.

Parameters
clsthe struct CadetConnection to initiate

Definition at line 610 of file gnunet-service-cadet_connection.c.

611{
612 struct CadetConnection *cc = cls;
613 struct GNUNET_CADET_ConnectionCreateMessage *create_msg;
614 struct GNUNET_PeerIdentity *pids;
615 struct GNUNET_MQ_Envelope *env;
616 struct CadetTunnel *t;
617
618 cc->task = NULL;
620 env =
621 GNUNET_MQ_msg_extra (create_msg,
622 (2 + cc->off) * sizeof(struct GNUNET_PeerIdentity),
624 // TODO This will be removed in a major release, because this will be a protocol breaking change. We set the deprecated 'reliable' bit here that was removed.
625 create_msg->options = 2;
626 create_msg->cid = cc->cid;
627
628 // check for tunnel state and set signed monotime (xrs,t3ss)
630 if ((NULL != t) && (GCT_get_estate (t) == CADET_TUNNEL_KEY_UNINITIALIZED) &&
632 {
633 create_msg->has_monotime = GNUNET_YES;
634 create_msg->monotime = GNUNET_TIME_absolute_hton (
636 set_monotime_sig (create_msg);
637 }
638
639 pids = (struct GNUNET_PeerIdentity *) &create_msg[1];
640 pids[0] = my_full_id;
641 for (unsigned int i = 0; i <= cc->off; i++)
642 pids[i + 1] = *GCP_get_id (GCPP_get_peer_at_offset (cc->path, i));
644 "Sending CADET_CONNECTION_CREATE message for %s with %u hops\n",
645 GCC_2s (cc),
646 cc->off + 2);
647 cc->env = env;
651 GCP_send (cc->mq_man, env);
652}
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
Definition: gnunet-hello.c:101
void set_monotime_sig(struct GNUNET_CADET_ConnectionCreateMessage *msg)
Set the signature for a monotime value on a GNUNET_CADET_ConnectionCreateMessage.
const struct GNUNET_PeerIdentity * GCP_get_id(struct CadetPeer *cp)
Obtain the peer identity for a struct CadetPeer.
struct CadetTunnel * GCP_get_tunnel(struct CadetPeer *cp, int create)
Get the tunnel towards a peer.
void GCP_send(struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *env)
Send the message in env to cp.
int GCT_alice_or_betty(const struct GNUNET_PeerIdentity *other)
Am I Alice or Betty (some call her Bob), or talking to myself?
@ CADET_TUNNEL_KEY_UNINITIALIZED
Uninitialized status, we need to send KX.
static struct GNUNET_SCHEDULER_Task * t
Main task.
#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:63
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE
Request the creation of a connection.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_monotonic(const struct GNUNET_CONFIGURATION_Handle *cfg)
Obtain the current time and make sure it is monotonically increasing.
Definition: time.c:860
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
struct GNUNET_MQ_Envelope * env
Pending message, NULL if we are ready to transmit.
struct GNUNET_TIME_Absolute create_at
Earliest time for re-trying CREATE.
struct GNUNET_TIME_Relative retry_delay
How long do we wait before we try again with a CREATE message?
struct CadetPeer * destination
To which peer does this connection go?
Struct containing all information regarding a tunnel to a peer.
Message for cadet connection creation.
int has_monotime
This flag indicates the peer sending the connection create meassage likes to trigger a KX handshake.
uint32_t options
Connection options in network byte order.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
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...
The identity of the host (wraps the signing key of the peer).

References CADET_CONNECTION_SENT, CADET_TUNNEL_KEY_UNINITIALIZED, cfg, GNUNET_CADET_ConnectionCreateMessage::cid, CadetConnection::cid, CadetConnection::create_at, CadetConnection::destination, env, CadetConnection::env, GCC_2s(), GCP_get_id(), GCP_get_tunnel(), GCP_send(), GCPP_get_peer_at_offset(), GCT_alice_or_betty(), GCT_get_estate(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, GNUNET_MQ_msg_extra, GNUNET_NO, GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, GNUNET_CADET_ConnectionCreateMessage::has_monotime, LOG, GNUNET_CADET_ConnectionCreateMessage::monotime, CadetConnection::mq_man, CadetConnection::mqm_ready, my_full_id, CadetConnection::off, GNUNET_CADET_ConnectionCreateMessage::options, CadetConnection::path, CadetConnection::retry_delay, set_monotime_sig(), t, CadetConnection::task, and update_state().

Referenced by manage_first_hop_mq().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_create_ack()

static void send_create_ack ( void *  cls)
static

Send a CREATE_ACK message towards the origin.

Parameters
clsthe struct CadetConnection to initiate

Definition at line 661 of file gnunet-service-cadet_connection.c.

662{
663 struct CadetConnection *cc = cls;
665 struct GNUNET_MQ_Envelope *env;
666
667 cc->task = NULL;
669 "Sending CONNECTION_CREATE_ACK message for %s\n",
670 GCC_2s (cc));
672 env =
674 ack_msg->cid = cc->cid;
675 cc->env = env;
680 if (CADET_CONNECTION_READY == cc->state)
681 cc->task =
683 GCP_send (cc->mq_man, env);
684}
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK
Send origin an ACK that the connection is complete.
struct GNUNET_TIME_Absolute create_ack_at
Earliest time for re-trying CREATE_ACK.
Message for ack'ing a connection.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.

References CADET_CONNECTION_CREATE_RECEIVED, CADET_CONNECTION_READY, GNUNET_CADET_ConnectionCreateAckMessage::cid, CadetConnection::cid, CadetConnection::create_ack_at, env, CadetConnection::env, GCC_2s(), GCP_send(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK, GNUNET_MQ_msg, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, keepalive_period, LOG, CadetConnection::mq_man, CadetConnection::mqm_ready, CadetConnection::retry_delay, send_keepalive(), CadetConnection::state, CadetConnection::task, and update_state().

Referenced by GCC_handle_duplicate_create(), and manage_first_hop_mq().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_handle_duplicate_create()

void GCC_handle_duplicate_create ( struct CadetConnection cc)

We got a GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE for a connection that we already have.

Either our ACK got lost or something is fishy. Consider retransmitting the ACK.

Parameters
ccconnection that got the duplicate CREATE

Definition at line 695 of file gnunet-service-cadet_connection.c.

696{
697 if (GNUNET_YES == cc->mqm_ready)
698 {
700 "Got duplicate CREATE for %s, scheduling another ACK (%s)\n",
701 GCC_2s (cc),
702 (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy");
703 /* Revert back to the state of having only received the 'CREATE',
704 and immediately proceed to send the CREATE_ACK. */
706 if (NULL != cc->task)
708 cc->task =
710 }
711 else
712 {
713 /* We are currently sending something else back, which
714 can only be an ACK or payload, either of which would
715 do. So actually no need to do anything. */
717 "Got duplicate CREATE for %s. MQ is busy, not queueing another ACK\n",
718 GCC_2s (cc));
719 }
720}
static void send_create_ack(void *cls)
Send a CREATE_ACK message towards the origin.
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:1255

References CADET_CONNECTION_CREATE_RECEIVED, CadetConnection::create_ack_at, GCC_2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, LOG, CadetConnection::mqm_ready, send_create_ack(), CadetConnection::task, and update_state().

Referenced by handle_connection_create().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ manage_first_hop_mq()

static void manage_first_hop_mq ( void *  cls,
int  available 
)
static

There has been a change in the message queue existence for our peer at the first hop.

Adjust accordingly.

Parameters
clsthe struct CadetConnection
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 734 of file gnunet-service-cadet_connection.c.

735{
736 struct CadetConnection *cc = cls;
737
738 if (GNUNET_YES != available)
739 {
740 /* Connection is down, for now... */
741 LOG (GNUNET_ERROR_TYPE_DEBUG, "Core MQ for %s went down\n", GCC_2s (cc));
744 if (NULL != cc->task)
745 {
747 cc->task = NULL;
748 }
749 return;
750 }
751
752 update_state (cc, cc->state, GNUNET_YES);
754 "Core MQ for %s became available in state %d\n",
755 GCC_2s (cc),
756 cc->state);
757 switch (cc->state)
758 {
760 /* Transmit immediately */
762 break;
763
765 /* Should not be possible to be called in this state. */
766 GNUNET_assert (0);
767 break;
768
770 /* Retry a bit later... */
772 break;
773
775 /* We got the 'CREATE' (incoming connection), should send the CREATE_ACK */
777 cc->task =
779 break;
780
782 if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) &&
783 (NULL == cc->task))
784 {
786 "Scheduling keepalive for %s in %s\n",
787 GCC_2s (cc),
789 GNUNET_YES));
790 cc->task =
792 }
793 break;
794 }
795}
#define INITIAL_CONNECTION_CREATE_RETRY_DELAY
How long do we wait initially before retransmitting the KX? TODO: replace by 2 RTT if/once we have co...
static void send_create(void *cls)
Send a GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE message to the first hop.
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:570

References CadetConnectionMetrics::age, CADET_CONNECTION_CREATE_RECEIVED, CADET_CONNECTION_NEW, CADET_CONNECTION_READY, CADET_CONNECTION_SENDING_CREATE, CADET_CONNECTION_SENT, CadetConnection::create_ack_at, CadetConnection::create_at, GCC_2s(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_YES, INITIAL_CONNECTION_CREATE_RETRY_DELAY, keepalive_period, CadetConnection::keepalive_qe, LOG, CadetConnection::metrics, CadetConnection::mqm_ready, CadetConnection::retry_delay, send_create(), send_create_ack(), send_keepalive(), CadetConnection::state, CadetConnection::task, and update_state().

Referenced by connection_create().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ connection_create()

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 
)
static

Create a connection to destination via path and notify cb whenever we are ready for more data.

Shared logic independent of who is initiating the connection.

Parameters
destinationwhere to go
pathwhich path to take (may not be the full path)
offoffset of destination on path
ctwhich tunnel uses this connection
init_stateinitial state for the connection
ready_cbfunction to call when ready to transmit
ready_cb_clsclosure for cb
Returns
handle to the connection

Definition at line 813 of file gnunet-service-cadet_connection.c.

821{
822 struct CadetConnection *cc;
823 struct CadetPeer *first_hop;
824
825 cc = GNUNET_new (struct CadetConnection);
826 cc->state = init_state;
827 cc->ct = ct;
828 cc->destination = destination; /* xrs,t3ss,lurchi*/
829 cc->cid = *cid;
830 cc->retry_delay =
835 &GCC_get_id (cc)->connection_of_tunnel,
836 cc,
838 cc->ready_cb = ready_cb;
839 cc->ready_cb_cls = ready_cb_cls;
840 cc->path = path;
841 cc->off = off;
843 "Creating %s using path %s (offset: %u)\n",
844 GCC_2s (cc),
845 GCPP_2s (path),
846 off);
847 GCPP_add_connection (path, off, cc);
848 for (unsigned int i = 0; i < off; i++)
850 first_hop = GCPP_get_peer_at_offset (path, 0);
851 cc->mq_man = GCP_request_mq (first_hop, &manage_first_hop_mq, cc);
852 return cc;
853}
static void manage_first_hop_mq(void *cls, int available)
There has been a change in the message queue existence for our peer at the first hop.
const char * GCPP_2s(struct CadetPeerPath *path)
Convert a path to a human-readable string.
void GCPP_add_connection(struct CadetPeerPath *path, unsigned int off, struct CadetConnection *cc)
Notify path that it is used for connection cc which ends at the path's offset off.
void GCP_add_connection(struct CadetPeer *cp, struct CadetConnection *cc)
Add a connection to this cp.
struct GCP_MessageQueueManager * GCP_request_mq(struct CadetPeer *cp, GCP_MessageQueueNotificationCallback cb, void *cb_cls)
Start message queue change notifications.
enum GNUNET_GenericReturnValue 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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
@ GNUNET_OK
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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:484
Struct containing all information regarding a given peer.

References CadetConnection::cid, connections, CadetConnection::ct, CadetConnection::destination, GCC_2s(), GCC_get_id(), GCP_add_connection(), GCP_request_mq(), GCPP_2s(), GCPP_add_connection(), GCPP_get_peer_at_offset(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multishortmap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_OK, GNUNET_TIME_relative_multiply(), INITIAL_CONNECTION_CREATE_RETRY_DELAY, LOG, manage_first_hop_mq(), CadetConnection::mq_man, CadetConnection::off, CadetConnection::path, CadetConnection::ready_cb, CadetConnection::ready_cb_cls, CadetConnection::retry_delay, and CadetConnection::state.

Referenced by GCC_create(), GCC_create_inbound(), and GCO_init().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_create_inbound()

struct CadetConnection * GCC_create_inbound ( struct CadetPeer destination,
struct CadetPeerPath path,
struct CadetTConnection ct,
const struct GNUNET_CADET_ConnectionTunnelIdentifier cid,
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.

This is an inbound tunnel, so we must use the existing cid

Parameters
destinationwhere to go
pathwhich path to take (may not be the full path)
ctwhich tunnel uses this connection
ready_cbfunction to call when ready to transmit
ready_cb_clsclosure for cb
Returns
handle to the connection, NULL if we already have a connection that takes precedence on path

Definition at line 870 of file gnunet-service-cadet_connection.c.

876{
877 struct CadetConnection *cc;
878 unsigned int off;
879
881 GNUNET_assert (UINT_MAX != off);
883 if (NULL != cc)
884 {
885 int cmp;
886
887 cmp = GNUNET_memcmp (cid, &cc->cid);
888 if (0 == cmp)
889 {
890 /* Two peers picked the SAME random connection identifier at the
891 same time for the same path? Must be malicious. Drop
892 connection (existing and inbound), even if it is the only
893 one. */
894 GNUNET_break_op (0);
897 return NULL;
898 }
899 if (0 < cmp)
900 {
901 /* drop existing */
903 "Got two connections on %s, dropping my existing %s\n",
904 GCPP_2s (path),
905 GCC_2s (cc));
908 }
909 else
910 {
911 /* keep existing */
913 "Got two connections on %s, keeping my existing %s\n",
914 GCPP_2s (path),
915 GCC_2s (cc));
916 return NULL;
917 }
918 }
919
921 path,
922 off,
923 ct,
924 cid,
926 ready_cb,
928}
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.
void GCC_destroy_without_tunnel(struct CadetConnection *cc)
Destroy a connection, called if the tunnel association with the connection was already broken,...
struct CadetConnection * GCPP_get_connection(struct CadetPeerPath *path, struct CadetPeer *destination, unsigned int off)
Return connection to destination using path, or return NULL if no such connection exists.
unsigned int GCPP_find_peer(struct CadetPeerPath *path, struct CadetPeer *cp)
Find peer's offset on path.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.

References CADET_CONNECTION_CREATE_RECEIVED, CadetConnection::cid, connection_create(), CadetConnection::ct, CadetConnection::destination, GCC_2s(), GCC_destroy_without_tunnel(), GCPP_2s(), GCPP_find_peer(), GCPP_get_connection(), GCT_connection_lost(), GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcmp, LOG, CadetConnection::off, CadetConnection::path, CadetConnection::ready_cb, and CadetConnection::ready_cb_cls.

Referenced by GCT_add_inbound_connection().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_create()

struct CadetConnection * GCC_create ( struct CadetPeer destination,
struct CadetPeerPath path,
unsigned int  off,
struct CadetTConnection ct,
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.

Parameters
destinationwhere to go
pathwhich path to take (may not be the full path)
offoffset of destination on path
ctwhich tunnel uses this connection
ready_cbfunction to call when ready to transmit
ready_cb_clsclosure for cb
Returns
handle to the connection

Definition at line 932 of file gnunet-service-cadet_connection.c.

938{
940
942 return connection_create (destination,
943 path,
944 off,
945 ct,
946 &cid,
948 ready_cb,
949 ready_cb_cls);
950}
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
Hash uniquely identifying a connection below a tunnel.

References CADET_CONNECTION_NEW, connection_create(), GNUNET_CRYPTO_QUALITY_NONCE, and GNUNET_CRYPTO_random_block().

Referenced by consider_path_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_transmit()

void GCC_transmit ( struct CadetConnection cc,
struct GNUNET_MQ_Envelope env 
)

Transmit message msg via connection cc.

Must only be called (once) after the connection has signalled that it is ready via the ready_cb. Clients can also use #GCC_is_ready() to check if the connection is right now ready for transmission.

Parameters
ccconnection identification
envenvelope with message to transmit; must NOT yet have a GNUNET_MQ_notify_sent() callback attached to it

Definition at line 964 of file gnunet-service-cadet_connection.c.

965{
967 "Scheduling message for transmission on %s\n",
968 GCC_2s (cc));
972 cc->mqm_ready = GNUNET_NO;
973 if (NULL != cc->task)
974 {
976 cc->task = NULL;
977 }
978 GCP_send (cc->mq_man, env);
979}

References CADET_CONNECTION_READY, env, GCC_2s(), GCP_send(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), GNUNET_YES, CadetConnectionMetrics::last_use, LOG, CadetConnection::metrics, CadetConnection::mq_man, CadetConnection::mqm_ready, CadetConnection::state, and CadetConnection::task.

Referenced by send_kx(), send_kx_auth(), and try_send_normal_payload().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_get_path()

struct CadetPeerPath * GCC_get_path ( struct CadetConnection cc,
unsigned int *  off 
)

Obtain the path used by this connection.

Parameters
ccconnection
[out]offset to the length of the path we use
Returns
path to cc

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

991{
992 *off = cc->off;
993 return cc->path;
994}

References CadetConnection::off, and CadetConnection::path.

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

Here is the caller graph for this function:

◆ GCC_get_id()

const struct GNUNET_CADET_ConnectionTunnelIdentifier * GCC_get_id ( struct CadetConnection cc)

Obtain unique ID for the connection.

Parameters
ccconnection.
Returns
unique number of the connection

Definition at line 1004 of file gnunet-service-cadet_connection.c.

1005{
1006 return &cc->cid;
1007}

References CadetConnection::cid.

Referenced by connection_create(), GCC_destroy(), GCP_add_connection(), GCP_remove_connection(), handle_plaintext_channel_destroy(), handle_plaintext_channel_open(), handle_plaintext_channel_open_ack(), handle_plaintext_data(), handle_plaintext_data_ack(), send_kx(), send_kx_auth(), and try_send_normal_payload().

Here is the caller graph for this function:

◆ GCC_2s()

const char * GCC_2s ( const struct CadetConnection cc)

Get a (static) string for a connection.

Parameters
ccConnection.

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

1017{
1018 static char buf[128];
1019
1020 if (NULL == cc)
1021 return "Connection(NULL)";
1022
1023 if (NULL != cc->ct)
1024 {
1025 GNUNET_snprintf (buf,
1026 sizeof(buf),
1027 "Connection %s (%s)",
1029 GCT_2s (cc->ct->t));
1030 return buf;
1031 }
1032 GNUNET_snprintf (buf,
1033 sizeof(buf),
1034 "Connection %s",
1036 return buf;
1037}
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.

References CadetConnection::cid, GNUNET_CADET_ConnectionTunnelIdentifier::connection_of_tunnel, CadetConnection::ct, GCT_2s(), GNUNET_sh2s(), GNUNET_snprintf(), and CadetTConnection::t.

Referenced by connection_create(), connection_ready_cb(), consider_path_cb(), evaluate_connection(), GCC_create_inbound(), GCC_debug(), GCC_destroy(), GCC_handle_connection_create_ack(), GCC_handle_duplicate_create(), GCC_handle_encrypted(), GCC_handle_kx(), GCC_handle_kx_auth(), GCC_transmit(), GCP_add_connection(), GCP_remove_connection(), GCPP_add_connection(), GCPP_del_connection(), GCT_add_inbound_connection(), GCT_handle_kx(), manage_first_hop_mq(), send_create(), send_create_ack(), send_keepalive(), and try_send_normal_payload().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GCC_debug()

void GCC_debug ( struct CadetConnection cc,
enum GNUNET_ErrorType  level 
)

Log connection info.

Parameters
ccconnection
levelDebug level to use.

Definition at line 1051 of file gnunet-service-cadet_connection.c.

1052{
1053#if ! defined(GNUNET_CULL_LOGGING)
1054 int do_log;
1055
1057 "cadet-con",
1058 __FILE__,
1059 __FUNCTION__,
1060 __LINE__);
1061 if (0 == do_log)
1062 return;
1063 if (NULL == cc)
1064 {
1065 LOG2 (level, "Connection (NULL)\n");
1066 return;
1067 }
1068 LOG2 (level,
1069 "%s to %s via path %s in state %d is %s\n",
1070 GCC_2s (cc),
1071 GCP_2s (cc->destination),
1072 GCPP_2s (cc->path),
1073 cc->state,
1074 (GNUNET_YES == cc->mqm_ready) ? "ready" : "busy");
1075#endif
1076}
#define LOG2(level,...)
const char * GCP_2s(const struct CadetPeer *cp)
Get the static string for a peer ID.
int GNUNET_get_log_call_status(int caller_level, const char *comp, const char *file, const char *function, int line)
Decides whether a particular logging call should or should not be allowed to be made.
@ GNUNET_ERROR_TYPE_BULK

References CadetConnection::destination, GCC_2s(), GCP_2s(), GCPP_2s(), GNUNET_ERROR_TYPE_BULK, GNUNET_get_log_call_status(), GNUNET_YES, LOG2, CadetConnection::mqm_ready, CadetConnection::path, and CadetConnection::state.

Referenced by GCT_debug().

Here is the call graph for this function:
Here is the caller graph for this function: