gnunet-communicator-udp.c File Reference

Transport plugin using UDP. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_constants.h"
#include "gnunet_nt_lib.h"
#include "gnunet_nat_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_application_service.h"
#include "gnunet_transport_communication_service.h"

Include dependency graph for gnunet-communicator-udp.c:

Go to the source code of this file.

Data Structures
struct	UdpHandshakeSignature
	Signature we use to verify that the ephemeral key was really chosen by the specified sender. More...
struct	InitialKX
	"Plaintext" header at beginning of KX message. More...
struct	UDPConfirmation
	Encrypted continuation of UDP initial handshake, followed by message header with payload. More...
struct	UDPAck
	UDP key acknowledgement. More...
struct	UdpBroadcastSignature
	Signature we use to verify that the broadcast was really made by the peer that claims to have made it. More...
struct	UDPBroadcast
	Broadcast by peer in LAN announcing its presence. More...
struct	UDPBox
	UDP message box. More...
struct	UDPRekey
	UDP message box. More...
struct	KeyCacheEntry
	Pre-generated "kid" code (key and IV identification code) to quickly derive master key for a struct UDPBox. More...
struct	SharedSecret
	Shared secret we generated for a particular sender or receiver. More...
struct	SenderAddress
	Information we track per sender address we have recently been in contact with (we decrypt messages from the sender). More...
struct	ReceiverAddress
	Information we track per receiving address we have recently been in contact with (encryption to receiver). More...
struct	BroadcastInterface
	Interface we broadcast our presence on. More...
struct	SearchContext
	Context information to be used while searching for operation contexts. More...

Macros
#define	DEFAULT_REKEY_TIME_INTERVAL   GNUNET_TIME_UNIT_DAYS
	How often do we rekey based on time (at least) More...
#define	PROTO_QUEUE_TIMEOUT   GNUNET_TIME_UNIT_MINUTES
	How long do we wait until we must have received the initial KX? More...
#define	BROADCAST_FREQUENCY   GNUNET_TIME_UNIT_MINUTES
	How often do we broadcast our presence on the LAN? More...
#define	INTERFACE_SCAN_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
	How often do we scan for changes to our network interfaces? More...
#define	ADDRESS_VALIDITY_PERIOD   GNUNET_TIME_UNIT_HOURS
	How long do we believe our addresses to remain up (before the other peer should revalidate). More...
#define	WORKING_QUEUE_INTERVALL    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1)
#define	AES_KEY_SIZE   (256 / 8)
	AES key size. More...
#define	AES_IV_SIZE   (96 / 8)
	AES (GCM) IV size. More...
#define	GCM_TAG_SIZE   (128 / 8)
	Size of the GCM tag. More...
#define	GENERATE_AT_ONCE   2
#define	KCN_THRESHOLD   92
	If we fall below this number of available KCNs, we generate additional ACKs until we reach KCN_TARGET. More...
#define	KCN_TARGET   128
	How many KCNs do we keep around after we hit the KCN_THRESHOLD? Should be larger than KCN_THRESHOLD so we do not generate just one ACK at the time. More...
#define	MAX_SQN_DELTA   160
	What is the maximum delta between KCN sequence numbers that we allow. More...
#define	MAX_SECRETS   128000
	How many shared master secrets do we keep around at most per sender? Should be large enough so that we generally have a chance of sending an ACK before the sender already rotated out the master secret. More...
#define	DEFAULT_REKEY_MAX_BYTES   (1024LLU * 1024 * 1024 * 4LLU)
	Default value for how often we do rekey based on number of bytes transmitted? (additionally randomized). More...
#define	COMMUNICATOR_ADDRESS_PREFIX   "udp"
	Address prefix used by the communicator. More...
#define	COMMUNICATOR_CONFIG_SECTION   "communicator-udp"
	Configuration section used by the communicator. More...

Functions
static void	bi_destroy (struct BroadcastInterface *bi)
	An interface went away, stop broadcasting on it. More...
static void	receiver_destroy (struct ReceiverAddress *receiver)
	Destroys a receiving state due to timeout or shutdown. More...
static void	kce_destroy (struct KeyCacheEntry *kce)
	Free memory used by key cache entry. More...
static void	get_kid (const struct GNUNET_HashCode *msec, uint32_t serial, struct GNUNET_ShortHashCode *kid)
	Compute kid. More...
static void	kce_generate (struct SharedSecret *ss, uint32_t seq)
	Setup key cache entry for sequence number seq and shared secret ss. More...
static int	secret_destroy (struct SharedSecret *ss, int withoutKce)
	Destroy ss and associated key cache entries. More...
static void	sender_destroy (struct SenderAddress *sender)
	Functions with this signature are called whenever we need to close a sender's state due to timeout. More...
static void	get_iv_key (const struct GNUNET_HashCode *msec, uint32_t serial, char key[(256/8)], char iv[(96/8)])
	Compute key and iv. More...
static void	reschedule_sender_timeout (struct SenderAddress *sender)
	Increment sender timeout due to activity. More...
static void	reschedule_receiver_timeout (struct ReceiverAddress *receiver)
	Increment receiver timeout due to activity. More...
static void	check_timeouts (void *cls)
	Task run to check #receiver_heap and #sender_heap for timeouts. More...
static void	calculate_cmac (struct SharedSecret *ss)
	Calculate cmac from master in ss. More...
static void	pass_plaintext_to_core (struct SenderAddress *sender, const void *plaintext, size_t plaintext_len)
	We received plaintext_len bytes of plaintext from a sender. More...
static void	setup_cipher (const struct GNUNET_HashCode *msec, uint32_t serial, gcry_cipher_hd_t *cipher)
	Setup cipher based on shared secret msec and serial number serial. More...
static int	try_decrypt (const struct SharedSecret *ss, const char tag[(128/8)], uint32_t serial, const char *in_buf, size_t in_buf_size, char *out_buf)
	Try to decrypt buf using shared secret ss and key/iv derived using serial. More...
static struct SharedSecret *	setup_shared_secret_dec (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral)
	Setup shared secret for decryption. More...
static struct SharedSecret *	setup_shared_secret_enc (const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral, struct ReceiverAddress *receiver, int add_to_receiver)
	Setup shared secret for encryption. More...
static void	setup_receiver_mq (struct ReceiverAddress *receiver)
	Setup the MQ for the receiver. More...
static void	destroy_all_secrets (struct SharedSecret *ss, int withoutKce)
	Destroying all secrets. More...
static void	add_acks (struct SharedSecret *ss, int acks_to_add)
static uint32_t	reset_rekey_kces (struct ReceiverAddress *receiver, uint32_t acks_to_add)
static void	add_acks_rekey (struct ReceiverAddress *receiver)
static int	handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	We received an ACK for pid. More...
static void	try_handle_plaintext (struct SenderAddress *sender, const void *buf, size_t buf_size)
	Test if we have received a valid message in plaintext. More...
static void	kce_generate_cb (void *cls)
static void	kce_generate_rekey_cb (void *cls)
static void	consider_ss_ack (struct SharedSecret *ss, int initial)
	We established a shared secret with a sender. More...
static void	decrypt_box (const struct UDPBox *box, size_t box_len, struct KeyCacheEntry *kce)
	We received a box with matching kce. More...
static void	decrypt_rekey (const struct UDPRekey *rekey, size_t rekey_len, struct KeyCacheEntry *kce, struct SenderAddress *sender)
	We received a rekey with matching kce. More...
static int	find_sender_by_address (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Find existing struct SenderAddress by matching addresses. More...
static struct SenderAddress *	setup_sender (const struct GNUNET_PeerIdentity *target, const struct sockaddr *address, socklen_t address_len)
	Create sender address for target. More...
static int	verify_confirmation (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, const struct UDPConfirmation *uc)
	Check signature from uc against ephemeral. More...
static char *	sockaddr_to_udpaddr_string (const struct sockaddr *address, socklen_t address_len)
	Converts address to the address string format used by this communicator in HELLOs. More...
static void	sock_read (void *cls)
	Socket read task. More...
static struct sockaddr *	udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
	Convert UDP bind specification to a struct sockaddr * More...
static void	do_pad (gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
	Pad dgram by pad_size using out_cipher. More...
static void	mq_send_kx (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
	Signature of functions implementing the sending functionality of a message queue. More...
static void	check_for_rekeying (struct ReceiverAddress *receiver, struct UDPBox *box)
static void	send_UDPRekey (struct ReceiverAddress *receiver, struct SharedSecret *ss)
static void	mq_send_d (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
	Signature of functions implementing the sending functionality of a message queue. More...
static void	mq_destroy_d (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Signature of functions implementing the destruction of a message queue. More...
static void	mq_destroy_kx (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Signature of functions implementing the destruction of a message queue. More...
static void	mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Implementation function that cancels the currently sent message. More...
static void	mq_error (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
static int	mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
	Function called by the transport service to initialize a message queue given address information about another peer. More...
static int	get_receiver_delete_it (void *cls, const struct GNUNET_PeerIdentity *target, void *value)
	Iterator over all receivers to clean up. More...
static int	get_sender_delete_it (void *cls, const struct GNUNET_PeerIdentity *target, void *value)
	Iterator over all senders to clean up. More...
static void	do_shutdown (void *cls)
	Shutdown the UNIX communicator. More...
static void	enc_notify_cb (void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
	Function called when the transport service has received a backchannel message for this communicator (!) via a different return path. More...
static void	nat_address_cb (void *cls, void **app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen)
	Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of 'valid' addresses changes. More...
static void	ifc_broadcast (void *cls)
	Broadcast our presence on one of our interfaces. More...
static int	iface_proc (void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
	Callback function invoked for each interface found. More...
static void	do_broadcast (void *cls)
	Scan interfaces to broadcast our presence on the LAN. More...
static void	try_connection_reversal (void *cls, const struct sockaddr *addr, socklen_t addrlen)
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Setup communicator and launch network interactions. More...
int	main (int argc, char *const *argv)
	The main function for the UNIX communicator. More...

Variables
static struct GNUNET_TIME_Relative	rekey_interval
	The rekey interval. More...
static unsigned long long	rekey_max_bytes
	How often we do rekey based on number of bytes transmitted. More...
struct SharedSecret *	ss_finished
	Shared secret we finished the last kce working queue for. More...
static struct GNUNET_CONTAINER_MultiShortmap *	key_cache
	Cache of pre-generated key IDs. More...
static struct GNUNET_SCHEDULER_Task *	read_task
	ID of read task. More...
static struct GNUNET_SCHEDULER_Task *	timeout_task
	ID of timeout task. More...
static struct GNUNET_SCHEDULER_Task *	broadcast_task
	ID of master broadcast task. More...
static struct GNUNET_STATISTICS_Handle *	stats
	For logging statistics. More...
static struct GNUNET_TRANSPORT_CommunicatorHandle *	ch
	Our environment. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	receivers
	Receivers (map from peer identity to struct ReceiverAddress) More...
static struct GNUNET_CONTAINER_MultiPeerMap *	senders
	Senders (map from peer identity to struct SenderAddress) More...
static struct GNUNET_CONTAINER_Heap *	senders_heap
	Expiration heap for senders (contains struct SenderAddress) More...
static struct GNUNET_CONTAINER_Heap *	receivers_heap
	Expiration heap for receivers (contains struct ReceiverAddress) More...
static struct BroadcastInterface *	bi_head
	Broadcast interface tasks. More...
static struct BroadcastInterface *	bi_tail
	Broadcast interface tasks. More...
static struct GNUNET_NETWORK_Handle *	udp_sock
	Our socket. More...
static int	have_v6_socket
	GNUNET_YES if udp_sock supports IPv6. More...
static struct GNUNET_PeerIdentity	my_identity
	Our public key. More...
static struct GNUNET_CRYPTO_EddsaPrivateKey *	my_private_key
	Our private key. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration. More...
static struct GNUNET_TRANSPORT_ApplicationHandle *	ah
	Our handle to report addresses for validation to TRANSPORT. More...
static struct GNUNET_NT_InterfaceScanner *	is
	Network scanner to determine network types. More...
static struct GNUNET_NAT_Handle *	nat
	Connection to NAT service. More...
static uint16_t	my_port
	Port number to which we are actually bound. More...

Detailed Description

Transport plugin using UDP.

Author

Christian Grothoff

TODO:

• consider imposing transmission limits in the absence of ACKs; or: maybe this should be done at TNG service level? (at least the receiver might want to enforce limits on KX/DH operations per sender in here) (#5552)
• overall, we should look more into flow control support (either in backchannel, or general solution in TNG service)
• handle addresses discovered from broadcasts (#5551) (think: what was the story again on address validation? where is the API for that!?!)
• support DNS names in BINDTO option (#5528)
• support NAT connection reversal method (#5529)
• support other UDP-specific NAT traversal methods (#)

Definition in file gnunet-communicator-udp.c.

Macro Definition Documentation

DEFAULT_REKEY_TIME_INTERVAL

#define DEFAULT_REKEY_TIME_INTERVAL   GNUNET_TIME_UNIT_DAYS

How often do we rekey based on time (at least)

Definition at line 54 of file gnunet-communicator-udp.c.

PROTO_QUEUE_TIMEOUT

#define PROTO_QUEUE_TIMEOUT   GNUNET_TIME_UNIT_MINUTES

How long do we wait until we must have received the initial KX?

Definition at line 59 of file gnunet-communicator-udp.c.

BROADCAST_FREQUENCY

#define BROADCAST_FREQUENCY   GNUNET_TIME_UNIT_MINUTES

How often do we broadcast our presence on the LAN?

Definition at line 64 of file gnunet-communicator-udp.c.

INTERFACE_SCAN_FREQUENCY

#define INTERFACE_SCAN_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

How often do we scan for changes to our network interfaces?

Definition at line 69 of file gnunet-communicator-udp.c.

ADDRESS_VALIDITY_PERIOD

#define ADDRESS_VALIDITY_PERIOD   GNUNET_TIME_UNIT_HOURS

How long do we believe our addresses to remain up (before the other peer should revalidate).

Definition at line 76 of file gnunet-communicator-udp.c.

WORKING_QUEUE_INTERVALL

#define WORKING_QUEUE_INTERVALL    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1)

Definition at line 78 of file gnunet-communicator-udp.c.

AES_KEY_SIZE

#define AES_KEY_SIZE   (256 / 8)

AES key size.

Definition at line 84 of file gnunet-communicator-udp.c.

AES_IV_SIZE

#define AES_IV_SIZE   (96 / 8)

AES (GCM) IV size.

Definition at line 89 of file gnunet-communicator-udp.c.

GCM_TAG_SIZE

#define GCM_TAG_SIZE   (128 / 8)

Size of the GCM tag.

Definition at line 94 of file gnunet-communicator-udp.c.

GENERATE_AT_ONCE

#define GENERATE_AT_ONCE   2

Definition at line 96 of file gnunet-communicator-udp.c.

KCN_THRESHOLD

#define KCN_THRESHOLD   92

If we fall below this number of available KCNs, we generate additional ACKs until we reach KCN_TARGET.

Should be large enough that we don't generate ACKs all the time and still have enough time for the ACK to arrive before the sender runs out. So really this should ideally be based on the RTT.

Definition at line 107 of file gnunet-communicator-udp.c.

KCN_TARGET

#define KCN_TARGET   128

How many KCNs do we keep around after we hit the KCN_THRESHOLD? Should be larger than KCN_THRESHOLD so we do not generate just one ACK at the time.

Definition at line 115 of file gnunet-communicator-udp.c.

MAX_SQN_DELTA

#define MAX_SQN_DELTA   160

What is the maximum delta between KCN sequence numbers that we allow.

Used to expire 'ancient' KCNs that likely were dropped by the network. Must be larger than KCN_TARGET (otherwise we generate new KCNs all the time), but not too large (otherwise packet loss may cause sender to fall back to KX needlessly when sender runs out of ACK'ed KCNs due to losses).

Definition at line 126 of file gnunet-communicator-udp.c.

MAX_SECRETS

#define MAX_SECRETS   128000

How many shared master secrets do we keep around at most per sender? Should be large enough so that we generally have a chance of sending an ACK before the sender already rotated out the master secret.

Generally values around KCN_TARGET make sense. Might make sense to adapt to RTT if we had a good measurement...

Definition at line 137 of file gnunet-communicator-udp.c.

DEFAULT_REKEY_MAX_BYTES

#define DEFAULT_REKEY_MAX_BYTES   (1024LLU * 1024 * 1024 * 4LLU)

Default value for how often we do rekey based on number of bytes transmitted? (additionally randomized).

Definition at line 143 of file gnunet-communicator-udp.c.

COMMUNICATOR_ADDRESS_PREFIX

#define COMMUNICATOR_ADDRESS_PREFIX   "udp"

Address prefix used by the communicator.

Definition at line 149 of file gnunet-communicator-udp.c.

COMMUNICATOR_CONFIG_SECTION

#define COMMUNICATOR_CONFIG_SECTION   "communicator-udp"

Configuration section used by the communicator.

Definition at line 154 of file gnunet-communicator-udp.c.

Function Documentation

bi_destroy()

static void bi_destroy ( struct BroadcastInterface *  bi )

static

An interface went away, stop broadcasting on it.

Parameters

bi	entity to close down

Definition at line 904 of file gnunet-communicator-udp.c.

{
  if (AF_INET6 == bi->sa->sa_family)
  {
    /* Leave the multicast group */
    if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
                                                       IPPROTO_IPV6,
                                                       IPV6_LEAVE_GROUP,
                                                       &bi->mcreq,
                                                       sizeof(bi->mcreq)))
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
    }
  }
  GNUNET_CONTAINER_DLL_remove (bi_head, bi_tail, bi);
  GNUNET_SCHEDULER_cancel (bi->broadcast_task);
  GNUNET_free (bi->sa);
  GNUNET_free (bi->ba);
  GNUNET_free (bi);
}

References BroadcastInterface::ba, bi_head, bi_tail, BroadcastInterface::broadcast_task, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror, GNUNET_NETWORK_socket_setsockopt(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), BroadcastInterface::mcreq, BroadcastInterface::sa, and udp_sock.

Referenced by do_broadcast(), and do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

receiver_destroy()

static void receiver_destroy ( struct ReceiverAddress *  receiver )

static

Destroys a receiving state due to timeout or shutdown.

Parameters

receiver

entity to close down

Definition at line 932 of file gnunet-communicator-udp.c.

{
 
  receiver->receiver_destroy_called = GNUNET_YES;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Disconnecting receiver for peer `%s'\n",
              GNUNET_i2s (&receiver->target));
  /*if (NULL != (mq = receiver->kx_mq))
  {
    receiver->kx_mq = NULL;
    GNUNET_MQ_destroy (mq);
    }*/
  if (NULL != receiver->kx_qh)
  {
    GNUNET_TRANSPORT_communicator_mq_del (receiver->kx_qh);
    receiver->kx_qh = NULL;
    receiver->kx_mq = NULL;
  }
  /*if (NULL != (mq = receiver->d_mq))
  {
    receiver->d_mq = NULL;
    GNUNET_MQ_destroy (mq);
    }*/
  if (NULL != receiver->d_qh)
  {
    GNUNET_TRANSPORT_communicator_mq_del (receiver->d_qh);
    receiver->d_qh = NULL;
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (receivers,
                                                       &receiver->target,
                                                       receiver));
  GNUNET_assert (receiver == GNUNET_CONTAINER_heap_remove_node (receiver->hn));
  GNUNET_STATISTICS_set (stats,
                         "# receivers active",
                         GNUNET_CONTAINER_multipeermap_size (receivers),
                         GNUNET_NO);
  GNUNET_free (receiver->address);
  GNUNET_free (receiver->foreign_addr);
  GNUNET_free (receiver);
}

References GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_TRANSPORT_communicator_mq_del(), GNUNET_YES, receiver(), receivers, and stats.

Referenced by check_timeouts(), get_receiver_delete_it(), mq_destroy_d(), mq_destroy_kx(), mq_error(), mq_send_d(), and mq_send_kx().

Here is the call graph for this function:

Here is the caller graph for this function:

kce_destroy()

static void kce_destroy ( struct KeyCacheEntry *  kce )

static

Free memory used by key cache entry.

Parameters

kce	the key cache entry

Definition at line 982 of file gnunet-communicator-udp.c.

{
  struct SharedSecret *ss = kce->ss;
 
  ss->active_kce_count--;
  ss->sender->acks_available--;
  GNUNET_CONTAINER_DLL_remove (ss->kce_head, ss->kce_tail, kce);
  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (key_cache,
                                                                      &kce->kid,
                                                                      kce));
  GNUNET_free (kce);
}

References SenderAddress::acks_available, SharedSecret::active_kce_count, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multishortmap_remove(), GNUNET_free, GNUNET_YES, SharedSecret::kce_head, SharedSecret::kce_tail, key_cache, KeyCacheEntry::kid, SharedSecret::sender, and KeyCacheEntry::ss.

Referenced by consider_ss_ack(), decrypt_box(), decrypt_rekey(), and secret_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

get_kid()

static void get_kid ( const struct GNUNET_HashCode *  msec, uint32_t  serial, struct GNUNET_ShortHashCode *  kid  )

static

Compute kid.

Parameters

	msec	master secret for HMAC calculation
	serial	number for the smac calculation
[out]	kid	where to write the key ID

Definition at line 1004 of file gnunet-communicator-udp.c.

{
  uint32_t sid = htonl (serial);
 
  GNUNET_CRYPTO_hkdf (kid,
                      sizeof(*kid),
                      GCRY_MD_SHA512,
                      GCRY_MD_SHA256,
                      &sid,
                      sizeof(sid),
                      msec,
                      sizeof(*msec),
                      "UDP-KID",
                      strlen ("UDP-KID"),
                      NULL,
                      0);
}

References GNUNET_CRYPTO_hkdf().

Referenced by kce_generate(), mq_send_d(), and send_UDPRekey().

Here is the call graph for this function:

Here is the caller graph for this function:

kce_generate()

static void kce_generate ( struct SharedSecret *  ss, uint32_t  seq  )

static

Setup key cache entry for sequence number seq and shared secret ss.

Parameters

ss	shared secret
seq	sequence number for the key cache entry

Definition at line 1032 of file gnunet-communicator-udp.c.

{
  struct KeyCacheEntry *kce;
 
  GNUNET_assert (0 < seq);
  kce = GNUNET_new (struct KeyCacheEntry);
  kce->ss = ss;
  kce->sequence_number = seq;
  get_kid (&ss->master, seq, &kce->kid);
  GNUNET_CONTAINER_DLL_insert (ss->kce_head, ss->kce_tail, kce);
  ss->active_kce_count++;
  ss->sender->acks_available++;
  (void) GNUNET_CONTAINER_multishortmap_put (
    key_cache,
    &kce->kid,
    kce,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  GNUNET_STATISTICS_set (stats,
                         "# KIDs active",
                         GNUNET_CONTAINER_multishortmap_size (key_cache),
                         GNUNET_NO);
}

References SenderAddress::acks_available, SharedSecret::active_kce_count, get_kid(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_put(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_set(), SharedSecret::kce_head, SharedSecret::kce_tail, key_cache, KeyCacheEntry::kid, SharedSecret::master, SharedSecret::sender, KeyCacheEntry::sequence_number, KeyCacheEntry::ss, and stats.

Referenced by consider_ss_ack(), kce_generate_cb(), and kce_generate_rekey_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

secret_destroy()

static int secret_destroy ( struct SharedSecret *  ss, int  withoutKce  )

static

Destroy ss and associated key cache entries.

Parameters

ss	shared secret to destroy
withoutKce	If GNUNET_YES shared secrets with kce will not be destroyed.

Definition at line 1063 of file gnunet-communicator-udp.c.

{
  struct SenderAddress *sender;
  struct ReceiverAddress *receiver;
  struct KeyCacheEntry *kce;
 
  if (withoutKce && (ss->sequence_allowed > 0))
    return GNUNET_NO;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "secret %s destroy %u %u\n",
              GNUNET_h2s (&ss->master),
              withoutKce,
              ss->sequence_allowed);
  if (NULL != (sender = ss->sender))
  {
    GNUNET_CONTAINER_DLL_remove (sender->ss_head, sender->ss_tail, ss);
    sender->num_secrets--;
  }
  if (NULL != (receiver = ss->receiver))
  {
    GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
    receiver->num_secrets--;
    // Uncomment this for alternativ 1 of backchannel functionality
    receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "%u receiver->acks_available 3\n",
                receiver->acks_available);
    // Until here for alternativ 1
  }
  while (NULL != (kce = ss->kce_head))
    kce_destroy (kce);
  GNUNET_STATISTICS_update (stats, "# Secrets active", -1, GNUNET_NO);
  GNUNET_STATISTICS_set (stats,
                         "# KIDs active",
                         GNUNET_CONTAINER_multishortmap_size (key_cache),
                         GNUNET_NO);
  GNUNET_free (ss);
  return GNUNET_YES;
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_YES, kce_destroy(), SharedSecret::kce_head, key_cache, SharedSecret::master, SenderAddress::num_secrets, SharedSecret::receiver, receiver(), SharedSecret::sender, SharedSecret::sequence_allowed, SharedSecret::sequence_used, KeyCacheEntry::ss, SenderAddress::ss_head, SenderAddress::ss_tail, and stats.

Referenced by destroy_all_secrets().

Here is the call graph for this function:

Here is the caller graph for this function:

sender_destroy()

static void sender_destroy ( struct SenderAddress *  sender )

static

Functions with this signature are called whenever we need to close a sender's state due to timeout.

Parameters

sender

entity to close down

Definition at line 1112 of file gnunet-communicator-udp.c.

{
  sender->sender_destroy_called = GNUNET_YES;
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (senders, &sender->target, sender));
  GNUNET_assert (sender == GNUNET_CONTAINER_heap_remove_node (sender->hn));
  GNUNET_STATISTICS_set (stats,
                         "# senders active",
                         GNUNET_CONTAINER_multipeermap_size (senders),
                         GNUNET_NO);
  GNUNET_free (sender->address);
  GNUNET_free (sender);
}

References SenderAddress::address, GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_YES, SenderAddress::hn, SenderAddress::sender_destroy_called, senders, stats, and SenderAddress::target.

Referenced by check_timeouts(), and get_sender_delete_it().

Here is the call graph for this function:

Here is the caller graph for this function:

get_iv_key()

static void get_iv_key ( const struct GNUNET_HashCode *  msec, uint32_t  serial, char  key[(256/8)], char  iv[(96/8)]  )

static

Compute key and iv.

Parameters

	msec	master secret for calculation
	serial	number for the smac calculation
[out]	key	where to write the decryption key
[out]	iv	where to write the IV

Definition at line 1137 of file gnunet-communicator-udp.c.

{
  uint32_t sid = htonl (serial);
  char res[AES_KEY_SIZE + AES_IV_SIZE];
 
  GNUNET_CRYPTO_hkdf (res,
                      sizeof(res),
                      GCRY_MD_SHA512,
                      GCRY_MD_SHA256,
                      &sid,
                      sizeof(sid),
                      msec,
                      sizeof(*msec),
                      "UDP-IV-KEY",
                      strlen ("UDP-IV-KEY"),
                      NULL,
                      0);
  memcpy (key, res, AES_KEY_SIZE);
  memcpy (iv, &res[AES_KEY_SIZE], AES_IV_SIZE);
}

References AES_IV_SIZE, AES_KEY_SIZE, GNUNET_CRYPTO_hkdf(), key, and res.

Referenced by setup_cipher().

Here is the call graph for this function:

Here is the caller graph for this function:

reschedule_sender_timeout()

static void reschedule_sender_timeout ( struct SenderAddress *  sender )

static

Increment sender timeout due to activity.

Parameters

sender

address for which the timeout should be rescheduled

Definition at line 1168 of file gnunet-communicator-udp.c.

{
  sender->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  GNUNET_CONTAINER_heap_update_cost (sender->hn, sender->timeout.abs_value_us);
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_update_cost(), GNUNET_TIME_relative_to_absolute(), SenderAddress::hn, and SenderAddress::timeout.

Referenced by setup_sender().

Here is the call graph for this function:

Here is the caller graph for this function:

reschedule_receiver_timeout()

static void reschedule_receiver_timeout ( struct ReceiverAddress *  receiver )

static

Increment receiver timeout due to activity.

Parameters

receiver

address for which the timeout should be rescheduled

Definition at line 1182 of file gnunet-communicator-udp.c.

{
  receiver->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  GNUNET_CONTAINER_heap_update_cost (receiver->hn,
                                     receiver->timeout.abs_value_us);
}

References GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_update_cost(), GNUNET_TIME_relative_to_absolute(), and receiver().

Referenced by mq_send_d(), and mq_send_kx().

Here is the call graph for this function:

Here is the caller graph for this function:

check_timeouts()

static void check_timeouts ( void *  cls )

static

Task run to check #receiver_heap and #sender_heap for timeouts.

Parameters

cls	unused, NULL

Definition at line 1197 of file gnunet-communicator-udp.c.

{
  struct GNUNET_TIME_Relative st;
  struct GNUNET_TIME_Relative rt;
  struct GNUNET_TIME_Relative delay;
  struct ReceiverAddress *receiver;
  struct SenderAddress *sender;
 
  (void) cls;
  timeout_task = NULL;
  rt = GNUNET_TIME_UNIT_FOREVER_REL;
  while (NULL != (receiver = GNUNET_CONTAINER_heap_peek (receivers_heap)))
  {
    /* if (GNUNET_YES != receiver->receiver_destroy_called) */
    /* { */
    rt = GNUNET_TIME_absolute_get_remaining (receiver->timeout);
    if (0 != rt.rel_value_us)
      break;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Receiver timed out\n");
    receiver_destroy (receiver);
    // }
  }
  st = GNUNET_TIME_UNIT_FOREVER_REL;
  while (NULL != (sender = GNUNET_CONTAINER_heap_peek (senders_heap)))
  {
    if (GNUNET_YES != sender->sender_destroy_called)
    {
      st = GNUNET_TIME_absolute_get_remaining (sender->timeout);
      if (0 != st.rel_value_us)
        break;
      sender_destroy (sender);
    }
  }
  delay = GNUNET_TIME_relative_min (rt, st);
  if (delay.rel_value_us < GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
    timeout_task = GNUNET_SCHEDULER_add_delayed (delay, &check_timeouts, NULL);
}

References delay, GNUNET_CONTAINER_heap_peek(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_min(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, receiver(), receiver_destroy(), receivers_heap, GNUNET_TIME_Relative::rel_value_us, sender_destroy(), SenderAddress::sender_destroy_called, senders_heap, st, SenderAddress::timeout, and timeout_task.

Referenced by mq_init(), and setup_sender().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_cmac()

static void calculate_cmac ( struct SharedSecret *  ss )

static

Calculate cmac from master in ss.

Parameters

[in,out]

ss

data structure to complete

Definition at line 1243 of file gnunet-communicator-udp.c.

{
  GNUNET_CRYPTO_hkdf (&ss->cmac,
                      sizeof(ss->cmac),
                      GCRY_MD_SHA512,
                      GCRY_MD_SHA256,
                      "CMAC",
                      strlen ("CMAC"),
                      &ss->master,
                      sizeof(ss->master),
                      "UDP-CMAC",
                      strlen ("UDP-CMAC"),
                      NULL,
                      0);
}

References SharedSecret::cmac, GNUNET_CRYPTO_hkdf(), and SharedSecret::master.

Referenced by decrypt_rekey(), setup_shared_secret_enc(), and sock_read().

Here is the call graph for this function:

Here is the caller graph for this function:

pass_plaintext_to_core()

static void pass_plaintext_to_core ( struct SenderAddress *  sender, const void *  plaintext, size_t  plaintext_len  )

static

We received plaintext_len bytes of plaintext from a sender.

Pass it on to CORE.

Parameters

queue	the queue that received the plaintext
plaintext	the plaintext that was received
plaintext_len	number of bytes of plaintext received

Definition at line 1269 of file gnunet-communicator-udp.c.

{
  const struct GNUNET_MessageHeader *hdr = plaintext;
  const char *pos = plaintext;
 
  while (ntohs (hdr->size) <= plaintext_len)
  {
    GNUNET_STATISTICS_update (stats,
                              "# bytes given to core",
                              ntohs (hdr->size),
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Giving %u bytes to TNG\n", ntohs (hdr->size));
    GNUNET_assert (GNUNET_SYSERR !=
                   GNUNET_TRANSPORT_communicator_receive (ch,
                                                          &sender->target,
                                                          hdr,
                                                          ADDRESS_VALIDITY_PERIOD,
                                                          NULL /* no flow control possible */
                                                          ,
                                                          NULL));
    /* move on to next message, if any */
    plaintext_len -= ntohs (hdr->size);
    if (plaintext_len < sizeof(*hdr))
      break;
    pos += ntohs (hdr->size);
    hdr = (const struct GNUNET_MessageHeader *) pos;
    // TODO for now..., we do not actually sen >1msg or have a way of telling
    // if we are done
    break;
  }
  GNUNET_STATISTICS_update (stats,
                            "# bytes padding discarded",
                            plaintext_len,
                            GNUNET_NO);
}

References ADDRESS_VALIDITY_PERIOD, ch, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TRANSPORT_communicator_receive(), GNUNET_MessageHeader::size, stats, and SenderAddress::target.

Referenced by try_handle_plaintext().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_cipher()

static void setup_cipher ( const struct GNUNET_HashCode *  msec, uint32_t  serial, gcry_cipher_hd_t *  cipher  )

static

Setup cipher based on shared secret msec and serial number serial.

Parameters

msec	master shared secret
serial	serial number of cipher to set up
cipher[out]	cipher to initialize

Definition at line 1318 of file gnunet-communicator-udp.c.

{
  char key[AES_KEY_SIZE];
  char iv[AES_IV_SIZE];
  int rc;
 
  GNUNET_assert (0 ==
                 gcry_cipher_open (cipher,
                                   GCRY_CIPHER_AES256 /* low level: go for speed */,
                                   GCRY_CIPHER_MODE_GCM,
                                   0 /* flags */));
  get_iv_key (msec, serial, key, iv);
  rc = gcry_cipher_setkey (*cipher, key, sizeof(key));
  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
  rc = gcry_cipher_setiv (*cipher, iv, sizeof(iv));
  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
}

References AES_IV_SIZE, AES_KEY_SIZE, get_iv_key(), GNUNET_assert, and key.

Referenced by mq_send_d(), mq_send_kx(), send_UDPRekey(), and try_decrypt().

Here is the call graph for this function:

Here is the caller graph for this function:

try_decrypt()

static int try_decrypt ( const struct SharedSecret *  ss, const char  tag[(128/8)], uint32_t  serial, const char *  in_buf, size_t  in_buf_size, char *  out_buf  )

static

Try to decrypt buf using shared secret ss and key/iv derived using serial.

Parameters

ss	shared secret
tag	GCM authentication tag
serial	serial number to use
in_buf	input buffer to decrypt
in_buf_size	number of bytes in in_buf and available in out_buf
out_buf	where to write the result

Returns

GNUNET_OK on success

Definition at line 1352 of file gnunet-communicator-udp.c.

{
  gcry_cipher_hd_t cipher;
 
  setup_cipher (&ss->master, serial, &cipher);
  GNUNET_assert (
    0 ==
    gcry_cipher_decrypt (cipher, out_buf, in_buf_size, in_buf, in_buf_size));
  if (0 != gcry_cipher_checktag (cipher, tag, GCM_TAG_SIZE))
  {
    gcry_cipher_close (cipher);
    GNUNET_STATISTICS_update (stats,
                              "# AEAD authentication failures",
                              1,
                              GNUNET_NO);
    return GNUNET_SYSERR;
  }
  gcry_cipher_close (cipher);
  return GNUNET_OK;
}

References GCM_TAG_SIZE, GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, SharedSecret::master, setup_cipher(), and stats.

Referenced by decrypt_box(), decrypt_rekey(), and sock_read().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_shared_secret_dec()

static struct SharedSecret* setup_shared_secret_dec ( const struct GNUNET_CRYPTO_EcdhePublicKey *  ephemeral )

static

Setup shared secret for decryption.

Parameters

ephemeral

ephemeral key we received from the other peer

Returns

new shared secret

Definition at line 1386 of file gnunet-communicator-udp.c.

{
  struct SharedSecret *ss;
 
  ss = GNUNET_new (struct SharedSecret);
  GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &ss->master);
  return ss;
}

References GNUNET_CRYPTO_eddsa_ecdh(), GNUNET_new, SharedSecret::master, and my_private_key.

Referenced by sock_read().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_shared_secret_enc()

static struct SharedSecret* setup_shared_secret_enc ( const struct GNUNET_CRYPTO_EcdhePrivateKey *  ephemeral, struct ReceiverAddress *  receiver, int  add_to_receiver  )

static

Setup shared secret for encryption.

Parameters

	ephemeral	ephemeral key we are sending to the other peer
[in,out]	receiver	queue to initialize encryption key for

Returns

new shared secret

Definition at line 1404 of file gnunet-communicator-udp.c.

{
  struct SharedSecret *ss;
 
  ss = GNUNET_new (struct SharedSecret);
  GNUNET_CRYPTO_ecdh_eddsa (ephemeral,
                            &receiver->target.public_key,
                            &ss->master);
  calculate_cmac (ss);
  ss->receiver = receiver;
  GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
  receiver->num_secrets++;
  GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
  return ss;
}

References calculate_cmac(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_ecdh_eddsa(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), SharedSecret::master, SharedSecret::receiver, receiver(), and stats.

Referenced by mq_send_kx(), and send_UDPRekey().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_receiver_mq()

static void setup_receiver_mq ( struct ReceiverAddress *  receiver )

static

Setup the MQ for the receiver.

If a queue exists, the existing one is destroyed. Then the MTU is recalculated and a fresh queue is initialized.

Parameters

receiver

receiver to setup MQ for

Definition at line 3147 of file gnunet-communicator-udp.c.

{
  size_t base_mtu;
 
  /*if (NULL != receiver->kx_qh)
    {
    GNUNET_TRANSPORT_communicator_mq_del (receiver->kx_qh);
    receiver->kx_qh = NULL;
    }
    if (NULL != receiver->d_qh)
    {
    GNUNET_TRANSPORT_communicator_mq_del (receiver->d_qh);
    receiver->d_qh = NULL;
    }*/
  // GNUNET_assert (NULL == receiver->mq);
  switch (receiver->address->sa_family)
  {
  case AF_INET:
    base_mtu = 1480     /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */
               - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */
               - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
    break;
 
  case AF_INET6:
    base_mtu = 1280     /* Minimum MTU required by IPv6 */
               - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */
               - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
    break;
 
  default:
    GNUNET_assert (0);
    break;
  }
  /* MTU based on full KX messages */
  receiver->kx_mtu = base_mtu - sizeof(struct InitialKX)   /* 48 */
                     - sizeof(struct UDPConfirmation); /* 104 */
  /* MTU based on BOXed messages */
  receiver->d_mtu = base_mtu - sizeof(struct UDPBox);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Setting up MQs and QHs\n");
  /* => Effective MTU for CORE will range from 1080 (IPv6 + KX) to
     1404 (IPv4 + Box) bytes, depending on circumstances... */
  if (NULL == receiver->kx_mq)
    receiver->kx_mq = GNUNET_MQ_queue_for_callbacks (&mq_send_kx,
                                                     &mq_destroy_kx,
                                                     &mq_cancel,
                                                     receiver,
                                                     NULL,
                                                     &mq_error,
                                                     receiver);
  if (NULL == receiver->d_mq)
    receiver->d_mq = GNUNET_MQ_queue_for_callbacks (&mq_send_d,
                                                    &mq_destroy_d,
                                                    &mq_cancel,
                                                    receiver,
                                                    NULL,
                                                    &mq_error,
                                                    receiver);
 
  receiver->kx_qh =
    GNUNET_TRANSPORT_communicator_mq_add (ch,
                                          &receiver->target,
                                          receiver->foreign_addr,
                                          receiver->kx_mtu,
                                          GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED,
                                          0, /* Priority */
                                          receiver->nt,
                                          GNUNET_TRANSPORT_CS_OUTBOUND,
                                          receiver->kx_mq);
}

References ch, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_queue_for_callbacks(), GNUNET_TRANSPORT_communicator_mq_add(), GNUNET_TRANSPORT_CS_OUTBOUND, GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, mq_cancel(), mq_destroy_d(), mq_destroy_kx(), mq_error(), mq_send_d(), mq_send_kx(), and receiver().

Referenced by mq_init().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_all_secrets()

static void destroy_all_secrets ( struct SharedSecret *  ss, int  withoutKce  )

static

Destroying all secrets.

Depending on parameter we keep those secrets having a kce.

Parameters

ss	The secret we will not destroy.
withoutKce	If GNUNET_YES shared secrets with kce will not be destroyed.

Definition at line 1439 of file gnunet-communicator-udp.c.

{
  struct SenderAddress *sender;
  struct ReceiverAddress *receiver;
  struct SharedSecret *ss_to_destroy;
  struct SharedSecret *ss_start;
  struct SharedSecret *pos;
  int at_least_one_destroyed = GNUNET_NO;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting destroy all withoutKce: %u.\n",
              withoutKce);
 
  if (NULL != (sender = ss->sender))
  {
    ss_start = sender->ss_head;
  }
  else if (NULL != (receiver = ss->receiver))
  {
    ss_start = receiver->ss_head;
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Shared secret has no sender or receiver!\n");
    return;
  }
 
  pos = ss_start;
  while (NULL != pos)
  {
    ss_to_destroy = pos;
    pos = pos->next;
 
    if (ss != ss_to_destroy)
      at_least_one_destroyed = secret_destroy (ss_to_destroy, withoutKce);
  }
 
  if ((ss != ss_start) && ! at_least_one_destroyed)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Really destroying all.\n");
    destroy_all_secrets (ss_start, GNUNET_NO);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Finished destroy all.\n");
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, SharedSecret::next, SharedSecret::receiver, receiver(), secret_destroy(), SharedSecret::sender, and SenderAddress::ss_head.

Referenced by add_acks(), consider_ss_ack(), and mq_send_kx().

Here is the call graph for this function:

Here is the caller graph for this function:

add_acks()

static void add_acks ( struct SharedSecret *  ss, int  acks_to_add  )

static

Definition at line 1490 of file gnunet-communicator-udp.c.

{
 
  struct ReceiverAddress *receiver = ss->receiver;
 
  GNUNET_assert (NULL != ss);
  GNUNET_assert (NULL != receiver);
 
  if (NULL == receiver->d_qh)
  {
    receiver->d_qh =
      GNUNET_TRANSPORT_communicator_mq_add (ch,
                                            &receiver->target,
                                            receiver->foreign_addr,
                                            receiver->d_mtu,
                                            acks_to_add,
                                            1, /* Priority */
                                            receiver->nt,
                                            GNUNET_TRANSPORT_CS_OUTBOUND,
                                            receiver->d_mq);
  }
  else
  {
    GNUNET_TRANSPORT_communicator_mq_update (ch,
                                             receiver->d_qh,
                                             acks_to_add,
                                             1);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Tell transport we have %u more acks!\n",
              acks_to_add);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "%u kce for rekeying.\n",
              receiver->number_rekeying_kce);
 
  // Until here for alternativ 1
 
  /* move ss to head to avoid discarding it anytime soon! */
 
  GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
  GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
  destroy_all_secrets (ss, GNUNET_YES);
}

References ch, destroy_all_secrets(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_TRANSPORT_communicator_mq_add(), GNUNET_TRANSPORT_communicator_mq_update(), GNUNET_TRANSPORT_CS_OUTBOUND, GNUNET_YES, SharedSecret::receiver, and receiver().

Referenced by add_acks_rekey(), and handle_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_rekey_kces()

static uint32_t reset_rekey_kces ( struct ReceiverAddress *  receiver, uint32_t  acks_to_add  )

static

Definition at line 1537 of file gnunet-communicator-udp.c.

{
  int needed_for_rekeying;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "%u kce for rekeying and %u acks_to_add\n",
              receiver->number_rekeying_kce,
              acks_to_add);
 
  needed_for_rekeying = (3 - receiver->number_rekeying_kce);
  if (acks_to_add <= needed_for_rekeying)
  {
    receiver->number_rekeying_kce += acks_to_add;
    acks_to_add = 0;
  }
  else
  {
    acks_to_add -= (3 - receiver->number_rekeying_kce);
    receiver->number_rekeying_kce = 3;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "%u kce for rekeying and %u acks_to_add\n",
              receiver->number_rekeying_kce,
              acks_to_add);
  return acks_to_add;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and receiver().

Referenced by add_acks_rekey(), and handle_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

add_acks_rekey()

static void add_acks_rekey ( struct ReceiverAddress *  receiver )

static

Definition at line 1568 of file gnunet-communicator-udp.c.

{
  uint32_t acks_to_add = receiver->ss_rekey->sequence_allowed;
 
  if (receiver->number_rekeying_kce < 3)
    acks_to_add = reset_rekey_kces (receiver, acks_to_add);
  receiver->acks_available = receiver->ss_rekey->sequence_allowed;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "%u receiver->acks_available 4\n",
              receiver->acks_available);
  /* add_acks (receiver->ss_rekey, acks_to_add - 3); */
  if (0 != acks_to_add)
  {
    add_acks (receiver->ss_rekey, acks_to_add);
  }
  receiver->ss_rekey = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "# rekeying successful\n");
  GNUNET_STATISTICS_update (stats,
                            "# rekeying successful",
                            1,
                            GNUNET_NO);
}

References add_acks(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), receiver(), reset_rekey_kces(), and stats.

Referenced by handle_ack(), and mq_send_d().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_ack()

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

static

We received an ACK for pid.

Check if it is for the receiver in value and if so, handle it and return GNUNET_NO. Otherwise, return GNUNET_YES.

Parameters

cls	a const struct UDPAck
pid	peer the ACK is from
value	a struct ReceiverAddress

Returns

GNUNET_YES to continue to iterate

Definition at line 1604 of file gnunet-communicator-udp.c.

{
  const struct UDPAck *ack = cls;
  struct ReceiverAddress *receiver = value;
  uint32_t acks_to_add;
  uint32_t allowed;
  // int needed_for_rekeying;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "in handle ack with cmac %s\n",
              GNUNET_h2s (&ack->cmac));
 
  if (NULL != receiver->ss_rekey)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "We have rekey secret with cmac %s \n",
                GNUNET_h2s (&receiver->ss_rekey->cmac));
 
  if ((NULL != receiver->ss_rekey) && (0 == memcmp (&ack->cmac,
                                                    &receiver->ss_rekey->cmac,
                                                    sizeof(struct
                                                           GNUNET_HashCode))) )
  {
    allowed = ntohl (ack->sequence_max);
 
    if (allowed > receiver->ss_rekey->sequence_allowed)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "%u > %u (%u %u) for rekey secrect %s\n", allowed,
                  receiver->ss_rekey->sequence_allowed,
                  receiver->acks_available,
                  ack->acks_available,
                  GNUNET_h2s (&receiver->ss_rekey->master));
 
      receiver->ss_rekey->sequence_allowed = allowed;
 
      if (GNUNET_NO == receiver->rekeying)
        add_acks_rekey (receiver);
 
      return GNUNET_NO;
    }
  }
 
  (void) pid;
  for (struct SharedSecret *ss = receiver->ss_head; NULL != ss; ss = ss->next)
  {
    if (0 == memcmp (&ack->cmac, &ss->cmac, sizeof(struct GNUNET_HashCode)))
    {
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Found matching mac\n");
 
      allowed = ntohl (ack->sequence_max);
 
      if (allowed > ss->sequence_allowed)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "%u > %u (%u %u) for secrect %s\n", allowed,
                    ss->sequence_allowed,
                    receiver->acks_available,
                    ack->acks_available,
                    GNUNET_h2s (&ss->master));
        // Uncomment this for alternativ 1 of backchannel functionality
        acks_to_add = (allowed - ss->sequence_allowed);
        if ((GNUNET_NO == receiver->rekeying) &&
            (receiver->number_rekeying_kce < 3) )
          acks_to_add = reset_rekey_kces (receiver, acks_to_add);
        /* if ((GNUNET_NO == receiver->rekeying) && */
        /*     (receiver->number_rekeying_kce < */
        /*      3) ) */
        /* { */
        /*   needed_for_rekeying = (3 - receiver->number_rekeying_kce); */
        /*   if (acks_to_add <= needed_for_rekeying) */
        /*   { */
        /*     receiver->number_rekeying_kce += acks_to_add; */
        /*     acks_to_add = 0; */
        /*   } */
        /*   else */
        /*   { */
        /*     acks_to_add -= (3 - receiver->number_rekeying_kce); */
        /*     receiver->number_rekeying_kce = 3; */
        /*   } */
        /* } */
        /* GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, */
        /*             "%u kce for rekeying\n", */
        /*             receiver->number_rekeying_kce); */
 
        if ((0 != acks_to_add) && (GNUNET_NO == receiver->rekeying))
        {
          receiver->acks_available += (allowed - ss->sequence_allowed);
          ss->sequence_allowed = allowed;
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "%u receiver->acks_available 5\n",
                      receiver->acks_available);
          add_acks (ss, acks_to_add);
        }
      }
      return GNUNET_NO;
    }
  }
  return GNUNET_YES;
}

References UDPAck::acks_available, add_acks(), add_acks_rekey(), UDPAck::cmac, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_YES, pid, receiver(), reset_rekey_kces(), UDPAck::sequence_max, and value.

Referenced by enc_notify_cb(), and try_handle_plaintext().

Here is the call graph for this function:

Here is the caller graph for this function:

try_handle_plaintext()

static void try_handle_plaintext ( struct SenderAddress *  sender, const void *  buf, size_t  buf_size  )

static

Test if we have received a valid message in plaintext.

If so, handle it.

Parameters

sender	peer to process inbound plaintext for
buf	buffer we received
buf_size	number of bytes in buf

Definition at line 1716 of file gnunet-communicator-udp.c.

{
  const struct GNUNET_MessageHeader *hdr =
    (const struct GNUNET_MessageHeader *) buf;
  const struct UDPAck *ack = (const struct UDPAck *) buf;
  uint16_t type;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "try_handle_plaintext of size %lu (%u %lu) and type %u\n",
              buf_size,
              ntohs (hdr->size),
              sizeof(*hdr),
              ntohs (hdr->type));
  if (sizeof(*hdr) > buf_size)
    return; /* not even a header */
  if (ntohs (hdr->size) > buf_size)
    return; /* not even a header */
  type = ntohs (hdr->type);
  switch (type)
  {
  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK:
    /* lookup master secret by 'cmac', then update sequence_max */
    GNUNET_CONTAINER_multipeermap_get_multiple (receivers,
                                                &sender->target,
                                                &handle_ack,
                                                (void *) ack);
    /* There could be more messages after the ACK, handle those as well */
    buf += ntohs (hdr->size);
    buf_size -= ntohs (hdr->size);
    pass_plaintext_to_core (sender, buf, buf_size);
    break;
 
  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD:
    /* skip padding */
    break;
 
  default:
    pass_plaintext_to_core (sender, buf, buf_size);
  }
}

References buf, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD, handle_ack(), pass_plaintext_to_core(), receivers, GNUNET_MessageHeader::size, SenderAddress::target, GNUNET_MessageHeader::type, and type.

Referenced by decrypt_box(), and sock_read().

Here is the call graph for this function:

Here is the caller graph for this function:

kce_generate_cb()

static void kce_generate_cb ( void *  cls )

static

Definition at line 1761 of file gnunet-communicator-udp.c.

{
  struct SharedSecret *ss = cls;
 
  ss->sender->kce_task = NULL;
 
  if (((GNUNET_NO == ss->sender->rekeying) && (ss->sender->acks_available <
                                               KCN_TARGET) ) ||
      ((ss->sender->ss_rekey == ss) && (GNUNET_YES == ss->sender->rekeying) &&
       (ss->sender->acks_available < KCN_TARGET)))
  {
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Precomputing keys for master %s\n",
                GNUNET_h2s (&(ss->master)));
 
    for (int i = 0; i < GENERATE_AT_ONCE; i++)
      kce_generate (ss, ++ss->sequence_allowed);
 
    if (KCN_TARGET > ss->sender->acks_available)
    {
      ss->sender->kce_task = GNUNET_SCHEDULER_add_delayed (
        WORKING_QUEUE_INTERVALL,
        kce_generate_cb,
        ss);
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "We have enough keys.\n");
      ss_finished = ss;
      ss->sender->kce_task_finished = GNUNET_YES;
    }
  }
 
 
 
}

References SenderAddress::acks_available, GENERATE_AT_ONCE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, kce_generate(), SenderAddress::kce_task, SenderAddress::kce_task_finished, KCN_TARGET, SharedSecret::master, SenderAddress::rekeying, SharedSecret::sender, SharedSecret::sequence_allowed, ss_finished, SenderAddress::ss_rekey, and WORKING_QUEUE_INTERVALL.

Referenced by consider_ss_ack(), and kce_generate_rekey_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

kce_generate_rekey_cb()

static void kce_generate_rekey_cb ( void *  cls )

static

Definition at line 1802 of file gnunet-communicator-udp.c.

{
  struct SharedSecret *ss = cls;
 
  ss->sender->kce_task_rekey = NULL;
 
  if (NULL == ss->sender->kce_task)
  {
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Precomputing keys for rekey master %s\n",
                GNUNET_h2s (&(ss->master)));
 
    for (int i = 0; i < GENERATE_AT_ONCE; i++)
      kce_generate (ss, ++ss->sequence_allowed);
 
    ss->sender->kce_task = GNUNET_SCHEDULER_add_delayed (
      WORKING_QUEUE_INTERVALL,
      kce_generate_cb,
      ss);
    ss->sender->kce_task_rekey = NULL;
  }
  else
  {
    ss->sender->kce_task_rekey = GNUNET_SCHEDULER_add_delayed (
      WORKING_QUEUE_INTERVALL,
      kce_generate_rekey_cb,
      ss);
  }
}

References GENERATE_AT_ONCE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_SCHEDULER_add_delayed(), kce_generate(), kce_generate_cb(), SenderAddress::kce_task, SenderAddress::kce_task_rekey, SharedSecret::master, SharedSecret::sender, SharedSecret::sequence_allowed, and WORKING_QUEUE_INTERVALL.

Referenced by consider_ss_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

consider_ss_ack()

static void consider_ss_ack ( struct SharedSecret *  ss, int  initial  )

static

We established a shared secret with a sender.

We should try to send the sender an struct UDPAck at the next opportunity to allow the sender to use ss longer (assuming we did not yet already recently).

Parameters

ss	shared secret to generate ACKs for
initial	The SharedSecret came with initial KX.

Definition at line 1844 of file gnunet-communicator-udp.c.

{
  struct GNUNET_SCHEDULER_Task *kce_task_rekey;
  struct GNUNET_SCHEDULER_Task *kce_task;
  int kce_task_finished;
 
  kce_task_rekey = ss->sender->kce_task_rekey;
  kce_task_finished = ss->sender->kce_task_finished;
  kce_task = ss->sender->kce_task;
 
  GNUNET_assert (NULL != ss->sender);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Considering SS UDPAck %s\n",
              GNUNET_i2s_full (&ss->sender->target));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "We have %u acks available.\n",
              ss->sender->acks_available);
  /* drop ancient KeyCacheEntries */
  while ((NULL != ss->kce_head) &&
         (MAX_SQN_DELTA <
          ss->kce_head->sequence_number - ss->kce_tail->sequence_number))
    kce_destroy (ss->kce_tail);
 
 
  if (GNUNET_NO == initial)
    kce_generate (ss, ++ss->sequence_allowed);
 
  /*if (0 == ss->sender->acks_available)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Generating keys\n");
    while (ss->active_kce_count < KCN_TARGET)
      kce_generate (ss, ++ss->sequence_allowed);
      }*/
 
  if (NULL != kce_task)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "kce_task is not NULL\n");
  if (kce_task_finished)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "kce_task_finished: GNUNET_YES\n");
  if (initial)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "initial: GNUNET_YES\n");
 
  if ( kce_task_finished || (GNUNET_NO == initial))
  {
    struct UDPAck ack;
    struct SharedSecret *ss_tell;
 
    if (GNUNET_NO != initial)
      ss_tell = ss_finished;
    else
      ss_tell = ss;
 
    ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK);
    ack.header.size = htons (sizeof(ack));
    ack.sequence_max = htonl (ss_tell->sequence_allowed);
    ack.acks_available = ss->sender->acks_available;
    ack.cmac = ss_tell->cmac;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Notifying transport of UDPAck %s with initial %u and master %s\n",
                GNUNET_i2s_full (&ss_tell->sender->target),
                initial,
                GNUNET_h2s (&(ss_tell->master)));
    GNUNET_TRANSPORT_communicator_notify (ch,
                                          &ss_tell->sender->target,
                                          COMMUNICATOR_ADDRESS_PREFIX,
                                          &ack.header);
    if (GNUNET_NO != initial)
    {
      destroy_all_secrets (ss, GNUNET_YES);
      ss->sender->kce_task_finished = GNUNET_NO;
    }
  }
  else if ((NULL == kce_task) && ((KCN_THRESHOLD >
                                   ss->sender->acks_available) ||
                                  (GNUNET_YES == ss->sender->rekeying) ||
                                  (ss->sender->num_secrets > MAX_SECRETS) ))
  {
 
    // kce_generate (ss, ++ss->sequence_allowed);
    // kce_generate (ss, ++ss->sequence_allowed);
    // TODO This task must be per sender!
    kce_task = GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL,
                                             kce_generate_cb,
                                             ss);
    kce_task_finished = GNUNET_NO;
 
  }
  else if ((NULL == kce_task_rekey) && (GNUNET_YES ==
                                        ss->sender->rekeying) )
  {
    kce_task_rekey = GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL,
                                                   kce_generate_rekey_cb,
                                                   ss);
  }
}

References UDPAck::acks_available, SenderAddress::acks_available, ch, UDPAck::cmac, SharedSecret::cmac, COMMUNICATOR_ADDRESS_PREFIX, destroy_all_secrets(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s_full(), GNUNET_log, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TRANSPORT_communicator_notify(), GNUNET_YES, UDPAck::header, kce_destroy(), kce_generate(), kce_generate_cb(), kce_generate_rekey_cb(), SharedSecret::kce_head, SharedSecret::kce_tail, SenderAddress::kce_task, SenderAddress::kce_task_finished, SenderAddress::kce_task_rekey, KCN_THRESHOLD, SharedSecret::master, MAX_SECRETS, MAX_SQN_DELTA, SenderAddress::num_secrets, SenderAddress::rekeying, SharedSecret::sender, SharedSecret::sequence_allowed, UDPAck::sequence_max, KeyCacheEntry::sequence_number, GNUNET_MessageHeader::size, ss_finished, SenderAddress::target, GNUNET_MessageHeader::type, and WORKING_QUEUE_INTERVALL.

Referenced by decrypt_box(), decrypt_rekey(), and sock_read().

Here is the call graph for this function:

Here is the caller graph for this function:

decrypt_box()

static void decrypt_box ( const struct UDPBox *  box, size_t  box_len, struct KeyCacheEntry *  kce  )

static

We received a box with matching kce.

Decrypt and process it.

Parameters

box	the data we received
box_len	number of bytes in box
kce	key index to decrypt box

Definition at line 1953 of file gnunet-communicator-udp.c.

{
  struct SharedSecret *ss = kce->ss;
  char out_buf[box_len - sizeof(*box)];
 
  GNUNET_assert (NULL != ss->sender);
  if (GNUNET_OK != try_decrypt (ss,
                                box->gcm_tag,
                                kce->sequence_number,
                                (const char *) &box[1],
                                sizeof(out_buf),
                                out_buf))
  {
    GNUNET_STATISTICS_update (stats,
                              "# Decryption failures with valid KCE",
                              1,
                              GNUNET_NO);
    kce_destroy (kce);
    return;
  }
  kce_destroy (kce);
  GNUNET_STATISTICS_update (stats,
                            "# bytes decrypted with BOX",
                            sizeof(out_buf),
                            GNUNET_NO);
  GNUNET_STATISTICS_update (stats,
                            "# messages decrypted with BOX",
                            1,
                            GNUNET_NO);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "decrypted UDPBox with kid %s\n",
              GNUNET_sh2s (&box->kid));
  try_handle_plaintext (ss->sender, out_buf, sizeof(out_buf));
  if ((GNUNET_NO == box->rekeying) && (GNUNET_YES == ss->sender->rekeying))
  {
    ss->sender->rekeying = GNUNET_NO;
    ss->sender->ss_rekey = NULL;
    // destroy_all_secrets (ss, GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Receiver stopped rekeying.\n");
  }
  else if (GNUNET_NO == box->rekeying)
    consider_ss_ack (ss, GNUNET_NO);
  else
  {
    ss->sender->rekeying = GNUNET_YES;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Got Box: Receiver doing rekeying.\n");
  }
}

References consider_ss_ack(), UDPBox::gcm_tag, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_STATISTICS_update(), GNUNET_YES, kce_destroy(), UDPBox::kid, UDPBox::rekeying, SenderAddress::rekeying, SharedSecret::sender, KeyCacheEntry::sequence_number, KeyCacheEntry::ss, SenderAddress::ss_rekey, stats, try_decrypt(), and try_handle_plaintext().

Referenced by sock_read().

Here is the call graph for this function:

Here is the caller graph for this function:

decrypt_rekey()

static void decrypt_rekey ( const struct UDPRekey *  rekey, size_t  rekey_len, struct KeyCacheEntry *  kce, struct SenderAddress *  sender  )

static

We received a rekey with matching kce.

Decrypt and process it.

Parameters

rekey	the data we received
rekey_len	number of bytes in rekey
kce	key index to decrypt rekey

Definition at line 2015 of file gnunet-communicator-udp.c.

{
  struct SharedSecret *ss = kce->ss;
  struct SharedSecret *ss_rekey;
  char out_buf[rekey_len - sizeof(*rekey)];
  struct GNUNET_HashCode *master;
 
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "decrypt_rekey.\n");
 
  GNUNET_assert (NULL != ss->sender);
  if (GNUNET_OK != try_decrypt (ss,
                                rekey->gcm_tag,
                                kce->sequence_number,
                                (const char *) &rekey[1],
                                sizeof(out_buf),
                                out_buf))
  {
    GNUNET_STATISTICS_update (stats,
                              "# Decryption failures with valid KCE",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Decryption with kid %s failed\n",
                GNUNET_sh2s (&rekey->kid));
    kce_destroy (kce);
    return;
  }
  kce_destroy (kce);
  GNUNET_STATISTICS_update (stats,
                            "# bytes decrypted with Rekey",
                            sizeof(out_buf),
                            GNUNET_NO);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "decrypted UDPRekey with kid %s\n",
              GNUNET_sh2s (&rekey->kid));
  /*cmac = (struct GNUNET_HashCode *) out_buf;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received secret with cmac %s \n",
              GNUNET_h2s (&cmac));*/
  // ss_rekey = (struct SharedSecret *) out_buf;
  master = (struct GNUNET_HashCode *) out_buf;
  ss_rekey = GNUNET_new (struct SharedSecret);
  ss_rekey->master = *master;
  calculate_cmac (ss_rekey);
  ss_rekey->sender = sender;
  // ss_rekey->sequence_used = 0;
  // ss_rekey->sequence_allowed = 0;
  /* ss_rekey->active_kce_count = 0; */
  /* ss_rekey->prev = NULL; */
  /* ss_rekey->next = NULL; */
  /* GNUNET_assert (ss_rekey->prev == NULL && sender->ss_head != ss_rekey); */
  /* GNUNET_assert (ss_rekey->next == NULL && sender->ss_tail != ss_rekey); */
  GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss_rekey);
  sender->ss_rekey = ss_rekey;
  sender->num_secrets++;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received secret with cmac %s\n",
              GNUNET_h2s (&(ss_rekey->cmac)));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received secret with master %s.\n",
              GNUNET_h2s (&(ss_rekey->master)));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "We have %u sequence_allowed.\n",
              ss_rekey->sequence_allowed);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "We have a sender %p\n",
              ss_rekey->sender);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "We have %u acks available.\n",
              ss_rekey->sender->acks_available);
  consider_ss_ack (ss_rekey, GNUNET_YES);
 
}

References SenderAddress::acks_available, calculate_cmac(), SharedSecret::cmac, consider_ss_ack(), UDPRekey::gcm_tag, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_STATISTICS_update(), GNUNET_YES, kce_destroy(), UDPRekey::kid, SharedSecret::master, SenderAddress::num_secrets, SharedSecret::sender, SharedSecret::sequence_allowed, KeyCacheEntry::sequence_number, KeyCacheEntry::ss, SenderAddress::ss_head, SenderAddress::ss_rekey, SenderAddress::ss_tail, stats, and try_decrypt().

Referenced by sock_read().

Here is the call graph for this function:

Here is the caller graph for this function:

find_sender_by_address()

static int find_sender_by_address ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Find existing struct SenderAddress by matching addresses.

Parameters

cls	a struct SearchContext
key	ignored, must match already
value	a struct SenderAddress

Returns

GNUNET_YES if not found (continue to search), GNUNET_NO if found

Definition at line 2126 of file gnunet-communicator-udp.c.

{
  struct SearchContext *sc = cls;
  struct SenderAddress *sender = value;
 
  if ((sender->address_len == sc->address_len) &&
      (0 == memcmp (sender->address, sc->address, sender->address_len)))
  {
    sc->sender = sender;
    return GNUNET_NO;   /* stop iterating! */
  }
  return GNUNET_YES;
}

References SenderAddress::address, SenderAddress::address_len, GNUNET_NO, GNUNET_YES, sc, and value.

Referenced by setup_sender().

Here is the caller graph for this function:

setup_sender()

static struct SenderAddress* setup_sender ( const struct GNUNET_PeerIdentity *  target, const struct sockaddr *  address, socklen_t  address_len  )

static

Create sender address for target.

Note that we might already have one, so a fresh one is only allocated if one does not yet exist for address.

Parameters

target	peer to generate address for
address	target address
address_len	number of bytes in address

Returns

data structure to keep track of key material for decrypting data from target

Definition at line 2155 of file gnunet-communicator-udp.c.

{
  struct SenderAddress *sender;
  struct SearchContext sc = { .address = address,
                              .address_len = address_len,
                              .sender = NULL };
 
  GNUNET_CONTAINER_multipeermap_get_multiple (senders,
                                              target,
                                              &find_sender_by_address,
                                              &sc);
  if (NULL != sc.sender)
  {
    reschedule_sender_timeout (sc.sender);
    return sc.sender;
  }
  sender = GNUNET_new (struct SenderAddress);
  sender->target = *target;
  sender->address = GNUNET_memdup (address, address_len);
  sender->address_len = address_len;
  (void) GNUNET_CONTAINER_multipeermap_put (
    senders,
    &sender->target,
    sender,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  GNUNET_STATISTICS_set (stats,
                         "# senders active",
                         GNUNET_CONTAINER_multipeermap_size (receivers),
                         GNUNET_NO);
  sender->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  sender->hn = GNUNET_CONTAINER_heap_insert (senders_heap,
                                             sender,
                                             sender->timeout.abs_value_us);
  sender->nt = GNUNET_NT_scanner_get_type (is, address, address_len);
  if (NULL == timeout_task)
    timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL);
  return sender;
}

References GNUNET_TIME_Absolute::abs_value_us, address, SenderAddress::address, SenderAddress::address_len, SearchContext::address_len, check_timeouts(), find_sender_by_address(), GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_memdup, GNUNET_new, GNUNET_NO, GNUNET_NT_scanner_get_type(), GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_set(), GNUNET_TIME_relative_to_absolute(), SenderAddress::hn, is, SenderAddress::nt, receivers, reschedule_sender_timeout(), sc, SearchContext::sender, senders, senders_heap, stats, SenderAddress::target, SenderAddress::timeout, and timeout_task.

Referenced by sock_read().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_confirmation()

static int verify_confirmation ( const struct GNUNET_CRYPTO_EcdhePublicKey *  ephemeral, const struct UDPConfirmation *  uc  )

static

Check signature from uc against ephemeral.

Parameters

ephemeral	key that is signed
uc	signature of claimant

Returns

GNUNET_OK if signature is valid

Definition at line 2206 of file gnunet-communicator-udp.c.

{
  struct UdpHandshakeSignature uhs;
 
  uhs.purpose.purpose = htonl (
    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE);
  uhs.purpose.size = htonl (sizeof(uhs));
  uhs.sender = uc->sender;
  uhs.receiver = my_identity;
  uhs.ephemeral = *ephemeral;
  uhs.monotonic_time = uc->monotonic_time;
  return GNUNET_CRYPTO_eddsa_verify (
    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE,
    &uhs,
    &uc->sender_sig,
    &uc->sender.public_key);
}

References UdpHandshakeSignature::ephemeral, GNUNET_CRYPTO_eddsa_verify, GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE, UdpHandshakeSignature::monotonic_time, my_identity, GNUNET_CRYPTO_EccSignaturePurpose::purpose, UdpHandshakeSignature::purpose, UdpHandshakeSignature::receiver, UdpHandshakeSignature::sender, GNUNET_CRYPTO_EccSignaturePurpose::size, and uc.

Referenced by sock_read().

Here is the caller graph for this function:

sockaddr_to_udpaddr_string()

static char* sockaddr_to_udpaddr_string ( const struct sockaddr *  address, socklen_t  address_len  )

static

Converts address to the address string format used by this communicator in HELLOs.

Parameters

address	the address to convert, must be AF_INET or AF_INET6.
address_len	number of bytes in address

Returns

string representation of address

Definition at line 2235 of file gnunet-communicator-udp.c.

{
  char *ret;
 
  switch (address->sa_family)
  {
  case AF_INET:
    GNUNET_asprintf (&ret,
                     "%s-%s",
                     COMMUNICATOR_ADDRESS_PREFIX,
                     GNUNET_a2s (address, address_len));
    break;
 
  case AF_INET6:
    GNUNET_asprintf (&ret,
                     "%s-%s",
                     COMMUNICATOR_ADDRESS_PREFIX,
                     GNUNET_a2s (address, address_len));
    break;
 
  default:
    GNUNET_assert (0);
  }
  return ret;
}

References address, COMMUNICATOR_ADDRESS_PREFIX, GNUNET_a2s(), GNUNET_asprintf(), GNUNET_assert, and ret.

Referenced by mq_init(), and sock_read().

Here is the call graph for this function:

Here is the caller graph for this function:

sock_read()

static void sock_read ( void *  cls )

static

Socket read task.

Parameters

cls

NULL

Definition at line 2269 of file gnunet-communicator-udp.c.

{
  struct sockaddr_storage sa;
  struct sockaddr_in *addr_verify;
  socklen_t salen = sizeof(sa);
  char buf[UINT16_MAX];
  ssize_t rcvd;
 
  (void) cls;
  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                             udp_sock,
                                             &sock_read,
                                             NULL);
  rcvd = GNUNET_NETWORK_socket_recvfrom (udp_sock,
                                         buf,
                                         sizeof(buf),
                                         (struct sockaddr *) &sa,
                                         &salen);
  if (-1 == rcvd)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Read %lu bytes\n", rcvd);
 
  if (rcvd > sizeof(struct UDPRekey))
  {
    const struct UDPRekey *rekey;
    const struct UDPBox *box;
    struct KeyCacheEntry *kce;
    struct SenderAddress *sender;
    int do_decrypt = GNUNET_NO;
 
    rekey = (const struct UDPRekey *) buf;
    box = (const struct UDPBox *) buf;
    kce = GNUNET_CONTAINER_multishortmap_get (key_cache, &rekey->kid);
 
    if ((GNUNET_YES == box->rekeying) || (GNUNET_NO == box->rekeying))
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "UDPRekey has rekeying %u\n",
                  box->rekeying);
    else
      do_decrypt = GNUNET_YES;
 
    if ((GNUNET_YES == do_decrypt) && (NULL != kce) && (GNUNET_YES ==
                                                        kce->ss->sender->
                                                        rekeying))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "UDPRekey with kid %s\n",
                  GNUNET_sh2s (&rekey->kid));
      sender = setup_sender (&rekey->sender, (const struct sockaddr *) &sa,
                             salen);
 
      if (NULL != sender->ss_rekey)
        return;
 
      decrypt_rekey (rekey, (size_t) rcvd, kce, sender);
      return;
    }
  }
 
  /* first, see if it is a UDPBox */
  if (rcvd > sizeof(struct UDPBox))
  {
    const struct UDPBox *box;
    struct KeyCacheEntry *kce;
 
    box = (const struct UDPBox *) buf;
    kce = GNUNET_CONTAINER_multishortmap_get (key_cache, &box->kid);
    if (NULL != kce)
    {
      decrypt_box (box, (size_t) rcvd, kce);
      return;
    }
  }
 
  /* next, check if it is a broadcast */
  if (sizeof(struct UDPBroadcast) == rcvd)
  {
    const struct UDPBroadcast *ub;
    struct UdpBroadcastSignature uhs;
    struct GNUNET_PeerIdentity sender;
 
    addr_verify = GNUNET_memdup (&sa, salen);
    addr_verify->sin_port = 0;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "received UDPBroadcast from %s\n",
                GNUNET_a2s ((const struct sockaddr *) addr_verify, salen));
    ub = (const struct UDPBroadcast *) buf;
    uhs.purpose.purpose = htonl (
      GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST);
    uhs.purpose.size = htonl (sizeof(uhs));
    uhs.sender = ub->sender;
    sender = ub->sender;
    if (0 == memcmp (&sender, &my_identity, sizeof (struct
                                                    GNUNET_PeerIdentity)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Received our own broadcast\n");
      GNUNET_free (addr_verify);
      return;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "checking UDPBroadcastSignature for %s\n",
                GNUNET_i2s (&sender));
    GNUNET_CRYPTO_hash ((struct sockaddr *) addr_verify, salen, &uhs.h_address);
    if (GNUNET_OK ==
        GNUNET_CRYPTO_eddsa_verify (
          GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST,
          &uhs,
          &ub->sender_sig,
          &ub->sender.public_key))
    {
      char *addr_s;
      enum GNUNET_NetworkType nt;
 
      addr_s =
        sockaddr_to_udpaddr_string ((const struct sockaddr *) &sa, salen);
      GNUNET_STATISTICS_update (stats, "# broadcasts received", 1, GNUNET_NO);
      /* use our own mechanism to determine network type */
      nt =
        GNUNET_NT_scanner_get_type (is, (const struct sockaddr *) &sa, salen);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "validating address %s received from UDPBroadcast\n",
                  GNUNET_i2s (&sender));
      GNUNET_TRANSPORT_application_validate (ah, &sender, nt, addr_s);
      GNUNET_free (addr_s);
      GNUNET_free (addr_verify);
      return;
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "VerifyingPeer %s is verifying UDPBroadcast\n",
                  GNUNET_i2s (&my_identity));
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Verifying UDPBroadcast from %s failed\n",
                  GNUNET_i2s (&ub->sender));
    }
    GNUNET_free (addr_verify);
    /* continue with KX, mostly for statistics... */
  }
 
 
  /* finally, test if it is a KX */
  if (rcvd < sizeof(struct UDPConfirmation) + sizeof(struct InitialKX))
  {
    GNUNET_STATISTICS_update (stats,
                              "# messages dropped (no kid, too small for KX)",
                              1,
                              GNUNET_NO);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got KX\n");
  {
    const struct InitialKX *kx;
    struct SharedSecret *ss;
    char pbuf[rcvd - sizeof(struct InitialKX)];
    const struct UDPConfirmation *uc;
    struct SenderAddress *sender;
 
    kx = (const struct InitialKX *) buf;
    ss = setup_shared_secret_dec (&kx->ephemeral);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Before DEC\n");
 
    if (GNUNET_OK != try_decrypt (ss,
                                  kx->gcm_tag,
                                  0,
                                  &buf[sizeof(*kx)],
                                  sizeof(pbuf),
                                  pbuf))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Unable to decrypt tag, dropping...\n");
      GNUNET_free (ss);
      GNUNET_STATISTICS_update (
        stats,
        "# messages dropped (no kid, AEAD decryption failed)",
        1,
        GNUNET_NO);
      return;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Before VERIFY\n");
 
    uc = (const struct UDPConfirmation *) pbuf;
    if (GNUNET_OK != verify_confirmation (&kx->ephemeral, uc))
    {
      GNUNET_break_op (0);
      GNUNET_free (ss);
      GNUNET_STATISTICS_update (stats,
                                "# messages dropped (sender signature invalid)",
                                1,
                                GNUNET_NO);
      return;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Before SETUP_SENDER\n");
 
    calculate_cmac (ss);
    sender = setup_sender (&uc->sender, (const struct sockaddr *) &sa, salen);
    ss->sender = sender;
    GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss);
    sender->num_secrets++;
    GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
    GNUNET_STATISTICS_update (stats,
                              "# messages decrypted without BOX",
                              1,
                              GNUNET_NO);
    try_handle_plaintext (sender, &uc[1], sizeof(pbuf) - sizeof(*uc));
    if ((GNUNET_NO == kx->rekeying) && (GNUNET_YES == ss->sender->rekeying))
    {
      ss->sender->rekeying = GNUNET_NO;
      sender->ss_rekey = NULL;
      // destroy_all_secrets (ss, GNUNET_NO);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Receiver stopped rekeying.\n");
    }
    else if (GNUNET_NO == kx->rekeying)
      consider_ss_ack (ss, GNUNET_YES);
    else
    {
      ss->sender->rekeying = GNUNET_YES;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Got KX: Receiver doing rekeying.\n");
    }
    /*if (sender->num_secrets > MAX_SECRETS)
      secret_destroy (sender->ss_tail);*/
  }
}

References ah, buf, calculate_cmac(), consider_ss_ack(), decrypt_box(), decrypt_rekey(), do_decrypt(), InitialKX::ephemeral, InitialKX::gcm_tag, GNUNET_a2s(), GNUNET_break_op, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CRYPTO_eddsa_verify, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_log_strerror, GNUNET_memdup, GNUNET_NETWORK_socket_recvfrom(), GNUNET_NO, GNUNET_NT_scanner_get_type(), GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_sh2s(), GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST, GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_application_validate(), GNUNET_YES, UdpBroadcastSignature::h_address, is, key_cache, UDPBox::kid, UDPRekey::kid, my_identity, nt, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, UdpBroadcastSignature::purpose, read_task, InitialKX::rekeying, UDPBox::rekeying, SenderAddress::rekeying, UDPConfirmation::sender, UdpBroadcastSignature::sender, UDPBroadcast::sender, UDPRekey::sender, SharedSecret::sender, UDPBroadcast::sender_sig, setup_sender(), setup_shared_secret_dec(), GNUNET_CRYPTO_EccSignaturePurpose::size, sockaddr_to_udpaddr_string(), KeyCacheEntry::ss, SenderAddress::ss_rekey, stats, try_decrypt(), try_handle_plaintext(), uc, udp_sock, and verify_confirmation().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

udp_address_to_sockaddr()

static struct sockaddr* udp_address_to_sockaddr ( const char *  bindto, socklen_t *  sock_len  )

static

Convert UDP bind specification to a struct sockaddr *

Parameters

	bindto	bind specification to convert
[out]	sock_len	set to the length of the address

Returns

converted bindto specification

Definition at line 2513 of file gnunet-communicator-udp.c.

{
  struct sockaddr *in;
  unsigned int port;
  char dummy[2];
  char *colon;
  char *cp;
 
  if (1 == sscanf (bindto, "%u%1s", &port, dummy))
  {
    /* interpreting value as just a PORT number */
    if (port > UINT16_MAX)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "BINDTO specification `%s' invalid: value too large for port\n",
                  bindto);
      return NULL;
    }
    if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
        (GNUNET_YES ==
         GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                               COMMUNICATOR_CONFIG_SECTION,
                                               "DISABLE_V6")))
    {
      struct sockaddr_in *i4;
 
      i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
      i4->sin_family = AF_INET;
      i4->sin_port = htons ((uint16_t) port);
      *sock_len = sizeof(struct sockaddr_in);
      in = (struct sockaddr *) i4;
    }
    else
    {
      struct sockaddr_in6 *i6;
 
      i6 = GNUNET_malloc (sizeof(struct sockaddr_in6));
      i6->sin6_family = AF_INET6;
      i6->sin6_port = htons ((uint16_t) port);
      *sock_len = sizeof(struct sockaddr_in6);
      in = (struct sockaddr *) i6;
    }
    return in;
  }
  cp = GNUNET_strdup (bindto);
  colon = strrchr (cp, ':');
  if (NULL != colon)
  {
    /* interpret value after colon as port */
    *colon = '\0';
    colon++;
    if (1 == sscanf (colon, "%u%1s", &port, dummy))
    {
      /* interpreting value as just a PORT number */
      if (port > UINT16_MAX)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "BINDTO specification `%s' invalid: value too large for port\n",
                    bindto);
        GNUNET_free (cp);
        return NULL;
      }
    }
    else
    {
      GNUNET_log (
        GNUNET_ERROR_TYPE_ERROR,
        "BINDTO specification `%s' invalid: last ':' not followed by number\n",
        bindto);
      GNUNET_free (cp);
      return NULL;
    }
  }
  else
  {
    /* interpret missing port as 0, aka pick any free one */
    port = 0;
  }
  {
    /* try IPv4 */
    struct sockaddr_in v4;
 
    memset (&v4, 0, sizeof(v4));
    if (1 == inet_pton (AF_INET, cp, &v4.sin_addr))
    {
      v4.sin_family = AF_INET;
      v4.sin_port = htons ((uint16_t) port);
#if HAVE_SOCKADDR_IN_SIN_LEN
      v4.sin_len = sizeof(struct sockaddr_in);
#endif
      in = GNUNET_memdup (&v4, sizeof(struct sockaddr_in));
      *sock_len = sizeof(struct sockaddr_in);
      GNUNET_free (cp);
      return in;
    }
  }
  {
    /* try IPv6 */
    struct sockaddr_in6 v6;
    const char *start;
 
    memset (&v6, 0, sizeof(v6));
    start = cp;
    if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
    {
      start++;   /* skip over '[' */
      cp[strlen (cp) - 1] = '\0';  /* eat ']' */
    }
    if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
    {
      v6.sin6_family = AF_INET6;
      v6.sin6_port = htons ((uint16_t) port);
#if HAVE_SOCKADDR_IN_SIN_LEN
      v6.sin6_len = sizeof(sizeof(struct sockaddr_in6));
#endif
      in = GNUNET_memdup (&v6, sizeof(v6));
      *sock_len = sizeof(v6);
      GNUNET_free (cp);
      return in;
    }
  }
  /* #5528 FIXME (feature!): maybe also try getnameinfo()? */
  GNUNET_free (cp);
  return NULL;
}

References cfg, COMMUNICATOR_CONFIG_SECTION, dummy, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memdup, GNUNET_NETWORK_test_pf(), GNUNET_NO, GNUNET_strdup, GNUNET_YES, port, and start.

Referenced by mq_init(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

do_pad()

static void do_pad ( gcry_cipher_hd_t  out_cipher, char *  dgram, size_t  pad_size  )

static

Pad dgram by pad_size using out_cipher.

Parameters

out_cipher	cipher to use
dgram	datagram to pad
pad_size	number of bytes of padding to append

Definition at line 2648 of file gnunet-communicator-udp.c.

{
  char pad[pad_size];
 
  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, pad, sizeof(pad));
  if (sizeof(pad) > sizeof(struct GNUNET_MessageHeader))
  {
    struct GNUNET_MessageHeader hdr =
    { .size = htons (sizeof(pad)),
      .type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD) };
 
    memcpy (pad, &hdr, sizeof(hdr));
  }
  GNUNET_assert (
    0 ==
    gcry_cipher_encrypt (out_cipher, dgram, sizeof(pad), pad, sizeof(pad)));
}

References GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_block(), GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD, and GNUNET_MessageHeader::size.

Referenced by mq_send_d(), mq_send_kx(), and send_UDPRekey().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_send_kx()

static void mq_send_kx ( struct GNUNET_MQ_Handle *  mq, const struct GNUNET_MessageHeader *  msg, void *  impl_state  )

static

Signature of functions implementing the sending functionality of a message queue.

Parameters

mq	the message queue
msg	the message to send
impl_state	our struct ReceiverAddress

Definition at line 2676 of file gnunet-communicator-udp.c.

{
  struct ReceiverAddress *receiver = impl_state;
  uint16_t msize = ntohs (msg->size);
  struct UdpHandshakeSignature uhs;
  struct UDPConfirmation uc;
  struct InitialKX kx;
  struct GNUNET_CRYPTO_EcdhePrivateKey epriv;
  char dgram[receiver->kx_mtu + sizeof(uc) + sizeof(kx)];
  size_t dpos;
  gcry_cipher_hd_t out_cipher;
  struct SharedSecret *ss;
 
  GNUNET_assert (mq == receiver->kx_mq);
  if (msize > receiver->kx_mtu)
  {
    GNUNET_break (0);
    if (GNUNET_YES != receiver->receiver_destroy_called)
      receiver_destroy (receiver);
    return;
  }
  reschedule_receiver_timeout (receiver);
 
  /* setup key material */
  GNUNET_CRYPTO_ecdhe_key_create (&epriv);
 
  ss = setup_shared_secret_enc (&epriv, receiver, GNUNET_YES);
 
  if (receiver->num_secrets > MAX_SECRETS)
  {
    destroy_all_secrets (ss, GNUNET_YES);
  }
 
  setup_cipher (&ss->master, 0, &out_cipher);
  /* compute 'uc' */
  uc.sender = my_identity;
  uc.monotonic_time =
    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
  uhs.purpose.purpose = htonl (
    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE);
  uhs.purpose.size = htonl (sizeof(uhs));
  uhs.sender = my_identity;
  uhs.receiver = receiver->target;
  GNUNET_CRYPTO_ecdhe_key_get_public (&epriv, &uhs.ephemeral);
  uhs.monotonic_time = uc.monotonic_time;
  GNUNET_CRYPTO_eddsa_sign (my_private_key,
                            &uhs,
                            &uc.sender_sig);
  /* Leave space for kx */
  dpos = sizeof(kx);
  /* Append encrypted uc to dgram */
  GNUNET_assert (0 == gcry_cipher_encrypt (out_cipher,
                                           &dgram[dpos],
                                           sizeof(uc),
                                           &uc,
                                           sizeof(uc)));
  dpos += sizeof(uc);
  /* Append encrypted payload to dgram */
  GNUNET_assert (
    0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
  dpos += msize;
  do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
  /* Datagram starts with kx */
  kx.ephemeral = uhs.ephemeral;
  GNUNET_assert (
    0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag)));
  gcry_cipher_close (out_cipher);
  if (GNUNET_NO == receiver->rekeying)
    kx.rekeying = GNUNET_NO;
  else
    kx.rekeying = GNUNET_YES;
  memcpy (dgram, &kx, sizeof(kx));
  if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
                                          dgram,
                                          sizeof(dgram),
                                          receiver->address,
                                          receiver->address_len))
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending KX with payload size %u to %s\n",
              msize,
              GNUNET_a2s (receiver->address,
                          receiver->address_len));
  GNUNET_MQ_impl_send_continue (mq);
}

References cfg, destroy_all_secrets(), do_pad(), UdpHandshakeSignature::ephemeral, InitialKX::ephemeral, InitialKX::gcm_tag, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_CRYPTO_eddsa_sign, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_sendto(), GNUNET_NO, GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE, GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), GNUNET_YES, SharedSecret::master, MAX_SECRETS, UdpHandshakeSignature::monotonic_time, mq, msg, my_identity, my_private_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, UdpHandshakeSignature::purpose, UdpHandshakeSignature::receiver, receiver(), receiver_destroy(), InitialKX::rekeying, reschedule_receiver_timeout(), UdpHandshakeSignature::sender, setup_cipher(), setup_shared_secret_enc(), GNUNET_MessageHeader::size, GNUNET_CRYPTO_EccSignaturePurpose::size, uc, and udp_sock.

Referenced by setup_receiver_mq().

Here is the call graph for this function:

Here is the caller graph for this function:

check_for_rekeying()

static void check_for_rekeying ( struct ReceiverAddress *  receiver, struct UDPBox *  box  )

static

Definition at line 2766 of file gnunet-communicator-udp.c.

{
 
  struct GNUNET_TIME_Relative rt;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Timeout is %llu\n.",
              (unsigned long long) receiver->rekey_timeout.abs_value_us);
 
  if (0 == receiver->rekey_timeout.abs_value_us)
  {
    receiver->rekey_timeout = GNUNET_TIME_relative_to_absolute (
      rekey_interval);
  }
  else
  {
    rt = GNUNET_TIME_absolute_get_remaining (receiver->rekey_timeout);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Relative time is %llu and timeout is %llu\n.",
                (unsigned long long) rt.rel_value_us,
                (unsigned long long) receiver->rekey_timeout.abs_value_us);
 
    if ((0 == rt.rel_value_us) || (receiver->rekey_send_bytes >
                                   rekey_max_bytes) )
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Bytes send %llu greater than %llu max bytes\n.",
                  (unsigned long long) receiver->rekey_send_bytes,
                  rekey_max_bytes);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Relative time is %llu and timeout is %llu\n.",
                  (unsigned long long) rt.rel_value_us,
                  (unsigned long long) receiver->rekey_timeout.abs_value_us);
 
      receiver->rekey_timeout.abs_value_us = 0;
      receiver->rekey_send_bytes = 0;
      receiver->ss_rekey = NULL;
      // destroy_all_secrets (ss, GNUNET_NO);
      receiver->rekeying = GNUNET_YES;
      receiver->rekey_acks_available = receiver->acks_available;
      box->rekeying = GNUNET_YES;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Sender started rekeying.\n");
      if (GNUNET_YES == box->rekeying)
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Sending rekeying with kid %s\n",
                    GNUNET_sh2s (&box->kid));
    }
  }
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_sh2s(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, UDPBox::kid, receiver(), rekey_interval, rekey_max_bytes, UDPBox::rekeying, and GNUNET_TIME_Relative::rel_value_us.

Referenced by mq_send_d().

Here is the call graph for this function:

Here is the caller graph for this function:

send_UDPRekey()

static void send_UDPRekey ( struct ReceiverAddress *  receiver, struct SharedSecret *  ss  )

static

Definition at line 2819 of file gnunet-communicator-udp.c.

{
  uint8_t is_ss_rekey_sequence_allowed_zero = GNUNET_NO;
  uint8_t is_acks_available_below = GNUNET_NO;
  uint8_t send_rekey = GNUNET_NO;
  uint16_t not_below;
  struct GNUNET_CRYPTO_EcdhePrivateKey epriv;
  struct UDPRekey *rekey;
  size_t dpos;
 
  char rekey_dgram[sizeof(struct UDPRekey) + receiver->d_mtu];
 
  if (NULL != receiver->ss_rekey)
  {
    not_below = (receiver->rekey_acks_available
                 - (receiver->rekey_acks_available % 3)) / 3;
    is_ss_rekey_sequence_allowed_zero = (0 ==
                                         receiver->ss_rekey->sequence_allowed);
    is_acks_available_below = (receiver->acks_available >= not_below);
    send_rekey = (0 == (receiver->acks_available - not_below) % not_below) &&
                 is_acks_available_below && is_ss_rekey_sequence_allowed_zero;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "send_rekey: %u, %u, %u\n",
                send_rekey,
                receiver->rekey_acks_available,
                receiver->acks_available);
  }
  else if (NULL == receiver->ss_rekey)
  {
    /* setup key material */
    GNUNET_CRYPTO_ecdhe_key_create (&epriv);
    receiver->ss_rekey = setup_shared_secret_enc (&epriv, receiver,
                                                  GNUNET_NO);
    receiver->ss_rekey->sequence_allowed = 0;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Setup secret with cmac %s\n",
                GNUNET_h2s (&(receiver->ss_rekey->cmac)));
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Setup secret with master %s.\n",
                GNUNET_h2s (&(receiver->ss_rekey->master)));
  }
 
  if (send_rekey)
  {
    GNUNET_assert (0 != receiver->number_rekeying_kce);
    gcry_cipher_hd_t rekey_out_cipher;
 
    while (NULL != ss && ss->sequence_used >= ss->sequence_allowed)
    {
      ss = ss->prev;
    }
 
    if (NULL != ss)
    {
      rekey = (struct UDPRekey *) rekey_dgram;
      rekey->sender = my_identity;
      ss->sequence_used++;
      get_kid (&ss->master, ss->sequence_used, &rekey->kid);
      receiver->number_rekeying_kce--;
      setup_cipher (&ss->master, ss->sequence_used, &rekey_out_cipher);
      /* Append encrypted payload to dgram */
      dpos = sizeof(struct UDPRekey);
 
      GNUNET_assert (
        0 == gcry_cipher_encrypt (rekey_out_cipher, &rekey_dgram[dpos],
                                  sizeof(receiver->ss_rekey->master),
                                  &(receiver->ss_rekey->master),
                                  sizeof(receiver->ss_rekey->master)));
      dpos += sizeof(receiver->ss_rekey->master);
      /* GNUNET_assert ( */
      /*   0 == gcry_cipher_encrypt (rekey_out_cipher, &rekey_dgram[dpos], */
      /*                             /\*sizeof(receiver->ss_rekey->cmac), */
      /*                             &(receiver->ss_rekey->cmac), */
      /*                             sizeof(receiver->ss_rekey->cmac))); */
      /*                             dpos += sizeof(receiver->ss_rekey->cmac);*\/ */
      /*                             sizeof(receiver->ss_rekey), */
      /*                             receiver->ss_rekey, */
      /*                             sizeof(receiver->ss_rekey))); */
      /* dpos += sizeof(receiver->ss_rekey); */
      do_pad (rekey_out_cipher, &rekey_dgram[dpos], sizeof(rekey_dgram)
              - dpos);
      GNUNET_assert (0 == gcry_cipher_gettag (rekey_out_cipher,
                                              rekey->gcm_tag,
                                              sizeof(rekey->gcm_tag)));
      gcry_cipher_close (rekey_out_cipher);
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Sending rekey with kid %s and master %s\n",
                  GNUNET_sh2s (&rekey->kid),
                  GNUNET_h2s (&(receiver->ss_rekey->master)));
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Sending rekey with cmac %s\n",
                  GNUNET_h2s (&(receiver->ss_rekey->cmac)));
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "%u rekey kces left.\n",
                  receiver->number_rekeying_kce);
 
      if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
                                              rekey_dgram,
                                              sizeof(rekey_dgram),
                                              receiver->address,
                                              receiver->address_len))
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
 
      receiver->acks_available--;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "%u receiver->acks_available 1\n",
                  receiver->acks_available);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Sending UDPRekey to %s\n", GNUNET_a2s (receiver->address,
                                                          receiver->
                                                          address_len));
    }
  }
}

References do_pad(), UDPRekey::gcm_tag, get_kid(), GNUNET_a2s(), GNUNET_assert, GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_sendto(), GNUNET_NO, GNUNET_sh2s(), UDPRekey::kid, SharedSecret::master, my_identity, SharedSecret::prev, receiver(), UDPRekey::sender, SharedSecret::sequence_allowed, SharedSecret::sequence_used, setup_cipher(), setup_shared_secret_enc(), and udp_sock.

Referenced by mq_send_d().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_send_d()

static void mq_send_d ( struct GNUNET_MQ_Handle *  mq, const struct GNUNET_MessageHeader *  msg, void *  impl_state  )

static

Signature of functions implementing the sending functionality of a message queue.

Parameters

mq	the message queue
msg	the message to send
impl_state	our struct ReceiverAddress

Definition at line 2945 of file gnunet-communicator-udp.c.

{
  struct ReceiverAddress *receiver = impl_state;
  uint16_t msize = ntohs (msg->size);
 
  GNUNET_assert (mq == receiver->d_mq);
  if ((msize > receiver->d_mtu) ||
      (0 == receiver->acks_available))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "msize: %u, mtu: %lu, acks: %u\n",
                msize,
                receiver->d_mtu,
                receiver->acks_available);
 
    GNUNET_break (0);
    if (GNUNET_YES != receiver->receiver_destroy_called)
      receiver_destroy (receiver);
    return;
  }
  reschedule_receiver_timeout (receiver);
 
  /* begin "BOX" encryption method, scan for ACKs from tail! */
  for (struct SharedSecret *ss = receiver->ss_tail; NULL != ss; ss = ss->prev)
  {
    if (0 < ss->sequence_used)
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Trying to send UDPBox with shared secrect %s sequence_used %u and ss->sequence_allowed %u\n",
                  GNUNET_h2s (&ss->master),
                  ss->sequence_used,
                  ss->sequence_allowed);
    // Uncomment this for alternativ 1 of backchannel functionality
    if (ss->sequence_used >= ss->sequence_allowed)
    // Until here for alternativ 1
    // Uncomment this for alternativ 2 of backchannel functionality
    // if (0 == ss->sequence_allowed)
    // Until here for alternativ 2
    {
      continue;
    }
    char dgram[sizeof(struct UDPBox) + receiver->d_mtu];
    struct UDPBox *box;
    gcry_cipher_hd_t out_cipher;
    size_t dpos;
 
    box = (struct UDPBox *) dgram;
    ss->sequence_used++;
    get_kid (&ss->master, ss->sequence_used, &box->kid);
    setup_cipher (&ss->master, ss->sequence_used, &out_cipher);
    /* Append encrypted payload to dgram */
    dpos = sizeof(struct UDPBox);
    GNUNET_assert (
      0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
    dpos += msize;
    do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
    GNUNET_assert (0 == gcry_cipher_gettag (out_cipher,
                                            box->gcm_tag,
                                            sizeof(box->gcm_tag)));
    gcry_cipher_close (out_cipher);
 
    receiver->rekey_send_bytes += sizeof(struct UDPBox) + receiver->d_mtu;
 
    if (GNUNET_NO == receiver->rekeying)
      box->rekeying = GNUNET_NO;
    else
      box->rekeying = GNUNET_YES;
 
    if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
                                            dgram,
                                            sizeof(dgram),
                                            receiver->address,
                                            receiver->address_len))
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending UDPBox with payload size %u, %u acks left\n",
                msize,
                receiver->acks_available);
    GNUNET_MQ_impl_send_continue (mq);
    receiver->acks_available--;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "%u receiver->acks_available 2\n",
                receiver->acks_available);
    check_for_rekeying (receiver, box);
    if (0 == receiver->acks_available - receiver->number_rekeying_kce)
    {
      /* We have no more ACKs */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "No more acks\n");
      if (GNUNET_YES == receiver->rekeying)
      {
        receiver->rekeying = GNUNET_NO;
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Sender stopped rekeying\n");
 
        if ((NULL != receiver->ss_rekey) && (0 <
                                             receiver->ss_rekey->
                                             sequence_allowed) )
          add_acks_rekey (receiver);
      }
    }
    else if ((GNUNET_YES == receiver->rekeying)  )
    {
      send_UDPRekey (receiver, ss);
    }
 
    return;
  }
}

References add_acks_rekey(), check_for_rekeying(), do_pad(), UDPBox::gcm_tag, get_kid(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_log_strerror, GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_sendto(), GNUNET_NO, GNUNET_YES, UDPBox::kid, mq, msg, receiver(), receiver_destroy(), UDPBox::rekeying, reschedule_receiver_timeout(), send_UDPRekey(), setup_cipher(), GNUNET_MessageHeader::size, and udp_sock.

Referenced by setup_receiver_mq().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_destroy_d()

static void mq_destroy_d ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Signature of functions implementing the destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters

mq	the message queue to destroy
impl_state	our struct ReceiverAddress

Definition at line 3066 of file gnunet-communicator-udp.c.

{
  struct ReceiverAddress *receiver = impl_state;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Default MQ destroyed\n");
  if (mq == receiver->d_mq)
  {
    receiver->d_mq = NULL;
    if (GNUNET_YES != receiver->receiver_destroy_called)
      receiver_destroy (receiver);
  }
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_YES, mq, receiver(), and receiver_destroy().

Referenced by setup_receiver_mq().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_destroy_kx()

static void mq_destroy_kx ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Signature of functions implementing the destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters

mq	the message queue to destroy
impl_state	our struct ReceiverAddress

Definition at line 3089 of file gnunet-communicator-udp.c.

{
  struct ReceiverAddress *receiver = impl_state;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "KX MQ destroyed\n");
  if (mq == receiver->kx_mq)
  {
    receiver->kx_mq = NULL;
    if (GNUNET_YES != receiver->receiver_destroy_called)
      receiver_destroy (receiver);
  }
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_YES, mq, receiver(), and receiver_destroy().

Referenced by setup_receiver_mq().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_cancel()

static void mq_cancel ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Implementation function that cancels the currently sent message.

Parameters

mq	message queue
impl_state	our struct RecvierAddress

Definition at line 3110 of file gnunet-communicator-udp.c.

{
  /* Cancellation is impossible with UDP; bail */
  GNUNET_assert (0);
}

References GNUNET_assert.

Referenced by setup_receiver_mq().

Here is the caller graph for this function:

mq_error()

static void mq_error ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	our struct ReceiverAddress
error	error code

Definition at line 3127 of file gnunet-communicator-udp.c.

{
  struct ReceiverAddress *receiver = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "MQ error in queue to %s: %d\n",
              GNUNET_i2s (&receiver->target),
              (int) error);
  receiver_destroy (receiver);
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_log, receiver(), and receiver_destroy().

Referenced by setup_receiver_mq().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_init()

static int mq_init ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const char *  address  )

static

Function called by the transport service to initialize a message queue given address information about another peer.

If and when the communication channel is established, the communicator must call GNUNET_TRANSPORT_communicator_mq_add() to notify the service that the channel is now up. It is the responsibility of the communicator to manage sane retries and timeouts for any peer/address combination provided by the transport service. Timeouts and retries do not need to be signalled to the transport service.

Parameters

cls	closure
peer	identity of the other peer
address	where to send the message, human-readable communicator-specific format, 0-terminated, UTF-8

Returns

GNUNET_OK on success, GNUNET_SYSERR if the provided address is invalid

Definition at line 3239 of file gnunet-communicator-udp.c.

{
  struct ReceiverAddress *receiver;
  const char *path;
  struct sockaddr *in;
  socklen_t in_len;
 
  if (0 != strncmp (address,
                    COMMUNICATOR_ADDRESS_PREFIX "-",
                    strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
  in = udp_address_to_sockaddr (path, &in_len);
 
  receiver = GNUNET_new (struct ReceiverAddress);
  receiver->address = in;
  receiver->address_len = in_len;
  receiver->target = *peer;
  receiver->nt = GNUNET_NT_scanner_get_type (is, in, in_len);
  (void) GNUNET_CONTAINER_multipeermap_put (
    receivers,
    &receiver->target,
    receiver,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Added %s to receivers\n",
              GNUNET_i2s_full (&receiver->target));
  receiver->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  receiver->hn = GNUNET_CONTAINER_heap_insert (receivers_heap,
                                               receiver,
                                               receiver->timeout.abs_value_us);
  GNUNET_STATISTICS_set (stats,
                         "# receivers active",
                         GNUNET_CONTAINER_multipeermap_size (receivers),
                         GNUNET_NO);
  receiver->foreign_addr =
    sockaddr_to_udpaddr_string (receiver->address, receiver->address_len);
  setup_receiver_mq (receiver);
  if (NULL == timeout_task)
    timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL);
  return GNUNET_OK;
}

References address, check_timeouts(), COMMUNICATOR_ADDRESS_PREFIX, GNUNET_break_op, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s_full(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_NT_scanner_get_type(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_relative_to_absolute(), is, peer, receiver(), receivers, receivers_heap, setup_receiver_mq(), sockaddr_to_udpaddr_string(), stats, timeout_task, and udp_address_to_sockaddr().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

get_receiver_delete_it()

static int get_receiver_delete_it ( void *  cls, const struct GNUNET_PeerIdentity *  target, void *  value  )

static

Iterator over all receivers to clean up.

Parameters

cls	NULL
target	unused
value	the queue to destroy

Returns

GNUNET_OK to continue to iterate

Definition at line 3296 of file gnunet-communicator-udp.c.

{
  struct ReceiverAddress *receiver = value;
 
  (void) cls;
  (void) target;
  receiver_destroy (receiver);
  return GNUNET_OK;
}

References GNUNET_OK, receiver(), receiver_destroy(), ReceiverAddress::target, and value.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

get_sender_delete_it()

static int get_sender_delete_it ( void *  cls, const struct GNUNET_PeerIdentity *  target, void *  value  )

static

Iterator over all senders to clean up.

Parameters

cls	NULL
target	unused
value	the queue to destroy

Returns

GNUNET_OK to continue to iterate

Definition at line 3318 of file gnunet-communicator-udp.c.

{
  struct SenderAddress *sender = value;
 
  (void) cls;
  (void) target;
 
  if (NULL != sender->kce_task_rekey)
  {
    GNUNET_SCHEDULER_cancel (sender->kce_task_rekey);
    sender->kce_task_rekey = NULL;
  }
  if (NULL != sender->kce_task)
  {
    GNUNET_SCHEDULER_cancel (sender->kce_task);
    sender->kce_task = NULL;
  }
 
  sender_destroy (sender);
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_SCHEDULER_cancel(), SenderAddress::kce_task, SenderAddress::kce_task_rekey, sender_destroy(), SenderAddress::target, and value.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

do_shutdown()

static void do_shutdown ( void *  cls )

static

Shutdown the UNIX communicator.

Parameters

cls	NULL (always)

Definition at line 3349 of file gnunet-communicator-udp.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "do_shutdown\n");
  if (NULL != nat)
  {
    GNUNET_NAT_unregister (nat);
    nat = NULL;
  }
  while (NULL != bi_head)
    bi_destroy (bi_head);
  if (NULL != broadcast_task)
  {
    GNUNET_SCHEDULER_cancel (broadcast_task);
    broadcast_task = NULL;
  }
  if (NULL != timeout_task)
  {
    GNUNET_SCHEDULER_cancel (timeout_task);
    timeout_task = NULL;
  }
  if (NULL != read_task)
  {
    GNUNET_SCHEDULER_cancel (read_task);
    read_task = NULL;
  }
  if (NULL != udp_sock)
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_NETWORK_socket_close (udp_sock));
    udp_sock = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (receivers,
                                         &get_receiver_delete_it,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (receivers);
  GNUNET_CONTAINER_multipeermap_iterate (senders,
                                         &get_sender_delete_it,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (senders);
  GNUNET_CONTAINER_multishortmap_destroy (key_cache);
  GNUNET_CONTAINER_heap_destroy (senders_heap);
  GNUNET_CONTAINER_heap_destroy (receivers_heap);
  if (NULL != timeout_task)
  {
    GNUNET_SCHEDULER_cancel (timeout_task);
    timeout_task = NULL;
  }
  if (NULL != ch)
  {
    GNUNET_TRANSPORT_communicator_disconnect (ch);
    ch = NULL;
  }
  if (NULL != ah)
  {
    GNUNET_TRANSPORT_application_done (ah);
    ah = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
  if (NULL != my_private_key)
  {
    GNUNET_free (my_private_key);
    my_private_key = NULL;
  }
  if (NULL != is)
  {
    GNUNET_NT_scanner_done (is);
    is = NULL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "do_shutdown finished\n");
}

References ah, bi_destroy(), bi_head, broadcast_task, ch, get_receiver_delete_it(), get_sender_delete_it(), GNUNET_break, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NAT_unregister(), GNUNET_NETWORK_socket_close(), GNUNET_NO, GNUNET_NT_scanner_done(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_TRANSPORT_application_done(), GNUNET_TRANSPORT_communicator_disconnect(), is, key_cache, my_private_key, nat, read_task, receivers, receivers_heap, senders, senders_heap, stats, timeout_task, and udp_sock.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

enc_notify_cb()

static void enc_notify_cb ( void *  cls, const struct GNUNET_PeerIdentity *  sender, const struct GNUNET_MessageHeader *  msg  )

static

Function called when the transport service has received a backchannel message for this communicator (!) via a different return path.

Should be an acknowledgement.

Parameters

cls	closure, NULL
sender	which peer sent the notification
msg	payload

Definition at line 3437 of file gnunet-communicator-udp.c.

{
  const struct UDPAck *ack;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Storing UDPAck received from backchannel from %s\n",
              GNUNET_i2s_full (sender));
  if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK) ||
      (ntohs (msg->size) != sizeof(struct UDPAck)))
  {
    GNUNET_break_op (0);
    return;
  }
  ack = (const struct UDPAck *) msg;
  GNUNET_CONTAINER_multipeermap_get_multiple (receivers,
                                              sender,
                                              &handle_ack,
                                              (void *) ack);
}

References GNUNET_break_op, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s_full(), GNUNET_log, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK, handle_ack(), msg, receivers, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

nat_address_cb()

static void nat_address_cb ( void *  cls, void **  app_ctx, int  add_remove, enum GNUNET_NAT_AddressClass  ac, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of 'valid' addresses changes.

Parameters

cls	closure
app_ctx[in,out]	location where the app can store stuff on add and retrieve it on remove
add_remove	GNUNET_YES to add a new public IP address, GNUNET_NO to remove a previous (now invalid) one
ac	address class the address belongs to
addr	either the previous or the new public IP address
addrlen	actual length of the addr

Definition at line 3475 of file gnunet-communicator-udp.c.

{
  char *my_addr;
  struct GNUNET_TRANSPORT_AddressIdentifier *ai;
 
  if (GNUNET_YES == add_remove)
  {
    enum GNUNET_NetworkType nt;
 
    GNUNET_asprintf (&my_addr,
                     "%s-%s",
                     COMMUNICATOR_ADDRESS_PREFIX,
                     GNUNET_a2s (addr, addrlen));
    nt = GNUNET_NT_scanner_get_type (is, addr, addrlen);
    ai =
      GNUNET_TRANSPORT_communicator_address_add (ch,
                                                 my_addr,
                                                 nt,
                                                 GNUNET_TIME_UNIT_FOREVER_REL);
    GNUNET_free (my_addr);
    *app_ctx = ai;
  }
  else
  {
    ai = *app_ctx;
    GNUNET_TRANSPORT_communicator_address_remove (ai);
    *app_ctx = NULL;
  }
}

References ai, ch, COMMUNICATOR_ADDRESS_PREFIX, GNUNET_a2s(), GNUNET_asprintf(), GNUNET_free, GNUNET_NT_scanner_get_type(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_communicator_address_add(), GNUNET_TRANSPORT_communicator_address_remove(), GNUNET_YES, is, and nt.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

ifc_broadcast()

static void ifc_broadcast ( void *  cls )

static

Broadcast our presence on one of our interfaces.

Parameters

cls	a struct BroadcastInterface

Definition at line 3517 of file gnunet-communicator-udp.c.

{
  struct BroadcastInterface *bi = cls;
  struct GNUNET_TIME_Relative delay;
 
  delay = BROADCAST_FREQUENCY;
  delay.rel_value_us =
    GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, delay.rel_value_us);
  bi->broadcast_task =
    GNUNET_SCHEDULER_add_delayed (delay, &ifc_broadcast, bi);
 
  switch (bi->sa->sa_family)
  {
  case AF_INET: {
      static int yes = 1;
      static int no = 0;
      ssize_t sent;
 
      if (GNUNET_OK !=
          GNUNET_NETWORK_socket_setsockopt (udp_sock,
                                            SOL_SOCKET,
                                            SO_BROADCAST,
                                            &yes,
                                            sizeof(int)))
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                             "setsockopt");
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "creating UDPBroadcast from %s\n",
                  GNUNET_i2s (&(bi->bcm.sender)));
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "sending UDPBroadcast to add %s\n",
                  GNUNET_a2s (bi->ba, bi->salen));
      sent = GNUNET_NETWORK_socket_sendto (udp_sock,
                                           &bi->bcm,
                                           sizeof(bi->bcm),
                                           bi->ba,
                                           bi->salen);
      if (-1 == sent)
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                             "sendto");
      if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
                                                         SOL_SOCKET,
                                                         SO_BROADCAST,
                                                         &no,
                                                         sizeof(int)))
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                             "setsockopt");
      break;
    }
 
  case AF_INET6: {
      ssize_t sent;
      struct sockaddr_in6 dst;
 
      dst.sin6_family = AF_INET6;
      dst.sin6_port = htons (my_port);
      dst.sin6_addr = bi->mcreq.ipv6mr_multiaddr;
      dst.sin6_scope_id = ((struct sockaddr_in6 *) bi->ba)->sin6_scope_id;
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "sending UDPBroadcast\n");
      sent = GNUNET_NETWORK_socket_sendto (udp_sock,
                                           &bi->bcm,
                                           sizeof(bi->bcm),
                                           (const struct sockaddr *) &dst,
                                           sizeof(dst));
      if (-1 == sent)
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto");
      break;
    }
 
  default:
    GNUNET_break (0);
    break;
  }
}

References BroadcastInterface::ba, BroadcastInterface::bcm, BROADCAST_FREQUENCY, BroadcastInterface::broadcast_task, delay, GNUNET_a2s(), GNUNET_break, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_sendto(), GNUNET_NETWORK_socket_setsockopt(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), BroadcastInterface::mcreq, my_port, GNUNET_TIME_Relative::rel_value_us, BroadcastInterface::sa, BroadcastInterface::salen, UDPBroadcast::sender, and udp_sock.

Referenced by iface_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

iface_proc()

static int iface_proc ( void *  cls, const char *  name, int  isDefault, const struct sockaddr *  addr, const struct sockaddr *  broadcast_addr, const struct sockaddr *  netmask, socklen_t  addrlen  )

static

Callback function invoked for each interface found.

Activates/deactivates broadcast interfaces.

Parameters

cls	NULL
name	name of the interface (can be NULL for unknown)
isDefault	is this presumably the default interface
addr	address of this interface (can be NULL for unknown or unassigned)
broadcast_addr	the broadcast address (can be NULL for unknown or unassigned)
netmask	the network mask (can be NULL for unknown or unassigned)
addrlen	length of the address

Returns

GNUNET_OK to continue iteration, GNUNET_SYSERR to abort

Definition at line 3610 of file gnunet-communicator-udp.c.

{
  struct BroadcastInterface *bi;
  enum GNUNET_NetworkType network;
  struct UdpBroadcastSignature ubs;
 
  (void) cls;
  (void) netmask;
  if (NULL == addr)
    return GNUNET_YES; /* need to know our address! */
  network = GNUNET_NT_scanner_get_type (is, addr, addrlen);
  if (GNUNET_NT_LOOPBACK == network)
  {
    /* Broadcasting on loopback does not make sense */
    return GNUNET_YES;
  }
  for (bi = bi_head; NULL != bi; bi = bi->next)
  {
    if ((bi->salen == addrlen) && (0 == memcmp (addr, bi->sa, addrlen)))
    {
      bi->found = GNUNET_YES;
      return GNUNET_OK;
    }
  }
 
  if ((AF_INET6 == addr->sa_family) && (NULL == broadcast_addr))
    return GNUNET_OK; /* broadcast_addr is required for IPv6! */
  if ((AF_INET6 == addr->sa_family) && (GNUNET_YES != have_v6_socket))
    return GNUNET_OK; /* not using IPv6 */
 
  bi = GNUNET_new (struct BroadcastInterface);
  bi->sa = GNUNET_memdup (addr,
                          addrlen);
  if ( (NULL != broadcast_addr) &&
       (addrlen == sizeof (struct sockaddr_in)) )
  {
    struct sockaddr_in *ba;
 
    ba = GNUNET_memdup (broadcast_addr,
                        addrlen);
    ba->sin_port = htons (2086); /* always GNUnet port, ignore configuration! */
    bi->ba = (struct sockaddr *) ba;
  }
  bi->salen = addrlen;
  bi->found = GNUNET_YES;
  bi->bcm.sender = my_identity;
  ubs.purpose.purpose = htonl (
    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST);
  ubs.purpose.size = htonl (sizeof(ubs));
  ubs.sender = my_identity;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "creating UDPBroadcastSignature for %s\n",
              GNUNET_a2s (addr, addrlen));
  GNUNET_CRYPTO_hash (addr, addrlen, &ubs.h_address);
  GNUNET_CRYPTO_eddsa_sign (my_private_key,
                            &ubs,
                            &bi->bcm.sender_sig);
  if (NULL != bi->ba)
  {
    bi->broadcast_task = GNUNET_SCHEDULER_add_now (&ifc_broadcast, bi);
    GNUNET_CONTAINER_DLL_insert (bi_head, bi_tail, bi);
  }
  if ((AF_INET6 == addr->sa_family) && (NULL != broadcast_addr))
  {
    /* Create IPv6 multicast request */
    const struct sockaddr_in6 *s6 =
      (const struct sockaddr_in6 *) broadcast_addr;
 
    GNUNET_assert (
      1 == inet_pton (AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr));
 
    /* http://tools.ietf.org/html/rfc2553#section-5.2:
     *
     * IPV6_JOIN_GROUP
     *
     * Join a multicast group on a specified local interface.  If the
     * interface index is specified as 0, the kernel chooses the local
     * interface.  For example, some kernels look up the multicast
     * group in the normal IPv6 routing table and using the resulting
     * interface; we do this for each interface, so no need to use
     * zero (anymore...).
     */bi->mcreq.ipv6mr_interface = s6->sin6_scope_id;
 
    /* Join the multicast group */
    if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
                                                       IPPROTO_IPV6,
                                                       IPV6_JOIN_GROUP,
                                                       &bi->mcreq,
                                                       sizeof(bi->mcreq)))
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
    }
  }
  return GNUNET_OK;
}

References BroadcastInterface::ba, BroadcastInterface::bcm, bi_head, bi_tail, BroadcastInterface::broadcast_task, BroadcastInterface::found, GNUNET_a2s(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_eddsa_sign, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_memdup, GNUNET_NETWORK_socket_setsockopt(), GNUNET_new, GNUNET_NT_LOOPBACK, GNUNET_NT_scanner_get_type(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST, GNUNET_YES, UdpBroadcastSignature::h_address, have_v6_socket, ifc_broadcast(), is, BroadcastInterface::mcreq, my_identity, my_private_key, BroadcastInterface::next, GNUNET_CRYPTO_EccSignaturePurpose::purpose, UdpBroadcastSignature::purpose, BroadcastInterface::sa, BroadcastInterface::salen, UdpBroadcastSignature::sender, UDPBroadcast::sender, UDPBroadcast::sender_sig, GNUNET_CRYPTO_EccSignaturePurpose::size, and udp_sock.

Referenced by do_broadcast().

Here is the call graph for this function:

Here is the caller graph for this function:

do_broadcast()

static void do_broadcast ( void *  cls )

static

Scan interfaces to broadcast our presence on the LAN.

Parameters

cls	NULL, unused

Definition at line 3719 of file gnunet-communicator-udp.c.

{
  struct BroadcastInterface *bin;
 
  (void) cls;
  for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bi->next)
    bi->found = GNUNET_NO;
  GNUNET_OS_network_interfaces_list (&iface_proc, NULL);
  for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bin)
  {
    bin = bi->next;
    if (GNUNET_NO == bi->found)
      bi_destroy (bi);
  }
  broadcast_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_SCAN_FREQUENCY,
                                                 &do_broadcast,
                                                 NULL);
}

References bi_destroy(), bi_head, broadcast_task, BroadcastInterface::found, GNUNET_NO, GNUNET_OS_network_interfaces_list(), GNUNET_SCHEDULER_add_delayed(), iface_proc(), INTERFACE_SCAN_FREQUENCY, and BroadcastInterface::next.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

try_connection_reversal()

static void try_connection_reversal ( void *  cls, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Definition at line 3739 of file gnunet-communicator-udp.c.

{
  /* FIXME: support reversal: #5529 */
}

Referenced by run().

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  c  )

static

Setup communicator and launch network interactions.

Parameters

cls	NULL (always)
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
c	configuration

Definition at line 3755 of file gnunet-communicator-udp.c.

{
  char *bindto;
  struct sockaddr *in;
  socklen_t in_len;
  struct sockaddr_storage in_sto;
  socklen_t sto_len;
 
  (void) cls;
  cfg = c;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             COMMUNICATOR_CONFIG_SECTION,
                                             "BINDTO",
                                             &bindto))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               COMMUNICATOR_CONFIG_SECTION,
                               "BINDTO");
    return;
  }
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time (cfg,
                                           COMMUNICATOR_CONFIG_SECTION,
                                           "REKEY_INTERVAL",
                                           &rekey_interval))
    rekey_interval = DEFAULT_REKEY_TIME_INTERVAL;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_size (cfg,
                                           COMMUNICATOR_CONFIG_SECTION,
                                           "REKEY_MAX_BYTES",
                                           &rekey_max_bytes))
    rekey_max_bytes = DEFAULT_REKEY_MAX_BYTES;
 
  in = udp_address_to_sockaddr (bindto, &in_len);
  if (NULL == in)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup UDP socket address with path `%s'\n",
                bindto);
    GNUNET_free (bindto);
    return;
  }
  udp_sock =
    GNUNET_NETWORK_socket_create (in->sa_family,
                                  SOCK_DGRAM,
                                  IPPROTO_UDP);
  if (NULL == udp_sock)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
    GNUNET_free (in);
    GNUNET_free (bindto);
    return;
  }
  if (AF_INET6 == in->sa_family)
    have_v6_socket = GNUNET_YES;
  if (GNUNET_OK !=
      GNUNET_NETWORK_socket_bind (udp_sock,
                                  in,
                                  in_len))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "bind",
                              bindto);
    GNUNET_NETWORK_socket_close (udp_sock);
    udp_sock = NULL;
    GNUNET_free (in);
    GNUNET_free (bindto);
    return;
  }
 
  /* We might have bound to port 0, allowing the OS to figure it out;
     thus, get the real IN-address from the socket */
  sto_len = sizeof(in_sto);
  if (0 != getsockname (GNUNET_NETWORK_get_fd (udp_sock),
                        (struct sockaddr *) &in_sto,
                        &sto_len))
  {
    memcpy (&in_sto, in, in_len);
    sto_len = in_len;
  }
  GNUNET_free (in);
  GNUNET_free (bindto);
  in = (struct sockaddr *) &in_sto;
  in_len = sto_len;
  GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG,
                           "transport",
                           "Bound to `%s'\n",
                           GNUNET_a2s ((const struct sockaddr *) &in_sto,
                                       sto_len));
  switch (in->sa_family)
  {
  case AF_INET:
    my_port = ntohs (((struct sockaddr_in *) in)->sin_port);
    break;
 
  case AF_INET6:
    my_port = ntohs (((struct sockaddr_in6 *) in)->sin6_port);
    break;
 
  default:
    GNUNET_break (0);
    my_port = 0;
  }
  stats = GNUNET_STATISTICS_create ("C-UDP", cfg);
  senders = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
  receivers = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
  senders_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  receivers_heap =
    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  key_cache = GNUNET_CONTAINER_multishortmap_create (1024, GNUNET_YES);
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
  is = GNUNET_NT_scanner_init ();
  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
  if (NULL == my_private_key)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_ERROR,
      _ (
        "Transport service is lacking key configuration settings. Exiting.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
  /* start reading */
  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                             udp_sock,
                                             &sock_read,
                                             NULL);
  ch = GNUNET_TRANSPORT_communicator_connect (cfg,
                                              COMMUNICATOR_CONFIG_SECTION,
                                              COMMUNICATOR_ADDRESS_PREFIX,
                                              GNUNET_TRANSPORT_CC_UNRELIABLE,
                                              &mq_init,
                                              NULL,
                                              &enc_notify_cb,
                                              NULL);
  if (NULL == ch)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  ah = GNUNET_TRANSPORT_application_init (cfg);
  if (NULL == ah)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  /* start broadcasting */
  if (GNUNET_YES !=
      GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                            COMMUNICATOR_CONFIG_SECTION,
                                            "DISABLE_BROADCAST"))
  {
    broadcast_task = GNUNET_SCHEDULER_add_now (&do_broadcast, NULL);
  }
  nat = GNUNET_NAT_register (cfg,
                             COMMUNICATOR_CONFIG_SECTION,
                             IPPROTO_UDP,
                             1 /* one address */,
                             (const struct sockaddr **) &in,
                             &in_len,
                             &nat_address_cb,
                             try_connection_reversal,
                             NULL /* closure */);
}

References _, ah, broadcast_task, cfg, ch, COMMUNICATOR_ADDRESS_PREFIX, COMMUNICATOR_CONFIG_SECTION, DEFAULT_REKEY_MAX_BYTES, DEFAULT_REKEY_TIME_INTERVAL, do_broadcast(), do_shutdown(), enc_notify_cb(), GNUNET_a2s(), GNUNET_break, GNUNET_CONFIGURATION_get_value_size(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multishortmap_create(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_from_nocheck(), GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_NAT_register(), GNUNET_NETWORK_get_fd(), GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NT_scanner_init(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_application_init(), GNUNET_TRANSPORT_CC_UNRELIABLE, GNUNET_TRANSPORT_communicator_connect(), GNUNET_YES, have_v6_socket, is, key_cache, mq_init(), my_identity, my_port, my_private_key, nat, nat_address_cb(), GNUNET_PeerIdentity::public_key, read_task, receivers, receivers_heap, rekey_interval, rekey_max_bytes, senders, senders_heap, sock_read(), stats, try_connection_reversal(), udp_address_to_sockaddr(), and udp_sock.

Here is the call graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function for the UNIX communicator.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 3938 of file gnunet-communicator-udp.c.

{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
  int ret;
 
  GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG,
                           "transport",
                           "Starting udp communicator\n");
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
 
  ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
                                          argv,
                                          "gnunet-communicator-udp",
                                          _ ("GNUnet UDP communicator"),
                                          options,
                                          &run,
                                          NULL))
        ? 0
        : 1;
  GNUNET_free_nz ((void *) argv);
  return ret;
}

Variable Documentation

rekey_interval

struct GNUNET_TIME_Relative rekey_interval

static

The rekey interval.

Definition at line 384 of file gnunet-communicator-udp.c.

Referenced by check_for_rekeying(), and run().

rekey_max_bytes

unsigned long long rekey_max_bytes

static

How often we do rekey based on number of bytes transmitted.

Definition at line 786 of file gnunet-communicator-udp.c.

Referenced by check_for_rekeying(), and run().

ss_finished

struct SharedSecret* ss_finished

Shared secret we finished the last kce working queue for.

Definition at line 790 of file gnunet-communicator-udp.c.

Referenced by consider_ss_ack(), and kce_generate_cb().

key_cache

struct GNUNET_CONTAINER_MultiShortmap* key_cache

static

Cache of pre-generated key IDs.

Definition at line 795 of file gnunet-communicator-udp.c.

Referenced by do_shutdown(), kce_destroy(), kce_generate(), run(), secret_destroy(), and sock_read().

read_task

struct GNUNET_SCHEDULER_Task* read_task

static

ID of read task.

Definition at line 800 of file gnunet-communicator-udp.c.

Referenced by do_shutdown(), run(), and sock_read().

timeout_task

struct GNUNET_SCHEDULER_Task* timeout_task

static

ID of timeout task.

Definition at line 805 of file gnunet-communicator-udp.c.

Referenced by check_timeouts(), do_shutdown(), mq_init(), and setup_sender().