gnunet-service-cadet_tunnels.h File Reference

Information we track per tunnel. More...

#include "gnunet-service-cadet.h"
#include "cadet_protocol.h"

Include dependency graph for gnunet-service-cadet_tunnels.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DESIRED_CONNECTIONS_PER_TUNNEL   3
	How many connections would we like to have per tunnel?

Typedefs
typedef void(*	GCT_SendContinuation) (void *cls, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
	Function called when a transmission requested using GCT_send is done.
typedef void(*	GCT_ConnectionIterator) (void *cls, struct CadetTConnection *ct)
	Iterator over connections.
typedef void(*	GCT_ChannelIterator) (void *cls, struct CadetChannel *ch)
	Iterator over channels.

Enumerations
enum	CadetTunnelEState {   CADET_TUNNEL_KEY_UNINITIALIZED , CADET_TUNNEL_KEY_AX_SENT , CADET_TUNNEL_KEY_AX_RECV , CADET_TUNNEL_KEY_AX_SENT_AND_RECV ,   CADET_TUNNEL_KEY_AX_AUTH_SENT , CADET_TUNNEL_KEY_OK }
	All the encryption states a tunnel can be in. More...

Functions
int	GCT_alice_or_betty (const struct GNUNET_PeerIdentity *other)
	Am I Alice or Betty (some call her Bob), or talking to myself?
const char *	GCT_2s (const struct CadetTunnel *t)
	Get the static string for the peer this tunnel is directed.
struct CadetTunnel *	GCT_create_tunnel (struct CadetPeer *destination)
	Create a tunnel to destination.
void	GCT_destroy_tunnel_now (struct CadetTunnel *t)
	Destroys the tunnel t now, without delay.
int	GCT_add_inbound_connection (struct CadetTunnel *t, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, struct CadetPeerPath *path)
	Add a connection to the tunnel.
void	GCT_connection_lost (struct CadetTConnection *ct)
	We lost a connection, remove it from our list and clean up the connection object itself.
struct CadetPeer *	GCT_get_destination (struct CadetTunnel *t)
	Return the peer to which this tunnel goes.
void	GCT_consider_path (struct CadetTunnel *t, struct CadetPeerPath *p, unsigned int off)
	Consider using the path p for the tunnel t.
struct GNUNET_CADET_ChannelTunnelNumber	GCT_add_channel (struct CadetTunnel *t, struct CadetChannel *ch)
	Add a channel to a tunnel.
void	GCT_remove_channel (struct CadetTunnel *t, struct CadetChannel *ch, struct GNUNET_CADET_ChannelTunnelNumber ctn)
	Remove a channel from a tunnel.
void	GCT_send_channel_destroy (struct CadetTunnel *t, struct GNUNET_CADET_ChannelTunnelNumber ctn)
	Send a DESTROY message via the tunnel.
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 provided.
void	GCT_send_cancel (struct CadetTunnelQueueEntry *q)
	Cancel a previously sent message while it's in the queue.
unsigned int	GCT_count_channels (struct CadetTunnel *t)
	Returns the number of channels using a tunnel.
unsigned int	GCT_count_any_connections (const struct CadetTunnel *t)
	Counts the number of connections created for a tunnel, including busy connections.
void	GCT_iterate_connections (struct CadetTunnel *t, GCT_ConnectionIterator iter, void *iter_cls)
	Iterate over all connections of a tunnel.
void	GCT_iterate_channels (struct CadetTunnel *t, GCT_ChannelIterator iter, void *iter_cls)
	Iterate over all channels of a tunnel.
enum CadetTunnelEState	GCT_get_estate (struct CadetTunnel *t)
	Get the encryption state of a tunnel.
void	GCT_change_estate (struct CadetTunnel *t, enum CadetTunnelEState state)
	Change the tunnel encryption state.
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 after we respond with our own KX_AUTH and finally successfully decrypt the payload).
void	GCT_handle_kx_auth (struct CadetTConnection *ct, const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
	Handle KX_AUTH message.
void	GCT_handle_encrypted (struct CadetTConnection *ct, const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
	Handle encrypted message.
void	GCT_debug (const struct CadetTunnel *t, enum GNUNET_ErrorType level)
	Log all possible info about the tunnel state.

Detailed Description

Information we track per tunnel.

Author

Bartlomiej Polot

Christian Grothoff

Definition in file gnunet-service-cadet_tunnels.h.

Macro Definition Documentation

DESIRED_CONNECTIONS_PER_TUNNEL

#define DESIRED_CONNECTIONS_PER_TUNNEL   3

How many connections would we like to have per tunnel?

Definition at line 37 of file gnunet-service-cadet_tunnels.h.

Typedef Documentation

GCT_SendContinuation

typedef void(* GCT_SendContinuation) (void *cls, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)

Function called when a transmission requested using GCT_send is done.

Parameters

cls	closure
ctn	identifier of the connection used for transmission, NULL if the transmission failed (to be used to match ACKs to the respective connection for connection performance evaluation)

Definition at line 217 of file gnunet-service-cadet_tunnels.h.

GCT_ConnectionIterator

typedef void(* GCT_ConnectionIterator) (void *cls, struct CadetTConnection *ct)

Iterator over connections.

Parameters

cls	closure
ct	one of the connections

Definition at line 281 of file gnunet-service-cadet_tunnels.h.

GCT_ChannelIterator

typedef void(* GCT_ChannelIterator) (void *cls, struct CadetChannel *ch)

Iterator over channels.

Parameters

cls	closure
ch	one of the channels

Definition at line 305 of file gnunet-service-cadet_tunnels.h.

Enumeration Type Documentation

CadetTunnelEState

enum CadetTunnelEState

All the encryption states a tunnel can be in.

Enumerator
CADET_TUNNEL_KEY_UNINITIALIZED	Uninitialized status, we need to send KX. We will stay in this state until the first connection is up.
CADET_TUNNEL_KEY_AX_SENT	KX message sent, waiting for other peer's KX_AUTH.
CADET_TUNNEL_KEY_AX_RECV	KX message received, trying to send back KX_AUTH.
CADET_TUNNEL_KEY_AX_SENT_AND_RECV	KX message sent and received, trying to send back KX_AUTH.
CADET_TUNNEL_KEY_AX_AUTH_SENT	KX received and we sent KX_AUTH back, but we got no traffic yet, so we're waiting for either KX_AUTH or ENCRYPTED traffic from the other peer. We will not yet send traffic, as this might have been a replay. The other (initiating) peer should send a CHANNEL_OPEN next anyway, and then we are in business!
CADET_TUNNEL_KEY_OK	Handshake completed: session key available.

Definition at line 43 of file gnunet-service-cadet_tunnels.h.

{
  CADET_TUNNEL_KEY_UNINITIALIZED,
 
  CADET_TUNNEL_KEY_AX_SENT,
 
  CADET_TUNNEL_KEY_AX_RECV,
 
  CADET_TUNNEL_KEY_AX_SENT_AND_RECV,
 
  CADET_TUNNEL_KEY_AX_AUTH_SENT,
 
  CADET_TUNNEL_KEY_OK
};

Function Documentation

GCT_alice_or_betty()

int GCT_alice_or_betty

(

const struct GNUNET_PeerIdentity *

other

)

Am I Alice or Betty (some call her Bob), or talking to myself?

Parameters

other

the other peer

Returns

GNUNET_YES for Alice, GNUNET_NO for Betty, GNUNET_SYSERR if talking to myself

Definition at line 540 of file gnunet-service-cadet_tunnels.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  if (0 > GNUNET_memcmp (my_identity, other))
    return GNUNET_YES;
  else if (0 < GNUNET_memcmp (my_identity, other))
    return GNUNET_NO;
  else
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
}

References GNUNET_assert, GNUNET_break_op, GNUNET_memcmp, GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_SYSERR, GNUNET_YES, my_identity, and pils.

Referenced by GCT_handle_kx(), send_create(), send_kx(), and update_ax_by_kx().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_2s()

const char * GCT_2s

(

const struct CadetTunnel *

t

)

Get the static string for the peer this tunnel is directed.

Parameters

t

Tunnel.

Returns

Static string the destination peer's ID.

Definition at line 592 of file gnunet-service-cadet_tunnels.c.

{
  static char buf[64];
 
  if (NULL == t)
    return "Tunnel(NULL)";
  GNUNET_snprintf (buf,
                   sizeof(buf),
                   "Tunnel %s",
                   GNUNET_i2s (GCP_get_id (t->destination)));
  return buf;
}

References GCP_get_id(), GNUNET_i2s(), GNUNET_snprintf(), and t.

Referenced by connection_ready_cb(), consider_path_cb(), cont_GCT_handle_kx(), cont_GCT_handle_kx_auth(), destroy_tunnel(), GCC_2s(), GCCH_bind(), GCCH_channel_local_new(), GCCH_debug(), GCP_drop_tunnel(), GCT_add_channel(), GCT_add_inbound_connection(), GCT_change_estate(), GCT_consider_path(), GCT_debug(), GCT_handle_encrypted(), GCT_handle_kx(), GCT_handle_kx_auth(), GCT_remove_channel(), GCT_send(), handle_plaintext_channel_destroy(), handle_plaintext_channel_open(), handle_plaintext_channel_open_ack(), handle_plaintext_keepalive(), maintain_connections_cb(), retry_kx(), send_keepalive(), send_kx(), send_kx_auth(), try_send_normal_payload(), and update_state().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_create_tunnel()

struct CadetTunnel * GCT_create_tunnel

(

struct CadetPeer *

destination

)

Create a tunnel to destination.

Must only be called from within GCP_get_tunnel().

Parameters

destination

where to create the tunnel to

Returns

new tunnel to destination

Definition at line 3299 of file gnunet-service-cadet_tunnels.c.

{
  struct CadetTunnel *t = GNUNET_new (struct CadetTunnel);
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (plaintext_keepalive,
                             GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE,
                             struct GNUNET_MessageHeader,
                             t),
    GNUNET_MQ_hd_var_size (plaintext_data,
                           GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA,
                           struct GNUNET_CADET_ChannelAppDataMessage,
                           t),
    GNUNET_MQ_hd_fixed_size (plaintext_data_ack,
                             GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK,
                             struct GNUNET_CADET_ChannelDataAckMessage,
                             t),
    GNUNET_MQ_hd_fixed_size (plaintext_channel_open,
                             GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN,
                             struct GNUNET_CADET_ChannelOpenMessage,
                             t),
    GNUNET_MQ_hd_fixed_size (plaintext_channel_open_ack,
                             GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK,
                             struct GNUNET_CADET_ChannelOpenAckMessage,
                             t),
    GNUNET_MQ_hd_fixed_size (plaintext_channel_destroy,
                             GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY,
                             struct GNUNET_CADET_ChannelDestroyMessage,
                             t),
    GNUNET_MQ_handler_end ()
  };
 
  t->kx_retry_delay = INITIAL_KX_RETRY_DELAY;
  new_ephemeral (&t->ax);
  GNUNET_CRYPTO_ecdhe_key_create (&t->ax.kx_0);
  t->destination = destination;
  t->channels = GNUNET_CONTAINER_multihashmap32_create (8);
  t->maintain_connections_task
    = GNUNET_SCHEDULER_add_now (&maintain_connections_cb,
                                t);
  t->mq = GNUNET_MQ_queue_for_callbacks (NULL,
                                         NULL,
                                         NULL,
                                         NULL,
                                         handlers,
                                         &decrypted_error_cb,
                                         t);
  t->mst = GNUNET_MST_create (&handle_decrypted,
                              t);
  return t;
}

References decrypted_error_cb(), GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA, GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK, GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY, GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE, GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN, GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_queue_for_callbacks(), GNUNET_MST_create(), GNUNET_new, GNUNET_SCHEDULER_add_now(), handle_decrypted(), handlers, INITIAL_KX_RETRY_DELAY, maintain_connections_cb(), new_ephemeral(), and t.

Referenced by GCP_get_tunnel().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_destroy_tunnel_now()

void GCT_destroy_tunnel_now

(

struct CadetTunnel *

t

)

Destroys the tunnel t now, without delay.

Used during shutdown.

Parameters

t	tunnel to destroy

Definition at line 2467 of file gnunet-service-cadet_tunnels.c.

{
  GNUNET_assert (GNUNET_YES == shutting_down);
  GNUNET_CONTAINER_multihashmap32_iterate (t->channels,
                                           &destroy_remaining_channels,
                                           t);
  GNUNET_assert (0 ==
                 GCT_count_channels (t));
  if (NULL != t->destroy_task)
  {
    GNUNET_SCHEDULER_cancel (t->destroy_task);
    t->destroy_task = NULL;
  }
  destroy_tunnel (t);
}

References destroy_remaining_channels(), destroy_tunnel(), GCT_count_channels(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, shutting_down, and t.

Referenced by destroy_tunnels_now().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_add_inbound_connection()

int GCT_add_inbound_connection	(	struct CadetTunnel *	t,
		const struct GNUNET_CADET_ConnectionTunnelIdentifier *	cid,
		struct CadetPeerPath *	path
	)

Add a connection to the tunnel.

Parameters

t	a tunnel
cid	connection identifier to use for the connection
path	path to use for the connection

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure (duplicate connection)

Definition at line 3352 of file gnunet-service-cadet_tunnels.c.

{
  struct CadetTConnection *ct;
 
  ct = GNUNET_new (struct CadetTConnection);
  ct->created = GNUNET_TIME_absolute_get ();
  ct->t = t;
  ct->cc = GCC_create_inbound (t->destination,
                               path,
                               ct,
                               cid,
                               &connection_ready_cb,
                               ct);
  if (NULL == ct->cc)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "%s refused inbound %s (duplicate)\n",
         GCT_2s (t),
         GCC_2s (ct->cc));
    GNUNET_free (ct);
    return GNUNET_SYSERR;
  }
  /* FIXME: schedule job to kill connection (and path?)  if it takes
     too long to get ready! (And track performance data on how long
     other connections took with the tunnel!)
     => Note: to be done within 'connection'-logic! */
  GNUNET_CONTAINER_DLL_insert (t->connection_busy_head,
                               t->connection_busy_tail,
                               ct);
  t->num_busy_connections++;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "%s has new %s\n",
       GCT_2s (t),
       GCC_2s (ct->cc));
  return GNUNET_OK;
}

References CadetTConnection::cc, connection_ready_cb(), CadetTConnection::created, GCC_2s(), GCC_create_inbound(), GCT_2s(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_get(), LOG, t, and CadetTConnection::t.

Referenced by handle_connection_create().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_connection_lost()

void GCT_connection_lost

(

struct CadetTConnection *

ct

)

We lost a connection, remove it from our list and clean up the connection object itself.

Parameters

ct	binding of connection to tunnel of the connection that was lost.

Definition at line 2303 of file gnunet-service-cadet_tunnels.c.

{
  struct CadetTunnel *t = ct->t;
 
  if (GNUNET_YES == ct->is_ready)
  {
    GNUNET_CONTAINER_DLL_remove (t->connection_ready_head,
                                 t->connection_ready_tail,
                                 ct);
    t->num_ready_connections--;
  }
  else
  {
    GNUNET_CONTAINER_DLL_remove (t->connection_busy_head,
                                 t->connection_busy_tail,
                                 ct);
    t->num_busy_connections--;
  }
  GNUNET_free (ct);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_YES, CadetTConnection::is_ready, t, and CadetTConnection::t.

Referenced by destroy_t_connection(), GCC_create_inbound(), and GCC_destroy_without_core().

Here is the caller graph for this function:

GCT_get_destination()

struct CadetPeer * GCT_get_destination

(

struct CadetTunnel *

t

)

Return the peer to which this tunnel goes.

Parameters

t

a tunnel

Returns

the destination of the tunnel

Definition at line 648 of file gnunet-service-cadet_tunnels.c.

{
  return t->destination;
}

References t.

Referenced by GCCH_2s(), GCCH_bind(), GCCH_channel_incoming_new(), get_next_free_ctn(), and timeout_closed_cb().

Here is the caller graph for this function:

GCT_consider_path()

void GCT_consider_path	(	struct CadetTunnel *	t,
		struct CadetPeerPath *	p,
		unsigned int	off
	)

Consider using the path p for the tunnel t.

The tunnel destination is at offset off in path p.

Parameters

t	our tunnel
p	a path to our destination
off	offset of the destination on path path

Definition at line 2983 of file gnunet-service-cadet_tunnels.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Considering %s for %s (offset %u)\n",
       GCPP_2s (p),
       GCT_2s (t),
       off);
  (void) consider_path_cb (t,
                           p,
                           off);
}

References consider_path_cb(), GCPP_2s(), GCT_2s(), GNUNET_ERROR_TYPE_DEBUG, LOG, p, and t.

Referenced by GCP_path_entry_add(), and GCP_set_mq().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_add_channel()

struct GNUNET_CADET_ChannelTunnelNumber GCT_add_channel	(	struct CadetTunnel *	t,
		struct CadetChannel *	ch
	)

Add a channel to a tunnel.

Parameters

t	Tunnel.
ch	Channel

Returns

unique number identifying ch within t

Add a channel to a tunnel.

Otherwise that notification will be done later in notify_tunnel_up_cb().

Parameters

t	Tunnel.
ch	Channel

Returns

unique number identifying ch within t

Definition at line 2244 of file gnunet-service-cadet_tunnels.c.

{
  struct GNUNET_CADET_ChannelTunnelNumber ctn;
 
  ctn = get_next_free_ctn (t);
  if (NULL != t->destroy_task)
  {
    GNUNET_SCHEDULER_cancel (t->destroy_task);
    t->destroy_task = NULL;
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap32_put (t->channels,
                                                      ntohl (ctn.cn),
                                                      ch,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Adding %s to %s with state %d\n",
       GCCH_2s (ch),
       GCT_2s (t),
       t->estate);
  switch (t->estate)
  {
  case CADET_TUNNEL_KEY_UNINITIALIZED:
    /* waiting for connection to start KX */
    break;
 
  case CADET_TUNNEL_KEY_AX_RECV:
  case CADET_TUNNEL_KEY_AX_SENT:
  case CADET_TUNNEL_KEY_AX_SENT_AND_RECV:
    /* we're currently waiting for KX to complete */
    break;
 
  case CADET_TUNNEL_KEY_AX_AUTH_SENT:
    /* waiting for OTHER peer to send us data,
       we might need to prompt more aggressively! */
    if (NULL == t->kx_task)
      t->kx_task
        = GNUNET_SCHEDULER_add_at (t->next_kx_attempt,
                                   &retry_kx,
                                   t);
    break;
 
  case CADET_TUNNEL_KEY_OK:
    /* We are ready. Tell the new channel that we are up. */
    GCCH_tunnel_up (ch);
    break;
  }
  return ctn;
}

References CADET_TUNNEL_KEY_AX_AUTH_SENT, CADET_TUNNEL_KEY_AX_RECV, CADET_TUNNEL_KEY_AX_SENT, CADET_TUNNEL_KEY_AX_SENT_AND_RECV, CADET_TUNNEL_KEY_OK, CADET_TUNNEL_KEY_UNINITIALIZED, ch, GNUNET_CADET_ChannelTunnelNumber::cn, GCCH_2s(), GCCH_tunnel_up(), GCT_2s(), get_next_free_ctn(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, LOG, retry_kx(), and t.

Referenced by GCCH_channel_local_new().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_remove_channel()

void GCT_remove_channel	(	struct CadetTunnel *	t,
		struct CadetChannel *	ch,
		struct GNUNET_CADET_ChannelTunnelNumber	ctn
	)

Remove a channel from a tunnel.

Parameters

t	Tunnel.
ch	Channel
ctn	unique number identifying ch within t

Definition at line 2416 of file gnunet-service-cadet_tunnels.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Removing %s from %s\n",
       GCCH_2s (ch),
       GCT_2s (t));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap32_remove (t->channels,
                                                         ntohl (ctn.cn),
                                                         ch));
  if ((0 ==
       GCT_count_channels (t)) &&
      (NULL == t->destroy_task))
  {
    t->destroy_task
      = GNUNET_SCHEDULER_add_delayed (IDLE_DESTROY_DELAY,
                                      &destroy_tunnel,
                                      t);
  }
}

References ch, GNUNET_CADET_ChannelTunnelNumber::cn, destroy_tunnel(), GCCH_2s(), GCT_2s(), GCT_count_channels(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, IDLE_DESTROY_DELAY, LOG, and t.

Referenced by channel_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_send_channel_destroy()

void GCT_send_channel_destroy	(	struct CadetTunnel *	t,
		struct GNUNET_CADET_ChannelTunnelNumber	ctn
	)

Send a DESTROY message via the tunnel.

Parameters

t	the tunnel to transmit over
ctn	ID of the channel to destroy

Definition at line 3159 of file gnunet-service-cadet_tunnels.c.

{
  struct GNUNET_CADET_ChannelDestroyMessage msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending DESTROY message for channel ID %u\n",
       ntohl (ctn.cn));
  msg.header.size = htons (sizeof(msg));
  msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY);
  msg.reserved = htonl (0);
  msg.ctn = ctn;
  GCT_send (t,
            &msg.header,
            NULL,
            NULL,
            &ctn);
}

References GNUNET_CADET_ChannelTunnelNumber::cn, GNUNET_CADET_ChannelDestroyMessage::ctn, GCT_send(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY, LOG, msg, GNUNET_MessageHeader::size, t, and GNUNET_MessageHeader::type.

Referenced by GCCH_channel_local_destroy(), GCCH_handle_channel_plaintext_data(), GCCH_handle_local_ack(), handle_plaintext_channel_open_ack(), handle_plaintext_data(), and handle_plaintext_data_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_send()

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

Parameters

message	Message to send. Function modifies it.
t	Tunnel on which this message is transmitted.
cont	Continuation to call once message is really sent.
cont_cls	Closure for cont.

Returns

Handle to cancel message.

Definition at line 3575 of file gnunet-service-cadet_tunnels.c.

{
  struct CadetTunnelQueueEntry *tq;
  uint16_t payload_size;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_CADET_TunnelEncryptedMessage *ax_msg;
  struct CadetChannel *ch;
 
  if (NULL != ctn)
  {
    ch = lookup_channel (t,
                         *ctn);
    if ((NULL != ch) && GCCH_is_type_to_drop (ch, message))
    {
      GNUNET_break (0);
      return NULL;
    }
  }
 
  if (CADET_TUNNEL_KEY_OK != t->estate)
  {
    GNUNET_break (0);
    return NULL;
  }
  payload_size = ntohs (message->size);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Encrypting %u bytes for %s\n",
       (unsigned int) payload_size,
       GCT_2s (t));
  env = GNUNET_MQ_msg_extra (ax_msg,
                             payload_size,
                             GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED);
  t_ax_encrypt (&t->ax,
                &ax_msg[1],
                message,
                payload_size);
  GNUNET_STATISTICS_update (stats,
                            "# encrypted bytes",
                            payload_size,
                            GNUNET_NO);
  ax_msg->ax_header.Ns = htonl (t->ax.Ns++);
  ax_msg->ax_header.PNs = htonl (t->ax.PNs);
  /* FIXME: we should do this once, not once per message;
     this is a point multiplication, and DHRs does not
     change all the time. */
  GNUNET_CRYPTO_ecdhe_key_get_public (&t->ax.DHRs,
                                      &ax_msg->ax_header.DHRs);
  t_h_encrypt (&t->ax,
               ax_msg);
  t_hmac (&ax_msg->ax_header,
          sizeof(struct GNUNET_CADET_AxHeader) + payload_size,
          0,
          &t->ax.HKs,
          &ax_msg->hmac);
 
  tq = GNUNET_malloc (sizeof(*tq));
  tq->t = t;
  tq->env = env;
  tq->cid = &ax_msg->cid; /* will initialize 'ax_msg->cid' once we know the connection */
  tq->cont = cont;
  tq->cont_cls = cont_cls;
  GNUNET_CONTAINER_DLL_insert_tail (t->tq_head,
                                    t->tq_tail,
                                    tq);
  if (NULL != t->send_task)
    GNUNET_SCHEDULER_cancel (t->send_task);
  t->send_task
    = GNUNET_SCHEDULER_add_now (&trigger_transmissions,
                                t);
  return tq;
}

References GNUNET_CADET_TunnelEncryptedMessage::ax_header, CADET_TUNNEL_KEY_OK, ch, GNUNET_CADET_TunnelEncryptedMessage::cid, CadetTunnelQueueEntry::cid, CadetTunnelQueueEntry::cont, CadetTunnelQueueEntry::cont_cls, CadetChannel::ctn, GNUNET_CADET_AxHeader::DHRs, env, CadetTunnelQueueEntry::env, GCCH_is_type_to_drop(), GCT_2s(), GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_malloc, GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED, GNUNET_MQ_msg_extra, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_CADET_TunnelEncryptedMessage::hmac, LOG, lookup_channel(), GNUNET_CADET_AxHeader::Ns, GNUNET_CADET_AxHeader::PNs, GNUNET_MessageHeader::size, stats, t, CadetTunnelQueueEntry::t, t_ax_encrypt(), t_h_encrypt(), t_hmac(), and trigger_transmissions().

Referenced by GCCH_handle_local_data(), GCT_send_channel_destroy(), retry_transmission(), send_channel_data_ack(), send_channel_open(), send_keepalive(), and send_open_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_send_cancel()

void GCT_send_cancel

(

struct CadetTunnelQueueEntry *

q

)

Cancel a previously sent message while it's in the queue.

ONLY can be called before the continuation given to the send function is called. Once the continuation is called, the message is no longer in the queue!

Parameters

q	Handle to the queue entry to cancel.

Definition at line 3653 of file gnunet-service-cadet_tunnels.c.

{
  struct CadetTunnel *t = tq->t;
 
  GNUNET_CONTAINER_DLL_remove (t->tq_head,
                               t->tq_tail,
                               tq);
  GNUNET_MQ_discard (tq->env);
  GNUNET_free (tq);
}

References CadetTunnelQueueEntry::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_discard(), t, and CadetTunnelQueueEntry::t.

Referenced by channel_destroy(), destroy_tunnel(), GCC_destroy(), handle_matching_ack(), send_channel_data_ack(), send_channel_open(), and send_open_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_count_channels()

unsigned int GCT_count_channels

(

struct CadetTunnel *

t

)

Returns the number of channels using a tunnel.

Parameters

t	Tunnel in question.

Returns

Number of channels using the tunnel.

Definition at line 655 of file gnunet-service-cadet_tunnels.c.

{
  return GNUNET_CONTAINER_multihashmap32_size (t->channels);
}

References GNUNET_CONTAINER_multihashmap32_size(), and t.

Referenced by connection_ready_cb(), destroy_tunnel(), GCT_destroy_tunnel_now(), GCT_remove_channel(), get_all_tunnels_iterator(), and retry_kx().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_count_any_connections()

unsigned int GCT_count_any_connections

(

const struct CadetTunnel *

t

)

Counts the number of connections created for a tunnel, including busy connections.

Parameters

t	Tunnel to be counted.

Returns

Number of connections created for the tunnel.

Definition at line 678 of file gnunet-service-cadet_tunnels.c.

{
  return t->num_ready_connections + t->num_busy_connections;
}

References t.

Referenced by consider_path_cb(), GCT_debug(), get_all_tunnels_iterator(), and maintain_connections_cb().

Here is the caller graph for this function:

GCT_iterate_connections()

void GCT_iterate_connections	(	struct CadetTunnel *	t,
		GCT_ConnectionIterator	iter,
		void *	iter_cls
	)

Iterate over all connections of a tunnel.

Parameters

t	Tunnel whose connections to iterate.
iter	Iterator.
iter_cls	Closure for iter.

Definition at line 3673 of file gnunet-service-cadet_tunnels.c.

{
  struct CadetTConnection *n;
 
  for (struct CadetTConnection *ct = t->connection_ready_head;
       NULL != ct;
       ct = n)
  {
    n = ct->next;
    iter (iter_cls,
          ct);
  }
  for (struct CadetTConnection *ct = t->connection_busy_head;
       NULL != ct;
       ct = n)
  {
    n = ct->next;
    iter (iter_cls,
          ct);
  }
}

References CadetTConnection::next, and t.

Referenced by consider_path_cb(), destroy_tunnel(), and maintain_connections_cb().

Here is the caller graph for this function:

GCT_iterate_channels()

void GCT_iterate_channels	(	struct CadetTunnel *	t,
		GCT_ChannelIterator	iter,
		void *	iter_cls
	)

Iterate over all channels of a tunnel.

Parameters

t	Tunnel whose channels to iterate.
iter	Iterator.
iter_cls	Closure for iter.

Definition at line 3745 of file gnunet-service-cadet_tunnels.c.

{
  struct ChanIterCls ctx;
 
  ctx.iter = iter;
  ctx.iter_cls = iter_cls;
  GNUNET_CONTAINER_multihashmap32_iterate (t->channels,
                                           &iterate_channels_cb,
                                           &ctx);
}

References ctx, GNUNET_CONTAINER_multihashmap32_iterate(), ChanIterCls::iter, ChanIterCls::iter_cls, iterate_channels_cb(), and t.

Here is the call graph for this function:

GCT_get_estate()

enum CadetTunnelEState GCT_get_estate

(

struct CadetTunnel *

t

)

Get the encryption state of a tunnel.

Parameters

t

Tunnel.

Returns

Tunnel's encryption state.

Definition at line 710 of file gnunet-service-cadet_tunnels.c.

{
  return t->estate;
}

References t.

Referenced by get_all_tunnels_iterator(), handle_connection_create(), send_create(), and send_keepalive().

Here is the caller graph for this function:

GCT_change_estate()

void GCT_change_estate	(	struct CadetTunnel *	t,
		enum CadetTunnelEState	state
	)

Change the tunnel encryption state.

If the encryption state changes to OK, stop the rekey task.

Parameters

t	Tunnel whose encryption state to change, or NULL.
state	New encryption state.

Definition at line 1385 of file gnunet-service-cadet_tunnels.c.

{
  enum CadetTunnelEState old = t->estate;
 
  t->estate = state;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "%s estate changed from %s to %s\n",
       GCT_2s (t),
       estate2s (old),
       estate2s (state));
 
  if ((CADET_TUNNEL_KEY_OK != old) &&
      (CADET_TUNNEL_KEY_OK == t->estate))
  {
    if (NULL != t->kx_task)
    {
      GNUNET_SCHEDULER_cancel (t->kx_task);
      t->kx_task = NULL;
    }
    /* notify all channels that have been waiting */
    GNUNET_CONTAINER_multihashmap32_iterate (t->channels,
                                             &notify_tunnel_up_cb,
                                             t);
    if (NULL != t->send_task)
      GNUNET_SCHEDULER_cancel (t->send_task);
    t->send_task = GNUNET_SCHEDULER_add_now (&trigger_transmissions,
                                             t);
  }
}

References CADET_TUNNEL_KEY_OK, estate2s(), GCT_2s(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), LOG, notify_tunnel_up_cb(), state, t, and trigger_transmissions().

Referenced by cont_GCT_handle_kx(), cont_GCT_handle_kx_auth(), GCT_handle_encrypted(), handle_connection_create(), send_kx(), and send_kx_auth().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_handle_kx()

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 after we respond with our own KX_AUTH and finally successfully decrypt the payload).

Parameters

ct	connection/tunnel combo that received encrypted message
msg	the key exchange message

Handle KX message that lacks authentication (and which will thus only be considered authenticated after we respond with our own KX_AUTH and finally successfully decrypt the payload).

Parameters

cls	closure from updating AX by KX
ret	result from the update call

Definition at line 1870 of file gnunet-service-cadet_tunnels.c.

{
  struct CadetTunnel *t = ct->t;
 
  GNUNET_STATISTICS_update (stats,
                            "# KX received",
                            1,
                            GNUNET_NO);
  if (GNUNET_YES ==
      GCT_alice_or_betty (GCP_get_id (t->destination)))
  {
    /* Betty/Bob is not allowed to send KX! */
    GNUNET_break_op (0);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received KX message from %s with ephemeral %s from %s on connection %s\n",
       GCT_2s (t),
       GNUNET_e2s (&msg->ephemeral_key),
       GNUNET_i2s (GCP_get_id (t->destination)),
       GCC_2s (ct->cc));
#if 1
  if ((0 ==
       memcmp (&t->ax.DHRr,
               &msg->ratchet_key,
               sizeof(msg->ratchet_key))) &&
      (0 ==
       memcmp (&t->ax.last_ephemeral,
               &msg->ephemeral_key,
               sizeof(msg->ephemeral_key))))
 
  {
    GNUNET_STATISTICS_update (stats,
                              "# Duplicate KX received",
                              1,
                              GNUNET_NO);
    send_kx_auth (t,
                  ct,
                  &t->ax,
                  GNUNET_NO);
    return;
  }
#endif
  /* We only keep ONE unverified KX around, so if there is an existing one,
     clean it up. */
  if (NULL != t->unverified_ax)
  {
    if ((0 ==
         memcmp (&t->unverified_ax->DHRr,
                 &msg->ratchet_key,
                 sizeof(msg->ratchet_key))) &&
        (0 ==
         memcmp (&t->unverified_ax->last_ephemeral,
                 &msg->ephemeral_key,
                 sizeof(msg->ephemeral_key))))
    {
      GNUNET_STATISTICS_update (stats,
                                "# Duplicate unverified KX received",
                                1,
                                GNUNET_NO);
#if 1
      send_kx_auth (t,
                    ct,
                    t->unverified_ax,
                    GNUNET_NO);
      return;
#endif
    }
    if ((t->as.ecdh_op) &&
        (0 ==
         memcmp (&t->as.ratchet_key,
                 &msg->ratchet_key,
                 sizeof(msg->ratchet_key))) &&
        (0 ==
         memcmp (&t->as.ephemeral_key,
                 &msg->ephemeral_key,
                 sizeof(msg->ephemeral_key))))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Waiting for previous ECDH operation\n");
      return;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Dropping old unverified KX state.\n");
    GNUNET_STATISTICS_update (stats,
                              "# Unverified KX dropped for fresh KX",
                              1,
                              GNUNET_NO);
    GNUNET_break (NULL == t->unverified_ax->skipped_head);
    memset (t->unverified_ax,
            0,
            sizeof(struct CadetTunnelAxolotl));
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Creating fresh unverified KX for %s\n",
         GCT_2s (t));
    GNUNET_STATISTICS_update (stats,
                              "# Fresh KX setup",
                              1,
                              GNUNET_NO);
    t->unverified_ax = GNUNET_new (struct CadetTunnelAxolotl);
  }
  /* Set as the 'current' RK/DHRr the one we are currently using,
     so that the duplicate-detection logic of
   #update_ax_by_kx can work. */
  t->unverified_ax->RK = t->ax.RK;
  t->unverified_ax->DHRr = t->ax.DHRr;
  t->unverified_ax->DHRs = t->ax.DHRs;
  t->unverified_ax->kx_0 = t->ax.kx_0;
  t->unverified_attempts = 0;
 
  t->as.ax = *(t->unverified_ax);
  GNUNET_memcpy (&t->as.peer_id, GCP_get_id (t->destination),
                 sizeof (t->as.peer_id));
  GNUNET_memcpy (&t->as.ephemeral_key, &msg->ephemeral_key,
                 sizeof (t->as.ephemeral_key));
  GNUNET_memcpy (&t->as.ratchet_key, &msg->ratchet_key,
                 sizeof (t->as.ratchet_key));
  memset (&t->as.auth, 0, sizeof (t->as.auth));
  t->as.flags = 0;
  t->as.cb_cls = t;
  t->as.cb = &cont_GCT_handle_kx;
 
  if (t->as.ecdh_op)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Cancelling previous ECDH operation\n");
 
    GNUNET_PILS_cancel (t->as.ecdh_op);
  }
 
  t->as.ecdh_op = GNUNET_PILS_ecdh (pils, &msg->ephemeral_key,
                                    &update_ax_by_kx, &t->as);
}

References CadetTConnection::cc, cont_GCT_handle_kx(), GCC_2s(), GCP_get_id(), GCT_2s(), GCT_alice_or_betty(), GNUNET_break, GNUNET_break_op, GNUNET_e2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_PILS_cancel(), GNUNET_PILS_ecdh(), GNUNET_STATISTICS_update(), GNUNET_YES, LOG, msg, pils, send_kx_auth(), stats, t, CadetTConnection::t, and update_ax_by_kx().

Referenced by GCC_handle_kx().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_handle_kx_auth()

void GCT_handle_kx_auth	(	struct CadetTConnection *	ct,
		const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *	msg
	)

Handle KX_AUTH message.

Parameters

ct	connection/tunnel combo that received encrypted message
msg	the key exchange message

Definition at line 2127 of file gnunet-service-cadet_tunnels.c.

{
  struct CadetTunnel *t = ct->t;
 
  GNUNET_STATISTICS_update (stats,
                            "# KX_AUTH received",
                            1,
                            GNUNET_NO);
  if ((CADET_TUNNEL_KEY_UNINITIALIZED == t->estate) ||
      (CADET_TUNNEL_KEY_AX_RECV == t->estate))
  {
    /* Confusing, we got a KX_AUTH before we even send our own
       KX. This should not happen. We'll send our own KX ASAP anyway,
       so let's ignore this here. */
    GNUNET_break_op (0);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Handling KX_AUTH message from %s with ephemeral %s\n",
       GCT_2s (t),
       GNUNET_e2s (&msg->kx.ephemeral_key));
  if ((t->as.ecdh_op) &&
      (0 ==
       memcmp (&t->as.ratchet_key,
               &msg->kx.ratchet_key,
               sizeof(msg->kx.ratchet_key))) &&
      (0 ==
       memcmp (&t->as.ephemeral_key,
               &msg->kx.ephemeral_key,
               sizeof(msg->kx.ephemeral_key))))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Waiting for previous ECDH operation\n");
    return;
  }
  /* We do everything in a copy until we've checked the authentication
     so we don't clobber anything we care about by accident. */
  t->as.ax = t->ax;
  GNUNET_memcpy (&t->as.peer_id, GCP_get_id (t->destination),
                 sizeof (t->as.peer_id));
  GNUNET_memcpy (&t->as.ephemeral_key, &msg->kx.ephemeral_key,
                 sizeof (t->as.ephemeral_key));
  GNUNET_memcpy (&t->as.ratchet_key, &msg->kx.ratchet_key,
                 sizeof (t->as.ratchet_key));
  t->as.auth = msg->auth;
  t->as.flags = msg->kx.flags;
  t->as.cb_cls = t;
  t->as.cb = &cont_GCT_handle_kx_auth;
 
  if (t->as.ecdh_op)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Cancelling previous ECDH operation\n");
 
    GNUNET_PILS_cancel (t->as.ecdh_op);
  }
 
  /* Update 'ax' by the new key material */
  t->as.ecdh_op = GNUNET_PILS_ecdh (pils, &msg->kx.ephemeral_key,
                                    &update_ax_by_kx, &t->as);
}

References CADET_TUNNEL_KEY_AX_RECV, CADET_TUNNEL_KEY_UNINITIALIZED, cont_GCT_handle_kx_auth(), GCP_get_id(), GCT_2s(), GNUNET_break_op, GNUNET_e2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_NO, GNUNET_PILS_cancel(), GNUNET_PILS_ecdh(), GNUNET_STATISTICS_update(), LOG, msg, pils, stats, t, CadetTConnection::t, and update_ax_by_kx().

Referenced by GCC_handle_kx_auth().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_handle_encrypted()

void GCT_handle_encrypted	(	struct CadetTConnection *	ct,
		const struct GNUNET_CADET_TunnelEncryptedMessage *	msg
	)

Handle encrypted message.

Parameters

ct	connection/tunnel combo that received encrypted message
msg	the encrypted message to decrypt

Definition at line 3400 of file gnunet-service-cadet_tunnels.c.

{
  struct CadetTunnel *t = ct->t;
  uint16_t size = ntohs (msg->header.size);
  char cbuf[size] GNUNET_ALIGN;
  ssize_t decrypted_size;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "%s received %u bytes of encrypted data in state %d\n",
       GCT_2s (t),
       (unsigned int) size,
       t->estate);
 
  switch (t->estate)
  {
  case CADET_TUNNEL_KEY_UNINITIALIZED:
  case CADET_TUNNEL_KEY_AX_RECV:
    /* We did not even SEND our KX, how can the other peer
       send us encrypted data? Must have been that we went
       down and the other peer still things we are up.
       Let's send it KX back. */
    GNUNET_STATISTICS_update (stats,
                              "# received encrypted without any KX",
                              1,
                              GNUNET_NO);
    if (NULL != t->kx_task)
    {
      GNUNET_SCHEDULER_cancel (t->kx_task);
      t->kx_task = NULL;
    }
    send_kx (t,
             ct,
             &t->ax);
    return;
 
  case CADET_TUNNEL_KEY_AX_SENT_AND_RECV:
    /* We send KX, and other peer send KX to us at the same time.
       Neither KX is AUTH'ed, so let's try KX_AUTH this time. */
    GNUNET_STATISTICS_update (stats,
                              "# received encrypted without KX_AUTH",
                              1,
                              GNUNET_NO);
    if (NULL != t->kx_task)
    {
      GNUNET_SCHEDULER_cancel (t->kx_task);
      t->kx_task = NULL;
    }
    send_kx_auth (t,
                  ct,
                  &t->ax,
                  GNUNET_YES);
    return;
 
  case CADET_TUNNEL_KEY_AX_SENT:
    /* We did not get the KX of the other peer, but that
       might have been lost.  Send our KX again immediately. */
    GNUNET_STATISTICS_update (stats,
                              "# received encrypted without KX",
                              1,
                              GNUNET_NO);
    if (NULL != t->kx_task)
    {
      GNUNET_SCHEDULER_cancel (t->kx_task);
      t->kx_task = NULL;
    }
    send_kx (t,
             ct,
             &t->ax);
    return;
 
  case CADET_TUNNEL_KEY_AX_AUTH_SENT:
  /* Great, first payload, we might graduate to OK! */
  case CADET_TUNNEL_KEY_OK:
    /* We are up and running, all good. */
    break;
  }
 
  decrypted_size = -1;
  if (CADET_TUNNEL_KEY_OK == t->estate)
  {
    /* We have well-established key material available,
       try that. (This is the common case.) */
    decrypted_size = t_ax_decrypt_and_validate (&t->ax,
                                                cbuf,
                                                msg,
                                                size);
  }
 
  if ((-1 == decrypted_size) &&
      (NULL != t->unverified_ax))
  {
    /* We have un-authenticated KX material available. We should try
       this as a back-up option, in case the sender crashed and
       switched keys. */
    decrypted_size = t_ax_decrypt_and_validate (t->unverified_ax,
                                                cbuf,
                                                msg,
                                                size);
    if (-1 != decrypted_size)
    {
      /* It worked! Treat this as authentication of the AX data! */
      cleanup_ax (&t->ax);
      t->ax = *t->unverified_ax;
      GNUNET_free (t->unverified_ax);
      t->unverified_ax = NULL;
    }
    if (CADET_TUNNEL_KEY_AX_AUTH_SENT == t->estate)
    {
      /* First time it worked, move tunnel into production! */
      GCT_change_estate (t,
                         CADET_TUNNEL_KEY_OK);
      if (NULL != t->send_task)
        GNUNET_SCHEDULER_cancel (t->send_task);
      t->send_task = GNUNET_SCHEDULER_add_now (&trigger_transmissions,
                                               t);
    }
  }
  if (NULL != t->unverified_ax)
  {
    /* We had unverified KX material that was useless; so increment
       counter and eventually move to ignore it.  Note that we even do
       this increment if we successfully decrypted with the old KX
       material and thus didn't even both with the new one.  This is
       the ideal case, as a malicious injection of bogus KX data
       basically only causes us to increment a counter a few times. */t->unverified_attempts++;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Failed to decrypt message with unverified KX data %u times\n",
         t->unverified_attempts);
    if (t->unverified_attempts > MAX_UNVERIFIED_ATTEMPTS)
    {
      cleanup_ax (t->unverified_ax);
      GNUNET_free (t->unverified_ax);
      t->unverified_ax = NULL;
    }
  }
 
  if (-1 == decrypted_size)
  {
    /* Decryption failed for good, complain. */
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "%s failed to decrypt and validate encrypted data, retrying KX\n",
         GCT_2s (t));
    GNUNET_STATISTICS_update (stats,
                              "# unable to decrypt",
                              1,
                              GNUNET_NO);
    if (NULL != t->kx_task)
    {
      GNUNET_SCHEDULER_cancel (t->kx_task);
      t->kx_task = NULL;
    }
    send_kx (t,
             ct,
             &t->ax);
    return;
  }
  GNUNET_STATISTICS_update (stats,
                            "# decrypted bytes",
                            decrypted_size,
                            GNUNET_NO);
 
  /* The MST will ultimately call #handle_decrypted() on each message. */
  t->current_ct = ct;
  GNUNET_break_op (GNUNET_OK ==
                   GNUNET_MST_from_buffer (t->mst,
                                           cbuf,
                                           decrypted_size,
                                           GNUNET_YES,
                                           GNUNET_NO));
  t->current_ct = NULL;
}

References CADET_TUNNEL_KEY_AX_AUTH_SENT, CADET_TUNNEL_KEY_AX_RECV, CADET_TUNNEL_KEY_AX_SENT, CADET_TUNNEL_KEY_AX_SENT_AND_RECV, CADET_TUNNEL_KEY_OK, CADET_TUNNEL_KEY_UNINITIALIZED, cleanup_ax(), GCT_2s(), GCT_change_estate(), GNUNET_ALIGN, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_MST_from_buffer(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_YES, LOG, MAX_UNVERIFIED_ATTEMPTS, msg, send_kx(), send_kx_auth(), GNUNET_MessageHeader::size, size, stats, t, CadetTConnection::t, t_ax_decrypt_and_validate(), and trigger_transmissions().

Referenced by GCC_handle_encrypted().

Here is the call graph for this function:

Here is the caller graph for this function:

GCT_debug()

void GCT_debug	(	const struct CadetTunnel *	t,
		enum GNUNET_ErrorType	level
	)

Log all possible info about the tunnel state.

Parameters

t	Tunnel to debug.
level	Debug level to use.

Definition at line 3791 of file gnunet-service-cadet_tunnels.c.

{
#if ! defined(GNUNET_CULL_LOGGING)
  struct CadetTConnection *iter_c;
  int do_log;
 
  do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
                                       "cadet-tun",
                                       __FILE__, __FUNCTION__, __LINE__);
  if (0 == do_log)
    return;
 
  LOG2 (level,
        "TTT TUNNEL TOWARDS %s in estate %s tq_len: %u #cons: %u\n",
        GCT_2s (t),
        estate2s (t->estate),
        t->tq_len,
        GCT_count_any_connections (t));
  LOG2 (level,
        "TTT channels:\n");
  GNUNET_CONTAINER_multihashmap32_iterate (t->channels,
                                           &debug_channel,
                                           &level);
  LOG2 (level,
        "TTT connections:\n");
  for (iter_c = t->connection_ready_head; NULL != iter_c; iter_c = iter_c->next)
    GCC_debug (iter_c->cc,
               level);
  for (iter_c = t->connection_busy_head; NULL != iter_c; iter_c = iter_c->next)
    GCC_debug (iter_c->cc,
               level);
 
  LOG2 (level,
        "TTT TUNNEL END\n");
#endif
}

References CadetTConnection::cc, debug_channel(), estate2s(), GCC_debug(), GCT_2s(), GCT_count_any_connections(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_ERROR_TYPE_BULK, GNUNET_get_log_call_status(), LOG2, CadetTConnection::next, and t.

Here is the call graph for this function: