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 "platform.h"
#include "gnunet_signatures.h"
#include "gnunet-service-cadet_connection.h"
#include "gnunet-service-cadet_channel.h"
#include "gnunet-service-cadet_paths.h"
#include "gnunet-service-cadet_tunnels.h"
#include "gnunet_cadet_service.h"
#include "gnunet_statistics_service.h"
#include "cadet_protocol.h"

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 CadetConnection *	GCC_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 CadetTConnection *	GCC_get_ct (struct CadetConnection *cc)
	Return the tunnel associated with this connection. More...
const struct CadetConnectionMetrics *	GCC_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 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. More...
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. More...
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. More...
void	GCC_transmit (struct CadetConnection *cc, struct GNUNET_MQ_Envelope *env)
	Transmit message msg via connection cc. More...
struct CadetPeerPath *	GCC_get_path (struct CadetConnection *cc, unsigned int *off)
	Obtain the path used by this connection. More...
const struct GNUNET_CADET_ConnectionTunnelIdentifier *	GCC_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

enum 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.

{
  CADET_CONNECTION_NEW,
 
  CADET_CONNECTION_SENDING_CREATE,
 
  CADET_CONNECTION_SENT,
 
  CADET_CONNECTION_CREATE_RECEIVED,
 
  CADET_CONNECTION_READY
};

Function Documentation

GCC_lookup()

struct CadetConnection * GCC_lookup

(

const struct GNUNET_CADET_ConnectionTunnelIdentifier *

cid

)

Lookup a connection by its identifier.

Parameters

cid	identifier to resolve

Returns

NULL if connection was not found

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

{
  return GNUNET_CONTAINER_multishortmap_get (connections,
                                             &cid->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

cc	connection to update the state for
new_state	new state for cc
new_mqm_ready	new mqm_ready state for cc

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

{
  int old_ready;
  int new_ready;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "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",
       GCT_2s (cc->ct->t),
       cc->state,
       new_state,
       cc->mqm_ready,
       new_mqm_ready);
 
  if ((new_state == cc->state) && (new_mqm_ready == cc->mqm_ready))
    return; /* no change, nothing to do */
  old_ready =
    ((CADET_CONNECTION_READY == cc->state) && (GNUNET_YES == cc->mqm_ready));
  new_ready =
    ((CADET_CONNECTION_READY == new_state) && (GNUNET_YES == new_mqm_ready));
  cc->state = new_state;
  cc->mqm_ready = new_mqm_ready;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Updating connection state for %s having old_ready %d and new_rady %d\n",
       GCT_2s (cc->ct->t),
       old_ready,
       new_ready);
 
  if (old_ready != new_ready)
    cc->ready_cb (cc->ready_cb_cls, new_ready);
}

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

cc	connection to destroy

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

{
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying %s\n", GCC_2s (cc));
  if (NULL != cc->mq_man)
  {
    GCP_request_mq_cancel (cc->mq_man, NULL);
    cc->mq_man = NULL;
  }
  if (NULL != cc->task)
  {
    GNUNET_SCHEDULER_cancel (cc->task);
    cc->task = NULL;
  }
  if (NULL != cc->keepalive_qe)
  {
    GCT_send_cancel (cc->keepalive_qe);
    cc->keepalive_qe = NULL;
  }
  GCPP_del_connection (cc->path, cc->off, cc);
  for (unsigned int i = 0; i < cc->off; i++)
    GCP_remove_connection (GCPP_get_peer_at_offset (cc->path, i), cc);
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multishortmap_remove (connections,
                                           &GCC_get_id (cc)
                                           ->connection_of_tunnel,
                                           cc));
  GNUNET_free (cc);
}

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

cc	connection to destroy

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

{
  if (NULL != cc->ct)
  {
    GCT_connection_lost (cc->ct);
    cc->ct = NULL;
  }
  GCC_destroy (cc);
}

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

cc	connection to destroy

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

{
  cc->ct = NULL;
  if ((CADET_CONNECTION_SENDING_CREATE != cc->state) && (NULL != cc->mq_man))
  {
    struct GNUNET_MQ_Envelope *env;
    struct GNUNET_CADET_ConnectionDestroyMessage *destroy_msg;
 
    /* Need to notify next hop that we are down. */
    env =
      GNUNET_MQ_msg (destroy_msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY);
    destroy_msg->cid = cc->cid;
    GCP_request_mq_cancel (cc->mq_man, env);
    cc->mq_man = NULL;
  }
  GCC_destroy (cc);
}

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

cc	connection to query

Returns

corresponding entry in the tunnel's connection list

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

{
  return cc->ct;
}

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

GCC_get_metrics()

const struct CadetConnectionMetrics * GCC_get_metrics

(

struct CadetConnection *

cc

)

Obtain performance metrics from cc.

Parameters

cc	connection to query

Returns

the metrics

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

{
  return &cc->metrics;
}

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

cls	the struct CadetConnection to keep alive.

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

{
  struct CadetConnection *cc = cls;
  struct GNUNET_MessageHeader msg;
 
  cc->task = NULL;
  if (CADET_TUNNEL_KEY_OK != GCT_get_estate (cc->ct->t))
  {
    /* Tunnel not yet ready, wait with keepalives... */
    cc->task =
      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
    return;
  }
  GNUNET_assert (NULL != cc->ct);
  GNUNET_assert (GNUNET_YES == cc->mqm_ready);
  GNUNET_assert (NULL == cc->keepalive_qe);
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Sending KEEPALIVE on behalf of %s via %s\n",
       GCC_2s (cc),
       GCT_2s (cc->ct->t));
  GNUNET_STATISTICS_update (stats, "# keepalives sent", 1, GNUNET_NO);
  msg.size = htons (sizeof(msg));
  msg.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE);
 
  cc->keepalive_qe = GCT_send (cc->ct->t, &msg, &keepalive_done, cc, NULL);
}

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

cls	the struct CadetConnection to keep alive.
cid	identifier of the connection within the tunnel, NULL if transmission failed

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

{
  struct CadetConnection *cc = cls;
 
  cc->keepalive_qe = NULL;
  if ((GNUNET_YES == cc->mqm_ready) && (NULL == cc->task))
    cc->task =
      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
}

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

cid	connection identifier where we expect an ACK

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

{
  struct CadetConnection *cc;
 
  cc = GCC_lookup (cid);
  if (NULL == cc)
    return; /* whopise, connection already down? */
  cc->metrics.num_acked_transmissions++;
}

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

cid	connection 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.

{
  struct CadetConnection *cc;
 
  cc = GCC_lookup (cid);
  if (NULL == cc)
    return; /* whopise, connection already down? */
  cc->metrics.num_successes++;
}

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

cti	connection identifier where we measured latency
latency	the observed latency

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

{
  struct CadetConnection *cc;
  double weight;
  double result;
 
  cc = GCC_lookup (cid);
  if (NULL == cc)
    return; /* whopise, connection already down? */
  GNUNET_STATISTICS_update (stats, "# latencies observed", 1, GNUNET_NO);
  cc->latency_datapoints++;
  if (cc->latency_datapoints >= 7)
    weight = 7.0;
  else
    weight = cc->latency_datapoints;
  /* Compute weighted average, giving at MOST weight 7 to the
     existing values, or less if that value is based on fewer than 7
     measurements. */
  result = (weight * cc->metrics.aged_latency.rel_value_us)
           + 1.0 * latency.rel_value_us;
  result /= (weight + 1.0);
  cc->metrics.aged_latency.rel_value_us = (uint64_t) result;
}

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

cc	the connection that got the ACK.

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

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received CADET_CONNECTION_CREATE_ACK for %s in state %d (%s)\n",
       GCC_2s (cc),
       cc->state,
       (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy");
  if (CADET_CONNECTION_READY == cc->state)
    return; /* Duplicate ACK, ignore */
  if (NULL != cc->task)
  {
    GNUNET_SCHEDULER_cancel (cc->task);
    cc->task = NULL;
  }
  cc->metrics.age = GNUNET_TIME_absolute_get ();
  update_state (cc, CADET_CONNECTION_READY, cc->mqm_ready);
  if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) &&
      (NULL == cc->task))
    cc->task =
      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
}

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

cc	connection that received encrypted message
msg	the key exchange message

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

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received KX message with ephermal %s on CC %s in state %d\n",
       GNUNET_e2s (&msg->ephemeral_key),
       GNUNET_sh2s (&cc->cid.connection_of_tunnel),
       cc->state);
  if (CADET_CONNECTION_SENT == cc->state)
  {
    /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine,
       clearly something is working, so pretend we got an ACK. */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n",
         GCC_2s (cc));
    GCC_handle_connection_create_ack (cc);
  }
  GCT_handle_kx (cc->ct, msg);
}

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

cc	connection that received encrypted message
msg	the key exchange message

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

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received KX AUTH message with ephermal %s on CC %s in state %d\n",
       GNUNET_e2s (&msg->kx.ephemeral_key),
       GNUNET_sh2s (&cc->cid.connection_of_tunnel),
       cc->state);
  if (CADET_CONNECTION_SENT == cc->state)
  {
    /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine,
       clearly something is working, so pretend we got an ACK. */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n",
         GCC_2s (cc));
    GCC_handle_connection_create_ack (cc);
  }
  GCT_handle_kx_auth (cc->ct, msg);
}

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

cc	connection that received encrypted message
msg	the encrypted message to decrypt

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

{
  if (CADET_CONNECTION_SENT == cc->state)
  {
    /* We didn't get the CREATE_ACK, but instead got payload. That's fine,
       clearly something is working, so pretend we got an ACK. */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Faking connection ACK for %s due to ENCRYPTED payload\n",
         GCC_2s (cc));
    GCC_handle_connection_create_ack (cc);
  }
  cc->metrics.last_use = GNUNET_TIME_absolute_get ();
  GCT_handle_encrypted (cc->ct, msg);
}

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

msg	The GNUNET_CADET_ConnectionCreateMessage.

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

{
 
  struct CadetConnectionCreatePS cp = { .purpose.purpose = htonl (
                                          GNUNET_SIGNATURE_PURPOSE_CADET_CONNECTION_INITIATOR),
                                        .purpose.size = htonl (sizeof(cp)),
                                        .monotonic_time = msg->monotime};
 
  GNUNET_CRYPTO_eddsa_sign (my_private_key, &cp,
                            &msg->monotime_sig);
 
}

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

cls	the struct CadetConnection to initiate

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

{
  struct CadetConnection *cc = cls;
  struct GNUNET_CADET_ConnectionCreateMessage *create_msg;
  struct GNUNET_PeerIdentity *pids;
  struct GNUNET_MQ_Envelope *env;
  struct CadetTunnel *t;
 
  cc->task = NULL;
  GNUNET_assert (GNUNET_YES == cc->mqm_ready);
  env =
    GNUNET_MQ_msg_extra (create_msg,
                         (2 + cc->off) * sizeof(struct GNUNET_PeerIdentity),
                         GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE);
  // 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.
  create_msg->options = 2;
  create_msg->cid = cc->cid;
 
  // check for tunnel state and set signed monotime (xrs,t3ss)
  t = GCP_get_tunnel (cc->destination, GNUNET_YES);
  if ((NULL != t) && (GCT_get_estate (t) == CADET_TUNNEL_KEY_UNINITIALIZED) &&
      (GCT_alice_or_betty (GCP_get_id (cc->destination)) == GNUNET_NO))
  {
    create_msg->has_monotime = GNUNET_YES;
    create_msg->monotime = GNUNET_TIME_absolute_hton (
      GNUNET_TIME_absolute_get_monotonic (cfg));
    set_monotime_sig (create_msg);
  }
 
  pids = (struct GNUNET_PeerIdentity *) &create_msg[1];
  pids[0] = my_full_id;
  for (unsigned int i = 0; i <= cc->off; i++)
    pids[i + 1] = *GCP_get_id (GCPP_get_peer_at_offset (cc->path, i));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending CADET_CONNECTION_CREATE message for %s with %u hops\n",
       GCC_2s (cc),
       cc->off + 2);
  cc->env = env;
  cc->retry_delay = GNUNET_TIME_STD_BACKOFF (cc->retry_delay);
  cc->create_at = GNUNET_TIME_relative_to_absolute (cc->retry_delay);
  update_state (cc, CADET_CONNECTION_SENT, GNUNET_NO);
  GCP_send (cc->mq_man, env);
}

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

cls	the struct CadetConnection to initiate

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

{
  struct CadetConnection *cc = cls;
  struct GNUNET_CADET_ConnectionCreateAckMessage *ack_msg;
  struct GNUNET_MQ_Envelope *env;
 
  cc->task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending CONNECTION_CREATE_ACK message for %s\n",
       GCC_2s (cc));
  GNUNET_assert (GNUNET_YES == cc->mqm_ready);
  env =
    GNUNET_MQ_msg (ack_msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK);
  ack_msg->cid = cc->cid;
  cc->env = env;
  cc->retry_delay = GNUNET_TIME_STD_BACKOFF (cc->retry_delay);
  cc->create_ack_at = GNUNET_TIME_relative_to_absolute (cc->retry_delay);
  if (CADET_CONNECTION_CREATE_RECEIVED == cc->state)
    update_state (cc, CADET_CONNECTION_READY, GNUNET_NO);
  if (CADET_CONNECTION_READY == cc->state)
    cc->task =
      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
  GCP_send (cc->mq_man, env);
}

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

cc	connection that got the duplicate CREATE

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

{
  if (GNUNET_YES == cc->mqm_ready)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Got duplicate CREATE for %s, scheduling another ACK (%s)\n",
         GCC_2s (cc),
         (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy");
    /* Revert back to the state of having only received the 'CREATE',
       and immediately proceed to send the CREATE_ACK. */
    update_state (cc, CADET_CONNECTION_CREATE_RECEIVED, cc->mqm_ready);
    if (NULL != cc->task)
      GNUNET_SCHEDULER_cancel (cc->task);
    cc->task =
      GNUNET_SCHEDULER_add_at (cc->create_ack_at, &send_create_ack, cc);
  }
  else
  {
    /* We are currently sending something else back, which
       can only be an ACK or payload, either of which would
       do. So actually no need to do anything. */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Got duplicate CREATE for %s. MQ is busy, not queueing another ACK\n",
         GCC_2s (cc));
  }
}

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

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

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

{
  struct CadetConnection *cc = cls;
 
  if (GNUNET_YES != available)
  {
    /* Connection is down, for now... */
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Core MQ for %s went down\n", GCC_2s (cc));
    update_state (cc, CADET_CONNECTION_NEW, GNUNET_NO);
    cc->retry_delay = INITIAL_CONNECTION_CREATE_RETRY_DELAY;
    if (NULL != cc->task)
    {
      GNUNET_SCHEDULER_cancel (cc->task);
      cc->task = NULL;
    }
    return;
  }
 
  update_state (cc, cc->state, GNUNET_YES);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Core MQ for %s became available in state %d\n",
       GCC_2s (cc),
       cc->state);
  switch (cc->state)
  {
  case CADET_CONNECTION_NEW:
    /* Transmit immediately */
    cc->task = GNUNET_SCHEDULER_add_at (cc->create_at, &send_create, cc);
    break;
 
  case CADET_CONNECTION_SENDING_CREATE:
    /* Should not be possible to be called in this state. */
    GNUNET_assert (0);
    break;
 
  case CADET_CONNECTION_SENT:
    /* Retry a bit later... */
    cc->task = GNUNET_SCHEDULER_add_at (cc->create_at, &send_create, cc);
    break;
 
  case CADET_CONNECTION_CREATE_RECEIVED:
    /* We got the 'CREATE' (incoming connection), should send the CREATE_ACK */
    cc->metrics.age = GNUNET_TIME_absolute_get ();
    cc->task =
      GNUNET_SCHEDULER_add_at (cc->create_ack_at, &send_create_ack, cc);
    break;
 
  case CADET_CONNECTION_READY:
    if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) &&
        (NULL == cc->task))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Scheduling keepalive for %s in %s\n",
           GCC_2s (cc),
           GNUNET_STRINGS_relative_time_to_string (keepalive_period,
                                                   GNUNET_YES));
      cc->task =
        GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
    }
    break;
  }
}

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

destination	where to go
path	which path to take (may not be the full path)
off	offset of destination on path
ct	which tunnel uses this connection
init_state	initial state for the connection
ready_cb	function to call when ready to transmit
ready_cb_cls	closure for cb

Returns

handle to the connection

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

{
  struct CadetConnection *cc;
  struct CadetPeer *first_hop;
 
  cc = GNUNET_new (struct CadetConnection);
  cc->state = init_state;
  cc->ct = ct;
  cc->destination = destination; /* xrs,t3ss,lurchi*/
  cc->cid = *cid;
  cc->retry_delay =
    GNUNET_TIME_relative_multiply (INITIAL_CONNECTION_CREATE_RETRY_DELAY, off);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_put (
                   connections,
                   &GCC_get_id (cc)->connection_of_tunnel,
                   cc,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  cc->ready_cb = ready_cb;
  cc->ready_cb_cls = ready_cb_cls;
  cc->path = path;
  cc->off = off;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating %s using path %s (offset: %u)\n",
       GCC_2s (cc),
       GCPP_2s (path),
       off);
  GCPP_add_connection (path, off, cc);
  for (unsigned int i = 0; i < off; i++)
    GCP_add_connection (GCPP_get_peer_at_offset (path, i), cc);
  first_hop = GCPP_get_peer_at_offset (path, 0);
  cc->mq_man = GCP_request_mq (first_hop, &manage_first_hop_mq, cc);
  return cc;
}

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

destination	where to go
path	which path to take (may not be the full path)
ct	which tunnel uses this connection
ready_cb	function to call when ready to transmit
ready_cb_cls	closure 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.

{
  struct CadetConnection *cc;
  unsigned int off;
 
  off = GCPP_find_peer (path, destination);
  GNUNET_assert (UINT_MAX != off);
  cc = GCPP_get_connection (path, destination, off);
  if (NULL != cc)
  {
    int cmp;
 
    cmp = GNUNET_memcmp (cid, &cc->cid);
    if (0 == cmp)
    {
      /* Two peers picked the SAME random connection identifier at the
         same time for the same path? Must be malicious.  Drop
         connection (existing and inbound), even if it is the only
         one. */
      GNUNET_break_op (0);
      GCT_connection_lost (cc->ct);
      GCC_destroy_without_tunnel (cc);
      return NULL;
    }
    if (0 < cmp)
    {
      /* drop existing */
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Got two connections on %s, dropping my existing %s\n",
           GCPP_2s (path),
           GCC_2s (cc));
      GCT_connection_lost (cc->ct);
      GCC_destroy_without_tunnel (cc);
    }
    else
    {
      /* keep existing */
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Got two connections on %s, keeping my existing %s\n",
           GCPP_2s (path),
           GCC_2s (cc));
      return NULL;
    }
  }
 
  return connection_create (destination,
                            path,
                            off,
                            ct,
                            cid,
                            CADET_CONNECTION_CREATE_RECEIVED,
                            ready_cb,
                            ready_cb_cls);
}

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

destination	where to go
path	which path to take (may not be the full path)
off	offset of destination on path
ct	which tunnel uses this connection
ready_cb	function to call when ready to transmit
ready_cb_cls	closure for cb

Returns

handle to the connection

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

{
  struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 
  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE, &cid, sizeof(cid));
  return connection_create (destination,
                            path,
                            off,
                            ct,
                            &cid,
                            CADET_CONNECTION_NEW,
                            ready_cb,
                            ready_cb_cls);
}

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

cc	connection identification
env	envelope 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.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Scheduling message for transmission on %s\n",
       GCC_2s (cc));
  GNUNET_assert (GNUNET_YES == cc->mqm_ready);
  GNUNET_assert (CADET_CONNECTION_READY == cc->state);
  cc->metrics.last_use = GNUNET_TIME_absolute_get ();
  cc->mqm_ready = GNUNET_NO;
  if (NULL != cc->task)
  {
    GNUNET_SCHEDULER_cancel (cc->task);
    cc->task = NULL;
  }
  GCP_send (cc->mq_man, env);
}

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

	cc	connection
[out]	off	set to the length of the path we use

Returns

path to cc

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

{
  *off = cc->off;
  return cc->path;
}

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

cc	connection.

Returns

unique number of the connection

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

{
  return &cc->cid;
}

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

cc	Connection.

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

{
  static char buf[128];
 
  if (NULL == cc)
    return "Connection(NULL)";
 
  if (NULL != cc->ct)
  {
    GNUNET_snprintf (buf,
                     sizeof(buf),
                     "Connection %s (%s)",
                     GNUNET_sh2s (&cc->cid.connection_of_tunnel),
                     GCT_2s (cc->ct->t));
    return buf;
  }
  GNUNET_snprintf (buf,
                   sizeof(buf),
                   "Connection %s",
                   GNUNET_sh2s (&cc->cid.connection_of_tunnel));
  return buf;
}

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

cc	connection
level	Debug level to use.

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

{
#if ! defined(GNUNET_CULL_LOGGING)
  int do_log;
 
  do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
                                       "cadet-con",
                                       __FILE__,
                                       __FUNCTION__,
                                       __LINE__);
  if (0 == do_log)
    return;
  if (NULL == cc)
  {
    LOG2 (level, "Connection (NULL)\n");
    return;
  }
  LOG2 (level,
        "%s to %s via path %s in state %d is %s\n",
        GCC_2s (cc),
        GCP_2s (cc->destination),
        GCPP_2s (cc->path),
        cc->state,
        (GNUNET_YES == cc->mqm_ready) ? "ready" : "busy");
#endif
}

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: