GNUnet debian-0.24.3-23-g589b01d60
gnunet-communicator-udp.c File Reference

Transport plugin using UDP. More...

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
 Plaintext of a rekey payload in a UDPBox. 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
 Closure for #find_sender_by_address() More...
 
struct  AckInfo
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "communicator-udp", __VA_ARGS__)
 
#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   64
 
#define KCN_THRESHOLD   96
 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   256
 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 eddsa_priv_to_hpke_key (struct GNUNET_CRYPTO_EddsaPrivateKey *edpk, struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
 
static void eddsa_pub_to_hpke_key (struct GNUNET_CRYPTO_EddsaPublicKey *edpk, struct GNUNET_CRYPTO_EcdhePublicKey *pk)
 
static void bi_destroy (struct BroadcastInterface *bi)
 An interface went away, stop broadcasting on it. More...
 
static int secret_destroy (struct SharedSecret *ss)
 Destroy ss and associated key cache entries. 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_ShortHashCode *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 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_ShortHashCode *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_ShortHashCode *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 uint8_t *tag, 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 SharedSecretsetup_shared_secret_dec (const struct GNUNET_CRYPTO_HpkeEncapsulation *ephemeral)
 Setup shared secret for decryption. More...
 
static struct SharedSecretsetup_initial_shared_secret_dec (const struct GNUNET_CRYPTO_HpkeEncapsulation *c)
 Setup shared secret for decryption for initial handshake. More...
 
static struct SharedSecretsetup_shared_secret_ephemeral (struct GNUNET_CRYPTO_HpkeEncapsulation *ephemeral, struct ReceiverAddress *receiver)
 Setup new shared secret for encryption using KEM. More...
 
static struct SharedSecretsetup_initial_shared_secret_ephemeral (struct GNUNET_CRYPTO_HpkeEncapsulation *c, struct ReceiverAddress *receiver)
 Setup new shared secret for encryption using KEM for initial handshake. More...
 
static void setup_receiver_mq (struct ReceiverAddress *receiver)
 Setup the MQ for the receiver. More...
 
static unsigned int purge_secrets (struct SharedSecret *ss_list_tail)
 Best effort try to purge some secrets. More...
 
static void add_acks (struct SharedSecret *ss, int acks_to_add)
 
static int handle_ack (void *cls, const struct GNUNET_HashCode *key, void *value)
 We received an ACK for pid. More...
 
static void consider_ss_ack (struct SharedSecret *ss)
 We established a shared secret with a sender. More...
 
static void kce_generate_cb (void *cls)
 
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 decrypt_box (const struct UDPBox *box, size_t box_len, struct KeyCacheEntry *kce)
 We received a box with matching kce. More...
 
static struct SenderAddresssetup_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_HpkeEncapsulation *enc, 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 struct GNUNET_NETWORK_Handleget_socket (struct ReceiverAddress *receiver)
 
static struct sockaddr * udp_address_to_sockaddr (const char *bindto, sa_family_t family, socklen_t *sock_len)
 Convert UDP bind specification to a struct sockaddr * More...
 
static void sock_read (void *cls)
 Socket read task. More...
 
static enum GNUNET_GenericReturnValue create_receiver (const struct GNUNET_PeerIdentity *peer, const char *address, struct GNUNET_NETWORK_Handle *udp_sock)
 
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 send_msg_with_kx (const struct GNUNET_MessageHeader *msg, struct ReceiverAddress *receiver, struct GNUNET_MQ_Handle *mq)
 
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 create_rekey (struct ReceiverAddress *receiver, struct SharedSecret *ss, struct UDPRekey *rekey)
 
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_HashCode *target, void *value)
 Iterator over all receivers to clean up. More...
 
static int get_sender_delete_it (void *cls, const struct GNUNET_HashCode *target, void *value)
 Iterator over all senders to clean up. More...
 
static void do_shutdown (void *cls)
 Shutdown the UNIX communicator. More...
 
static int handle_ack_by_sender (void *cls, const struct GNUNET_HashCode *key, void *value)
 
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 udp_socket_notify (struct GNUNET_UdpSocketInfo *sock_info)
 
static void start_burst (const char *addr, struct GNUNET_TIME_Relative rtt, struct GNUNET_PeerIdentity *pid)
 
static struct GNUNET_NETWORK_Handlecreate_udp_socket (const char *bindto, sa_family_t family, struct sockaddr **out, socklen_t *out_len)
 
static void shutdown_run (struct sockaddr *addrs[2])
 
static enum GNUNET_GenericReturnValue load_ikm ()
 FIXME: We could alternatively ask PILS for de/encaps, but at a high cost wrt async RPC calls... More...
 
void pid_change_cb (void *cls, const struct GNUNET_HELLO_Parser *parser, const struct GNUNET_HashCode *addr_hash)
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 

Variables

static unsigned char ikm [256/8]
 The initial key material for the peer. More...
 
static struct GNUNET_PILS_Handlepils
 For PILS. More...
 
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...
 
static struct GNUNET_CONTAINER_MultiShortmapkey_cache
 Cache of pre-generated key IDs. More...
 
static struct GNUNET_SCHEDULER_Taskread_v4_task
 ID of read IPv4 task. More...
 
static struct GNUNET_SCHEDULER_Taskread_v6_task
 ID of read IPv6 task. More...
 
static struct GNUNET_SCHEDULER_Tasktimeout_task
 ID of timeout task. More...
 
static struct GNUNET_SCHEDULER_Taskbroadcast_task
 ID of master broadcast task. More...
 
static struct GNUNET_STATISTICS_Handlestats
 For logging statistics. More...
 
static struct GNUNET_TRANSPORT_CommunicatorHandlech
 Our environment. More...
 
static struct GNUNET_CONTAINER_MultiHashMapreceivers
 Receivers (map from peer identity to struct ReceiverAddress) More...
 
static struct GNUNET_CONTAINER_MultiHashMapsenders
 Senders (map from peer identity to struct SenderAddress) More...
 
static struct GNUNET_CONTAINER_Heapsenders_heap
 Expiration heap for senders (contains struct SenderAddress) More...
 
static struct GNUNET_CONTAINER_Heapreceivers_heap
 Expiration heap for receivers (contains struct ReceiverAddress) More...
 
static struct BroadcastInterfacebi_head
 Broadcast interface tasks. More...
 
static struct BroadcastInterfacebi_tail
 Broadcast interface tasks. More...
 
static struct GNUNET_NETWORK_Handledefault_v4_sock
 Our IPv4 socket. More...
 
static struct GNUNET_NETWORK_Handledefault_v6_sock
 Our IPv6 socket. More...
 
static struct GNUNET_PeerIdentity my_identity
 Our public key. More...
 
static struct GNUNET_CRYPTO_EddsaPrivateKeymy_private_key
 Our private key. More...
 
static struct GNUNET_CRYPTO_EcdhePrivateKey my_x25519_private_key
 Our private key for HPKE. More...
 
static const struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration. More...
 
static struct GNUNET_TRANSPORT_ApplicationHandleah
 Our handle to report addresses for validation to TRANSPORT. More...
 
static struct GNUNET_NT_InterfaceScanneris
 Network scanner to determine network types. More...
 
static struct GNUNET_NAT_Handlenat
 Connection to NAT service. More...
 
static uint16_t my_port
 Port number to which we are actually bound. More...
 
char * my_ipv4
 Our ipv4 address. More...
 
static int disable_v6
 IPv6 disabled or not. More...
 
static struct GNUNET_SCHEDULER_Taskburst_task
 

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

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "communicator-udp", __VA_ARGS__)

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

◆ 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 58 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 63 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 68 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 73 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 80 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 82 of file gnunet-communicator-udp.c.

◆ AES_KEY_SIZE

#define AES_KEY_SIZE   (256 / 8)

AES key size.

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

◆ AES_IV_SIZE

#define AES_IV_SIZE   (96 / 8)

AES (GCM) IV size.

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

◆ GCM_TAG_SIZE

#define GCM_TAG_SIZE   (128 / 8)

Size of the GCM tag.

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

◆ GENERATE_AT_ONCE

#define GENERATE_AT_ONCE   64

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

◆ KCN_THRESHOLD

#define KCN_THRESHOLD   96

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 111 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 119 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 130 of file gnunet-communicator-udp.c.

◆ MAX_SECRETS

#define MAX_SECRETS   256

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 141 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 147 of file gnunet-communicator-udp.c.

◆ COMMUNICATOR_ADDRESS_PREFIX

#define COMMUNICATOR_ADDRESS_PREFIX   "udp"

Address prefix used by the communicator.

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

◆ COMMUNICATOR_CONFIG_SECTION

#define COMMUNICATOR_CONFIG_SECTION   "communicator-udp"

Configuration section used by the communicator.

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

Function Documentation

◆ eddsa_priv_to_hpke_key()

static void eddsa_priv_to_hpke_key ( struct GNUNET_CRYPTO_EddsaPrivateKey edpk,
struct GNUNET_CRYPTO_EcdhePrivateKey pk 
)
static

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

909{
911 key.type = htonl (GNUNET_PUBLIC_KEY_TYPE_EDDSA);
912 key.eddsa_key = *edpk;
914}
struct GNUNET_HashCode key
The key used in the DHT.
struct GNUNET_CRYPTO_PrivateKey pk
Private key from command line option, or NULL.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hpke_sk_to_x25519(const struct GNUNET_CRYPTO_PrivateKey *sk, struct GNUNET_CRYPTO_EcdhePrivateKey *x25519)
Convert a GNUnet identity key to a key sutiable for HPKE (X25519)
Definition: crypto_hpke.c:832
@ GNUNET_PUBLIC_KEY_TYPE_EDDSA
EDDSA identity.
A private key for an identity as per LSD0001.

References GNUNET_CRYPTO_hpke_sk_to_x25519(), GNUNET_PUBLIC_KEY_TYPE_EDDSA, key, and pk.

Referenced by pid_change_cb().

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

◆ eddsa_pub_to_hpke_key()

static void eddsa_pub_to_hpke_key ( struct GNUNET_CRYPTO_EddsaPublicKey edpk,
struct GNUNET_CRYPTO_EcdhePublicKey pk 
)
static

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

920{
922 key.type = htonl (GNUNET_PUBLIC_KEY_TYPE_EDDSA);
923 key.eddsa_key = *edpk;
925}
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hpke_pk_to_x25519(const struct GNUNET_CRYPTO_PublicKey *pk, struct GNUNET_CRYPTO_EcdhePublicKey *x25519)
Convert a GNUnet identity key to a key sutiable for HPKE (X25519)
Definition: crypto_hpke.c:808
An identity key as per LSD0001.

References GNUNET_CRYPTO_hpke_pk_to_x25519(), GNUNET_PUBLIC_KEY_TYPE_EDDSA, key, and pk.

Referenced by create_receiver().

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

◆ bi_destroy()

static void bi_destroy ( struct BroadcastInterface bi)
static

An interface went away, stop broadcasting on it.

Parameters
bientity to close down

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

935{
936 if (AF_INET6 == bi->sa->sa_family)
937 {
938 /* Leave the multicast group */
940 IPPROTO_IPV6,
941 IPV6_LEAVE_GROUP,
942 &bi->mcreq,
943 sizeof(bi->mcreq)))
944 {
946 }
947 }
950 GNUNET_free (bi->sa);
951 GNUNET_free (bi->ba);
952 GNUNET_free (bi);
953}
static struct BroadcastInterface * bi_tail
Broadcast interface tasks.
static struct BroadcastInterface * bi_head
Broadcast interface tasks.
static struct GNUNET_NETWORK_Handle * default_v6_sock
Our IPv6 socket.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
@ GNUNET_OK
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
#define GNUNET_free(ptr)
Wrapper around free.
int GNUNET_NETWORK_socket_setsockopt(struct GNUNET_NETWORK_Handle *fd, int level, int option_name, const void *option_value, socklen_t option_len)
Set socket option.
Definition: network.c:806
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:980
struct ipv6_mreq mcreq
If this is an IPv6 interface, this is the request we use to join/leave the group.
struct sockaddr * ba
Broadcast address to use on the interface.
struct GNUNET_SCHEDULER_Task * broadcast_task
Task for this broadcast interface.
struct sockaddr * sa
Sender's address of the interface.

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

Referenced by do_broadcast(), and do_shutdown().

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

Destroy ss and associated key cache entries.

Parameters
ssshared secret to destroy
withoutKceIf GNUNET_YES shared secrets with kce will not be destroyed.

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

1100{
1101 struct SenderAddress *sender;
1102 struct ReceiverAddress *receiver;
1103 struct KeyCacheEntry *kce;
1104
1106 "secret %s destroy %u\n",
1107 GNUNET_sh2s (&ss->master),
1109 if (NULL != (sender = ss->sender))
1110 {
1111 GNUNET_CONTAINER_DLL_remove (sender->ss_head, sender->ss_tail, ss);
1112 sender->num_secrets--;
1114 "%u sender->num_secrets %u allowed %u used, %u available\n",
1116 sender->acks_available);
1118 if (NULL != ss->sender->kce_task)
1119 {
1121 ss->sender->kce_task = NULL;
1122 }
1123 }
1124 if (NULL != (receiver = ss->receiver))
1125 {
1126 GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
1127 receiver->num_secrets--;
1128 receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used);
1130 "%u receiver->num_secrets\n",
1131 receiver->num_secrets);
1132 }
1133 while (NULL != (kce = ss->kce_head))
1134 kce_destroy (kce);
1135 GNUNET_STATISTICS_update (stats, "# Secrets active", -1, GNUNET_NO);
1137 "# KIDs active",
1139 GNUNET_NO);
1140 GNUNET_free (ss);
1141 return GNUNET_YES;
1142}
static void kce_destroy(struct KeyCacheEntry *kce)
Free memory used by key cache entry.
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
static struct GNUNET_CONTAINER_MultiShortmap * key_cache
Cache of pre-generated key IDs.
unsigned int GNUNET_CONTAINER_multishortmap_size(const struct GNUNET_CONTAINER_MultiShortmap *map)
Get the number of key-value pairs in the map.
#define GNUNET_log(kind,...)
@ GNUNET_YES
@ GNUNET_NO
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:330
Pre-generated "kid" code (key and IV identification code) to quickly derive master key for a struct U...
struct SharedSecret * ss
Corresponding shared secret.
Information we track per receiving address we have recently been in contact with (encryption to recei...
Information we track per sender address we have recently been in contact with (we decrypt messages fr...
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this sender.
unsigned int num_secrets
Length of the DLL at ss_head.
struct GNUNET_SCHEDULER_Task * kce_task
ID of kce working queue task.
struct SharedSecret * ss_head
Shared secrets we used with target, first used is head.
struct SharedSecret * ss_tail
Shared secrets we used with target, last used is tail.
uint32_t sequence_allowed
Up to which sequence number did the other peer allow us to use this key, or up to which number did we...
uint32_t sequence_used
Up to which sequence number did we use this master already? (for encrypting only)
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
struct KeyCacheEntry * kce_head
Kept in a DLL, sorted by sequence number.
struct ReceiverAddress * receiver
Receiver we use this shared secret with, or NULL.
struct GNUNET_ShortHashCode master
Master shared secret.

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

Referenced by decrypt_box(), mq_send_d(), purge_secrets(), receiver_destroy(), send_msg_with_kx(), sender_destroy(), sock_read(), and try_handle_plaintext().

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
receiverentity to close down

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

966{
967 struct SharedSecret *ss;
968 receiver->receiver_destroy_called = GNUNET_YES;
969
971 "Disconnecting receiver for peer `%s'\n",
972 GNUNET_i2s (&receiver->target));
973 if (NULL != receiver->kx_qh)
974 {
976 receiver->kx_qh = NULL;
977 receiver->kx_mq = NULL;
978 }
979 if (NULL != receiver->d_qh)
980 {
982 receiver->d_qh = NULL;
983 }
984 else if (NULL != receiver->d_mq)
985 {
987 receiver->d_mq = NULL;
988 }
989 if (NULL != receiver->udp_sock)
990 {
993 receiver->udp_sock = NULL;
994 }
997 &receiver->key,
998 receiver));
1001 "# receivers active",
1003 GNUNET_NO);
1004 while (NULL != (ss = receiver->ss_head))
1005 {
1006 secret_destroy (ss);
1007 }
1008 GNUNET_free (receiver->address);
1009 GNUNET_free (receiver->foreign_addr);
1011}
static int secret_destroy(struct SharedSecret *ss)
Destroy ss and associated key cache entries.
static struct GNUNET_CONTAINER_MultiHashMap * receivers
Receivers (map from peer identity to struct ReceiverAddress)
void GNUNET_TRANSPORT_communicator_mq_del(struct GNUNET_TRANSPORT_QueueHandle *qh)
Notify transport service that an MQ became unavailable due to a disconnect or timeout.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:700
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:508
Shared secret we generated for a particular sender or receiver.

References GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_destroy(), GNUNET_NETWORK_socket_close(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), GNUNET_TRANSPORT_communicator_mq_del(), GNUNET_YES, receiver(), receivers, secret_destroy(), and stats.

Referenced by check_timeouts(), get_receiver_delete_it(), mq_destroy_d(), mq_destroy_kx(), mq_error(), mq_send_d(), and send_msg_with_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
kcethe key cache entry

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

1021{
1022 struct SharedSecret *ss = kce->ss;
1023
1024 ss->active_kce_count--;
1027 &kce->kid,
1028 kce));
1029 GNUNET_free (kce);
1030}
int GNUNET_CONTAINER_multishortmap_remove(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, const void *value)
Remove the given key-value pair from the map.
struct GNUNET_ShortHashCode kid
Key and IV identification code.
struct KeyCacheEntry * kce_tail
Kept in a DLL, sorted by sequence number.
unsigned int active_kce_count
Number of active KCN entries.

References 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, and KeyCacheEntry::ss.

Referenced by consider_ss_ack(), decrypt_box(), 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_ShortHashCode msec,
uint32_t  serial,
struct GNUNET_ShortHashCode kid 
)
static

Compute kid.

Parameters
msecmaster secret for HMAC calculation
serialnumber for the smac calculation
[out]kidwhere to write the key ID

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

1044{
1045 uint32_t sid = htonl (serial);
1046 struct GNUNET_ShortHashCode prk;
1048 &sid, sizeof (sid),
1049 msec, sizeof (*msec));
1050
1052 sizeof(*kid),
1053 &prk,
1054 "gnunet-communicator-udp-kid",
1055 strlen ("gnunet-communicator-udp-kid"),
1056 NULL,
1057 0);
1058}
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf_extract(struct GNUNET_ShortHashCode *prk, const void *salt, size_t salt_len, const void *ikm, size_t ikm_len)
HKDF-Extract using SHA256.
Definition: crypto_hkdf.c:224
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf_expand(void *result, size_t out_len, const struct GNUNET_ShortHashCode *prk,...)
HKDF-Expand using SHA256.
Definition: crypto_hkdf.c:156
A 256-bit hashcode.

References GNUNET_CRYPTO_hkdf_expand(), and GNUNET_CRYPTO_hkdf_extract().

Referenced by kce_generate(), and mq_send_d().

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
ssshared secret
seqsequence number for the key cache entry

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

1069{
1070 struct KeyCacheEntry *kce;
1071
1072 GNUNET_assert (0 < seq);
1073 kce = GNUNET_new (struct KeyCacheEntry);
1074 kce->ss = ss;
1075 kce->sequence_number = seq;
1076 get_kid (&ss->master, seq, &kce->kid);
1081 key_cache,
1082 &kce->kid,
1083 kce,
1086 "# KIDs active",
1088 GNUNET_NO);
1089}
static void get_kid(const struct GNUNET_ShortHashCode *msec, uint32_t serial, struct GNUNET_ShortHashCode *kid)
Compute kid.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multishortmap_put(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint32_t sequence_number
Sequence number used to derive this entry from master key.

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 kce_generate_cb().

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
senderentity to close down

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

1153{
1154 struct SharedSecret *ss;
1157 GNUNET_YES ==
1161 "# senders active",
1163 GNUNET_NO);
1164 while (NULL != (ss = sender->ss_head))
1165 {
1166 secret_destroy (ss);
1167 }
1170}
static struct GNUNET_CONTAINER_MultiHashMap * senders
Senders (map from peer identity to struct SenderAddress)
struct GNUNET_CONTAINER_HeapNode * hn
Entry in sender expiration heap.
struct sockaddr * address
Address of the other peer.
struct GNUNET_HashCode key
The address key for this entry.
int sender_destroy_called
sender_destroy already called on sender.

References SenderAddress::address, GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_YES, SenderAddress::hn, SenderAddress::key, secret_destroy(), SharedSecret::sender, SenderAddress::sender_destroy_called, senders, SenderAddress::ss_head, and stats.

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_ShortHashCode msec,
uint32_t  serial,
char  key[(256/8)],
char  iv[(96/8)] 
)
static

Compute key and iv.

Parameters
msecmaster secret for calculation
serialnumber for the smac calculation
[out]keywhere to write the decryption key
[out]ivwhere to write the IV

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

1186{
1187 uint32_t sid = htonl (serial);
1188
1191 msec,
1192 "gnunet-communicator-udp-key",
1193 strlen ("gnunet-communicator-udp-key"),
1194 &sid, sizeof (sid),
1195 NULL,
1196 0);
1199 msec,
1200 "gnunet-communicator-udp-iv",
1201 strlen ("gnunet-communicator-udp-iv"),
1202 &sid, sizeof (sid),
1203 NULL,
1204 0);
1205}
#define AES_KEY_SIZE
AES key size.
#define AES_IV_SIZE
AES (GCM) IV size.

References AES_IV_SIZE, AES_KEY_SIZE, GNUNET_CRYPTO_hkdf_expand(), and key.

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
senderaddress for which the timeout should be rescheduled

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

1215{
1216 sender->timeout =
1219}
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don't receive messages from the peer?
void GNUNET_CONTAINER_heap_update_cost(struct GNUNET_CONTAINER_HeapNode *node, GNUNET_CONTAINER_HeapCostType new_cost)
Updates the cost of any node in the tree.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
uint64_t abs_value_us
The actual value.
struct GNUNET_TIME_Absolute timeout
Timeout for this sender.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_update_cost(), GNUNET_TIME_relative_to_absolute(), SenderAddress::hn, SharedSecret::sender, 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
receiveraddress for which the timeout should be rescheduled

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

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

Referenced by mq_send_d(), and send_msg_with_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
clsunused, NULL

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

1244{
1245 struct GNUNET_TIME_Relative st;
1246 struct GNUNET_TIME_Relative rt;
1247 struct GNUNET_TIME_Relative delay;
1248 struct ReceiverAddress *receiver;
1249 struct SenderAddress *sender;
1250
1251 (void) cls;
1252 timeout_task = NULL;
1255 {
1257 if (0 != rt.rel_value_us)
1258 break;
1260 "Receiver timed out\n");
1262 }
1264 while (NULL != (sender = GNUNET_CONTAINER_heap_peek (senders_heap)))
1265 {
1266 if (GNUNET_YES != sender->sender_destroy_called)
1267 {
1269 if (0 != st.rel_value_us)
1270 break;
1271 sender_destroy (sender);
1272 }
1273 }
1274 delay = GNUNET_TIME_relative_min (rt, st);
1275 if (delay.rel_value_us < GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
1277}
static struct GNUNET_CONTAINER_Heap * senders_heap
Expiration heap for senders (contains struct SenderAddress)
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.
static void receiver_destroy(struct ReceiverAddress *receiver)
Destroys a receiving state due to timeout or shutdown.
static struct GNUNET_CONTAINER_Heap * receivers_heap
Expiration heap for receivers (contains struct ReceiverAddress)
static void check_timeouts(void *cls)
Task run to check #receiver_heap and #sender_heap for timeouts.
static struct GNUNET_SCHEDULER_Task * timeout_task
ID of timeout task.
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1277
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:344
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:406
Time for relative time used by GNUnet, in microseconds.

References check_timeouts(), 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 check_timeouts(), create_receiver(), 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]ssdata structure to complete

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

1287{
1289 sizeof(ss->cmac),
1290 &ss->master,
1291 "gnunet-communicator-udp-cmac",
1292 strlen ("gnunet-communicator-udp-cmac"),
1293 NULL,
1294 0);
1295}
struct GNUNET_HashCode cmac
CMAC is used to identify master in ACKs.

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

Referenced by setup_initial_shared_secret_dec(), setup_initial_shared_secret_ephemeral(), setup_shared_secret_dec(), setup_shared_secret_ephemeral(), 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
queuethe queue that received the plaintext
plaintextthe plaintext that was received
plaintext_lennumber of bytes of plaintext received

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

1310{
1311 const struct GNUNET_MessageHeader *hdr = plaintext;
1312 const char *pos = plaintext;
1313
1314 while (ntohs (hdr->size) <= plaintext_len)
1315 {
1317 "# bytes given to core",
1318 ntohs (hdr->size),
1319 GNUNET_NO);
1321 "Giving %u bytes to TNG\n", ntohs (hdr->size));
1324 &sender->target,
1325 hdr,
1327 NULL /* no flow control possible */
1328 ,
1329 NULL));
1330 /* move on to next message, if any */
1331 plaintext_len -= ntohs (hdr->size);
1332 if (plaintext_len < sizeof(*hdr))
1333 break;
1334 pos += ntohs (hdr->size);
1335 hdr = (const struct GNUNET_MessageHeader *) pos;
1336 // TODO for now..., we do not actually sen >1msg or have a way of telling
1337 // if we are done
1338 break;
1339 }
1341 "# bytes padding discarded",
1342 plaintext_len,
1343 GNUNET_NO);
1344}
#define ADDRESS_VALIDITY_PERIOD
How long do we believe our addresses to remain up (before the other peer should revalidate).
static struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Our environment.
int GNUNET_TRANSPORT_communicator_receive(struct GNUNET_TRANSPORT_CommunicatorHandle *handle, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg, struct GNUNET_TIME_Relative expected_addr_validity, GNUNET_TRANSPORT_MessageCompletedCallback cb, void *cb_cls)
Notify transport service that the communicator has received a message.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_SYSERR
Header for all communications.
struct GNUNET_PeerIdentity target
To whom are we talking to.

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_ShortHashCode msec,
uint32_t  serial,
gcry_cipher_hd_t *  cipher 
)
static

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

Parameters
msecmaster shared secret
serialserial number of cipher to set up
cipher[out]cipher to initialize

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

1359{
1360 char key[AES_KEY_SIZE];
1361 char iv[AES_IV_SIZE];
1362 int rc;
1363
1364 GNUNET_assert (0 ==
1365 gcry_cipher_open (cipher,
1366 GCRY_CIPHER_AES256 /* low level: go for speed */
1367 ,
1368 GCRY_CIPHER_MODE_GCM,
1369 0 /* flags */));
1370 get_iv_key (msec, serial, key, iv);
1371 rc = gcry_cipher_setkey (*cipher, key, sizeof(key));
1372 GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
1373 rc = gcry_cipher_setiv (*cipher, iv, sizeof(iv));
1374 GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
1375}
static void get_iv_key(const struct GNUNET_ShortHashCode *msec, uint32_t serial, char key[(256/8)], char iv[(96/8)])
Compute key and iv.

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

Referenced by mq_send_d(), send_msg_with_kx(), 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 uint8_t *  tag,
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
ssshared secret
tagGCM authentication tag
serialserial number to use
in_bufinput buffer to decrypt
in_buf_sizenumber of bytes in in_buf and available in out_buf
out_bufwhere to write the result
Returns
GNUNET_OK on success

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

1397{
1398 gcry_cipher_hd_t cipher;
1399
1400 setup_cipher (&ss->master, serial, &cipher);
1402 0 ==
1403 gcry_cipher_decrypt (cipher, out_buf, in_buf_size, in_buf, in_buf_size));
1404 if (0 != gcry_cipher_checktag (cipher, tag, GCM_TAG_SIZE))
1405 {
1406 gcry_cipher_close (cipher);
1408 "# AEAD authentication failures",
1409 1,
1410 GNUNET_NO);
1411 return GNUNET_SYSERR;
1412 }
1413 gcry_cipher_close (cipher);
1414 return GNUNET_OK;
1415}
#define GCM_TAG_SIZE
Size of the GCM tag.
static void setup_cipher(const struct GNUNET_ShortHashCode *msec, uint32_t serial, gcry_cipher_hd_t *cipher)
Setup cipher based on shared secret msec and serial number serial.

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(), 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_HpkeEncapsulation ephemeral)
static

Setup shared secret for decryption.

Parameters
ephemeralephemeral key we received from the other peer
Returns
new shared secret

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

1427{
1428 struct SharedSecret *ss;
1429
1430 ss = GNUNET_new (struct SharedSecret);
1432 calculate_cmac (ss);
1433 return ss;
1434}
static void calculate_cmac(struct SharedSecret *ss)
Calculate cmac from master in ss.
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Our private key.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_kem_decaps(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_HpkeEncapsulation *c, struct GNUNET_ShortHashCode *prk)
Decapsulate a key for a private EdDSA key.
Definition: crypto_hpke.c:285

References calculate_cmac(), GNUNET_CRYPTO_eddsa_kem_decaps(), GNUNET_new, SharedSecret::master, and my_private_key.

Referenced by try_handle_plaintext().

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

◆ setup_initial_shared_secret_dec()

static struct SharedSecret * setup_initial_shared_secret_dec ( const struct GNUNET_CRYPTO_HpkeEncapsulation c)
static

Setup shared secret for decryption for initial handshake.

Parameters
representativeof ephemeral key we received from the other peer
Returns
new shared secret

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

1446{
1447 struct SharedSecret *ss;
1448
1449 ss = GNUNET_new (struct SharedSecret);
1451 &ss->master);
1453 "New receiver SS master: %s\n", GNUNET_sh2s (&ss->master));
1454 calculate_cmac (ss);
1455 return ss;
1456}
static struct GNUNET_CRYPTO_EcdhePrivateKey my_x25519_private_key
Our private key for HPKE.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hpke_elligator_kem_decaps(const struct GNUNET_CRYPTO_EcdhePrivateKey *skR, const struct GNUNET_CRYPTO_HpkeEncapsulation *c, struct GNUNET_ShortHashCode *shared_secret)
Carries out ecdh decapsulation with own private key and the representative of the received public key...
Definition: crypto_hpke.c:348

References calculate_cmac(), GNUNET_CRYPTO_hpke_elligator_kem_decaps(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_sh2s(), SharedSecret::master, and my_x25519_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_ephemeral()

static struct SharedSecret * setup_shared_secret_ephemeral ( struct GNUNET_CRYPTO_HpkeEncapsulation ephemeral,
struct ReceiverAddress receiver 
)
static

Setup new shared secret for encryption using KEM.

Parameters
[out]ephemeralephemeral key to be sent to other peer (encapsulated key from KEM)
[in,out]receiverqueue to initialize encryption key for
Returns
new shared secret

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

1470{
1471 struct SharedSecret *ss;
1472
1473 ss = GNUNET_new (struct SharedSecret);
1474 GNUNET_CRYPTO_eddsa_kem_encaps (&receiver->target.public_key, ephemeral,
1475 &ss->master);
1476 calculate_cmac (ss);
1477 ss->receiver = receiver;
1478 GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
1479 receiver->num_secrets++;
1480 GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
1481 return ss;
1482}
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_kem_encaps(const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_CRYPTO_HpkeEncapsulation *c, struct GNUNET_ShortHashCode *prk)
Encapsulate key material for a EdDSA public key.
Definition: crypto_hpke.c:233

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

Referenced by create_rekey().

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

◆ setup_initial_shared_secret_ephemeral()

static struct SharedSecret * setup_initial_shared_secret_ephemeral ( struct GNUNET_CRYPTO_HpkeEncapsulation c,
struct ReceiverAddress receiver 
)
static

Setup new shared secret for encryption using KEM for initial handshake.

Parameters
[out]representativeof ephemeral key to be sent to other peer (encapsulated key from KEM)
[in,out]receiverqueue to initialize encryption key for
Returns
new shared secret

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

1496{
1497 struct SharedSecret *ss;
1498
1499 ss = GNUNET_new (struct SharedSecret);
1501 c, &ss->master);
1503 "New sender SS master: %s\n", GNUNET_sh2s (&ss->master));
1504 calculate_cmac (ss);
1505 ss->receiver = receiver;
1506 GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
1507 receiver->num_secrets++;
1508 GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
1509 return ss;
1510}
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hpke_elligator_kem_encaps(const struct GNUNET_CRYPTO_EcdhePublicKey *pkR, struct GNUNET_CRYPTO_HpkeEncapsulation *c, struct GNUNET_ShortHashCode *shared_secret)
Carries out ecdh encapsulation with given public key and the private key from a freshly created ephem...
Definition: crypto_hpke.c:327

References calculate_cmac(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_hpke_elligator_kem_encaps(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_sh2s(), GNUNET_STATISTICS_update(), SharedSecret::master, receiver(), SharedSecret::receiver, and stats.

Referenced by send_msg_with_kx().

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
receiverreceiver to setup MQ for

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

3014{
3015 size_t base_mtu;
3016
3017 switch (receiver->address->sa_family)
3018 {
3019 case AF_INET:
3020 base_mtu = 1480 /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */
3021 - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */
3022 - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
3023 break;
3024
3025 case AF_INET6:
3026 base_mtu = 1280 /* Minimum MTU required by IPv6 */
3027 - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */
3028 - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
3029 break;
3030
3031 default:
3032 GNUNET_assert (0);
3033 break;
3034 }
3035 /* MTU based on full KX messages */
3036 receiver->kx_mtu = base_mtu - sizeof(struct InitialKX) /* 48 */
3037 - sizeof(struct UDPConfirmation); /* 104 */
3038 /* MTU based on BOXed messages */
3039 receiver->d_mtu = base_mtu - sizeof(struct UDPBox);
3040
3042 "Setting up MQs and QHs\n");
3043 /* => Effective MTU for CORE will range from 1080 (IPv6 + KX) to
3044 1404 (IPv4 + Box) bytes, depending on circumstances... */
3045 if (NULL == receiver->kx_mq)
3048 &mq_cancel,
3049 receiver,
3050 NULL,
3051 &mq_error,
3052 receiver);
3053 if (NULL == receiver->d_mq)
3055 &mq_destroy_d,
3056 &mq_cancel,
3057 receiver,
3058 NULL,
3059 &mq_error,
3060 receiver);
3061
3062 receiver->kx_qh =
3064 &receiver->target,
3065 receiver->foreign_addr,
3066 receiver->kx_mtu,
3068 0, /* Priority */
3069 receiver->nt,
3071 receiver->kx_mq);
3072}
static void mq_destroy_d(struct GNUNET_MQ_Handle *mq, void *impl_state)
Signature of functions implementing the destruction of a message queue.
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.
static void mq_destroy_kx(struct GNUNET_MQ_Handle *mq, void *impl_state)
Signature of functions implementing the destruction of a message queue.
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.
static void mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
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 c...
#define GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED
Queue length.
struct GNUNET_TRANSPORT_QueueHandle * GNUNET_TRANSPORT_communicator_mq_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *peer, const char *address, uint32_t mtu, uint64_t q_len, uint32_t priority, enum GNUNET_NetworkType nt, enum GNUNET_TRANSPORT_ConnectionStatus cs, struct GNUNET_MQ_Handle *mq)
Notify transport service that a MQ became available due to an "inbound" connection or because the com...
@ GNUNET_TRANSPORT_CS_OUTBOUND
this is an outbound connection (transport initiated)
struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)
Create a message queue for the specified handlers.
Definition: mq.c:482
Standard IPv4 header.
Standard IPv6 header.
UDP packet header.
"Plaintext" header at beginning of KX message.
UDP message box.
Encrypted continuation of UDP initial handshake, followed by message header with payload.

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 create_receiver().

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

◆ purge_secrets()

static unsigned int purge_secrets ( struct SharedSecret ss_list_tail)
static

Best effort try to purge some secrets.

Ideally those, not ACKed.

Parameters
ss_list_tailthe oldest secret in the list of interest.
Returns
number of deleted secrets.

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

1533{
1534 struct SharedSecret *pos;
1535 struct SharedSecret *ss_to_purge;
1536 unsigned int deleted = 0;
1537
1539 "Purging secrets.\n");
1540 pos = ss_list_tail;
1541 while (NULL != pos)
1542 {
1543 ss_to_purge = pos;
1544 pos = pos->prev;
1545
1546 // FIXME we may also want to purge old unacked.
1547 if (rekey_max_bytes <= ss_to_purge->bytes_sent)
1548 {
1549 secret_destroy (ss_to_purge);
1550 deleted++;
1551 }
1552 }
1554 "Finished purging all, deleted %u.\n", deleted);
1555 return deleted;
1556}
size_t bytes_sent
Bytes sent with this shared secret.
struct SharedSecret * prev
Kept in a DLL.

References SharedSecret::bytes_sent, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, SharedSecret::prev, and secret_destroy().

Referenced by mq_send_d(), send_msg_with_kx(), sock_read(), and try_handle_plaintext().

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 1560 of file gnunet-communicator-udp.c.

1561{
1562
1563 struct ReceiverAddress *receiver = ss->receiver;
1564
1565 GNUNET_assert (NULL != ss);
1566 GNUNET_assert (NULL != receiver);
1567
1568 if (NULL == receiver->d_qh)
1569 {
1570 receiver->d_qh =
1572 &receiver->target,
1573 receiver->foreign_addr,
1574 receiver->d_mtu,
1575 acks_to_add,
1576 1, /* Priority */
1577 receiver->nt,
1579 receiver->d_mq);
1580 }
1581 else
1582 {
1584 receiver->d_qh,
1585 acks_to_add,
1586 1);
1587 }
1588
1590 "Tell transport we have %u more acks!\n",
1591 acks_to_add);
1592
1593 // Until here for alternative 1
1594
1595 /* move ss to head to avoid discarding it anytime soon! */
1596
1597 // GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
1598 // GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
1599}
void GNUNET_TRANSPORT_communicator_mq_update(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_TRANSPORT_QueueHandle *u_qh, uint64_t q_len, uint32_t priority)
Notify transport service that an MQ was updated.

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

Referenced by handle_ack().

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_HashCode key,
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
clsa const struct UDPAck
pidpeer the ACK is from
valuea struct ReceiverAddress
Returns
GNUNET_YES to continue to iterate

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

1614{
1615 const struct UDPAck *ack = cls;
1616 struct ReceiverAddress *receiver = value;
1617 uint32_t acks_to_add;
1618 uint32_t allowed;
1619
1621 "in handle ack with cmac %s\n",
1622 GNUNET_h2s (&ack->cmac));
1623
1624 (void) key;
1625 for (struct SharedSecret *ss = receiver->ss_head; NULL != ss; ss = ss->next)
1626 {
1627 if (0 == memcmp (&ack->cmac, &ss->cmac, sizeof(struct GNUNET_HashCode)))
1628 {
1629
1631 "Found matching cmac\n");
1632
1633 allowed = ntohl (ack->sequence_ack);
1634
1635 if (allowed <= ss->sequence_allowed)
1636 {
1638 "Ignoring ack, not giving us increased window\n.");
1639 return GNUNET_NO;
1640 }
1641 acks_to_add = (allowed - ss->sequence_allowed);
1642 GNUNET_assert (0 != acks_to_add);
1643 receiver->acks_available += (allowed - ss->sequence_allowed);
1644 ss->sequence_allowed = allowed;
1645 add_acks (ss, acks_to_add);
1647 "New sequence allows until %u (+%u). Acks available to us: %u. For secret %s\n",
1648 allowed,
1649 acks_to_add,
1650 receiver->acks_available,
1651 GNUNET_sh2s (&ss->master));
1652 return GNUNET_NO;
1653 }
1654 }
1656 "Matching cmac not found for ack!\n");
1657 return GNUNET_YES;
1658}
static void add_acks(struct SharedSecret *ss, int acks_to_add)
static char * value
Value of the record to add/remove.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
A 512-bit hashcode.
UDP key acknowledgement.
uint32_t sequence_ack
Sequence acknowledgement limit.
struct GNUNET_HashCode cmac
CMAC of the base key being acknowledged.

References add_acks(), UDPAck::cmac, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_sh2s(), GNUNET_YES, key, receiver(), UDPAck::sequence_ack, and value.

Referenced by handle_ack_by_sender(), and try_handle_plaintext().

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)
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
ssshared secret to generate ACKs for

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

1671{
1672 struct UDPAck ack;
1673 GNUNET_assert (NULL != ss->sender);
1675 "Considering SS UDPAck %s\n",
1676 GNUNET_i2s_full (&ss->sender->target));
1677
1679 "Sender has %u acks available.\n",
1680 ss->sender->acks_available);
1681 /* drop ancient KeyCacheEntries */
1682 while ((NULL != ss->kce_head) &&
1683 (MAX_SQN_DELTA <
1685 kce_destroy (ss->kce_tail);
1686
1687
1688 ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK);
1689 ack.header.size = htons (sizeof(ack));
1690 ack.sequence_ack = htonl (ss->sequence_allowed);
1691 ack.cmac = ss->cmac;
1693 "Notifying transport with UDPAck %s, sequence %u and master %s\n",
1695 ss->sequence_allowed,
1696 GNUNET_sh2s (&(ss->master)));
1698 &ss->sender->target,
1700 &ack.header);
1701}
#define COMMUNICATOR_ADDRESS_PREFIX
Address prefix used by the communicator.
#define MAX_SQN_DELTA
What is the maximum delta between KCN sequence numbers that we allow.
void GNUNET_TRANSPORT_communicator_notify(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *pid, const char *comm, const struct GNUNET_MessageHeader *header)
The communicator asks the transport service to route a message via a different path to another commun...
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK
UDP KX acknowledgement.

References SenderAddress::acks_available, ch, UDPAck::cmac, SharedSecret::cmac, COMMUNICATOR_ADDRESS_PREFIX, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s_full(), GNUNET_log, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK, GNUNET_sh2s(), GNUNET_TRANSPORT_communicator_notify(), UDPAck::header, kce_destroy(), SharedSecret::kce_head, SharedSecret::kce_tail, SharedSecret::master, MAX_SQN_DELTA, SharedSecret::sender, UDPAck::sequence_ack, SharedSecret::sequence_allowed, KeyCacheEntry::sequence_number, GNUNET_MessageHeader::size, SenderAddress::target, and GNUNET_MessageHeader::type.

Referenced by kce_generate_cb().

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

As long as we loose over 30% of max acks in reschedule, We keep generating acks for this ss.

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

1706{
1707 struct SharedSecret *ss = cls;
1708 ss->sender->kce_task = NULL;
1709
1711 "Precomputing %u keys for master %s\n",
1713 GNUNET_sh2s (&ss->master));
1714 if ((ss->override_available_acks != GNUNET_YES) &&
1715 (KCN_TARGET < ss->sender->acks_available))
1716 return;
1717 for (int i = 0; i < GENERATE_AT_ONCE; i++)
1718 kce_generate (ss, ++ss->sequence_allowed);
1719
1724 if (KCN_TARGET > ss->sender->acks_available)
1725 {
1729 ss);
1730 return;
1731 }
1733 "We have enough keys (ACKs: %u).\n", ss->sender->acks_available);
1737 consider_ss_ack (ss);
1738}
#define WORKING_QUEUE_INTERVALL
static void kce_generate(struct SharedSecret *ss, uint32_t seq)
Setup key cache entry for sequence number seq and shared secret ss.
#define GENERATE_AT_ONCE
static void kce_generate_cb(void *cls)
#define KCN_TARGET
How many KCNs do we keep around after we hit the KCN_THRESHOLD? Should be larger than KCN_THRESHOLD s...
static void consider_ss_ack(struct SharedSecret *ss)
We established a shared secret with a sender.
int kce_send_ack_on_finish
When KCE finishes, send ACK if GNUNET_YES.
int kce_task_finished
Is the kce_task finished?
int override_available_acks
Also precompute keys despite sufficient acks (for rekey)

References SenderAddress::acks_available, consider_ss_ack(), GENERATE_AT_ONCE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_sh2s(), GNUNET_YES, kce_generate(), kce_generate_cb(), SenderAddress::kce_send_ack_on_finish, SenderAddress::kce_task, SenderAddress::kce_task_finished, KCN_TARGET, SharedSecret::master, SharedSecret::override_available_acks, SharedSecret::sender, SharedSecret::sequence_allowed, and WORKING_QUEUE_INTERVALL.

Referenced by decrypt_box(), kce_generate_cb(), sock_read(), 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
senderpeer to process inbound plaintext for
bufbuffer we received
buf_sizenumber of bytes in buf

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

1753{
1754 const struct GNUNET_MessageHeader *hdr;
1755 const struct UDPAck *ack;
1756 const struct UDPRekey *rekey;
1757 struct SharedSecret *ss_rekey;
1758 const char *buf_pos = buf;
1759 size_t bytes_remaining = buf_size;
1760 uint16_t type;
1761
1762 hdr = (struct GNUNET_MessageHeader*) buf_pos;
1763 if (sizeof(*hdr) > bytes_remaining)
1764 {
1765 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Plaintext too short, dropping...\n");
1766 return; /* no data left */
1767 }
1769 "try_handle_plaintext of size %llu (%u %lu) and type %u\n",
1770 (unsigned long long) bytes_remaining,
1771 ntohs (hdr->size),
1772 sizeof(*hdr),
1773 ntohs (hdr->type));
1774 if (ntohs (hdr->size) > bytes_remaining)
1775 return; /* buffer too short for indicated message length */
1776 type = ntohs (hdr->type);
1777 switch (type)
1778 {
1780 rekey = (struct UDPRekey*) buf_pos;
1781 ss_rekey = setup_shared_secret_dec (&rekey->ephemeral);
1782 ss_rekey->sender = sender;
1783 GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss_rekey);
1784 sender->num_secrets++;
1786 "Received rekey secret with cmac %s\n",
1787 GNUNET_h2s (&(ss_rekey->cmac)));
1789 "Received secret with master %s.\n",
1790 GNUNET_sh2s (&(ss_rekey->master)));
1792 "We have %u sequence_allowed.\n",
1793 ss_rekey->sequence_allowed);
1795 "We have a sender %p\n",
1796 ss_rekey->sender);
1798 "We have %u acks available.\n",
1799 ss_rekey->sender->acks_available);
1801 "# rekeying successful",
1802 1,
1803 GNUNET_NO);
1806 // FIXME
1807 kce_generate_cb (ss_rekey);
1808 /* ss_rekey->sender->kce_task = GNUNET_SCHEDULER_add_delayed (
1809 WORKING_QUEUE_INTERVALL,
1810 kce_generate_cb,
1811 ss_rekey);*/
1812 // FIXME: Theoretically, this could be an Ack
1813 buf_pos += ntohs (hdr->size);
1814 bytes_remaining -= ntohs (hdr->size);
1815 pass_plaintext_to_core (sender, buf_pos, bytes_remaining);
1816 if (0 == purge_secrets (sender->ss_tail))
1817 {
1818 // No secret purged. Delete oldest.
1819 if (sender->num_secrets > MAX_SECRETS)
1820 {
1821 secret_destroy (sender->ss_tail);
1822 }
1823 }
1824 break;
1826 /* lookup master secret by 'cmac', then update sequence_max */
1827 ack = (struct UDPAck*) buf_pos;
1829 &sender->key,
1830 &handle_ack,
1831 (void *) ack);
1832 /* There could be more messages after the ACK, handle those as well */
1833 buf_pos += ntohs (hdr->size);
1834 bytes_remaining -= ntohs (hdr->size);
1835 pass_plaintext_to_core (sender, buf_pos, bytes_remaining);
1836 break;
1837
1839 /* skip padding */
1840 break;
1841
1842 default:
1843 pass_plaintext_to_core (sender, buf_pos, bytes_remaining);
1844 }
1845 return;
1846}
static int handle_ack(void *cls, const struct GNUNET_HashCode *key, void *value)
We received an ACK for pid.
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.
static struct SharedSecret * setup_shared_secret_dec(const struct GNUNET_CRYPTO_HpkeEncapsulation *ephemeral)
Setup shared secret for decryption.
#define MAX_SECRETS
How many shared master secrets do we keep around at most per sender? Should be large enough so that w...
static unsigned int purge_secrets(struct SharedSecret *ss_list_tail)
Best effort try to purge some secrets.
static uint32_t type
Type string converted to DNS type value.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY
UDP Rekey.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD
UDP communicator padding.
Plaintext of a rekey payload in a UDPBox.
struct GNUNET_CRYPTO_HpkeEncapsulation ephemeral
Ephemeral key to rekey with.

References SenderAddress::acks_available, SharedSecret::cmac, UDPRekey::ephemeral, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY, GNUNET_NO, GNUNET_sh2s(), GNUNET_STATISTICS_update(), GNUNET_YES, handle_ack(), kce_generate_cb(), SenderAddress::kce_send_ack_on_finish, SenderAddress::key, SharedSecret::master, MAX_SECRETS, SenderAddress::num_secrets, SharedSecret::override_available_acks, pass_plaintext_to_core(), purge_secrets(), receivers, secret_destroy(), SharedSecret::sender, SharedSecret::sequence_allowed, setup_shared_secret_dec(), GNUNET_MessageHeader::size, SenderAddress::ss_head, SenderAddress::ss_tail, stats, type, and GNUNET_MessageHeader::type.

Referenced by decrypt_box(), 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
boxthe data we received
box_lennumber of bytes in box
kcekey index to decrypt box

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

1860{
1861 struct SharedSecret *ss = kce->ss;
1862 struct SharedSecret *ss_c = ss->sender->ss_tail;
1863 struct SharedSecret *ss_tmp;
1864 int ss_destroyed = 0;
1865 char out_buf[box_len - sizeof(*box)];
1866
1867 GNUNET_assert (NULL != ss->sender);
1868 if (GNUNET_OK != try_decrypt (ss,
1869 box->gcm_tag,
1870 kce->sequence_number,
1871 (const char *) &box[1],
1872 sizeof(out_buf),
1873 out_buf))
1874 {
1875 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed decryption.\n");
1877 "# Decryption failures with valid KCE",
1878 1,
1879 GNUNET_NO);
1880 kce_destroy (kce);
1881 ss->sender->acks_available--;
1882 return;
1883 }
1884 kce_destroy (kce);
1885 kce = NULL;
1886 ss->bytes_sent += box_len;
1887 ss->sender->acks_available--;
1888 ss->sequence_used++;
1890 "# bytes decrypted with BOX",
1891 sizeof(out_buf),
1892 GNUNET_NO);
1894 "# messages decrypted with BOX",
1895 1,
1896 GNUNET_NO);
1898 "decrypted UDPBox with kid %s\n",
1899 GNUNET_sh2s (&box->kid));
1900 try_handle_plaintext (ss->sender, out_buf, sizeof(out_buf));
1901
1902 while (NULL != ss_c)
1903 {
1904 if (ss_c->bytes_sent >= rekey_max_bytes)
1905 {
1907 "Removing SS because rekey bytes reached.\n");
1908 ss_tmp = ss_c->prev;
1909 if (ss == ss_c)
1910 ss_destroyed = 1;
1911 secret_destroy (ss_c);
1912 ss_c = ss_tmp;
1913 continue;
1914 }
1915 ss_c = ss_c->prev;
1916 }
1917 if (1 == ss_destroyed)
1918 return;
1920 "Sender has %u ack left.\n",
1921 ss->sender->acks_available);
1922 if ((KCN_THRESHOLD > ss->sender->acks_available) &&
1923 (NULL == ss->sender->kce_task) &&
1925 {
1927 "Sender has %u ack left which is under threshold.\n",
1928 ss->sender->acks_available);
1932 ss);
1933 }
1934}
static int try_decrypt(const struct SharedSecret *ss, const uint8_t *tag, 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.
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.
#define KCN_THRESHOLD
If we fall below this number of available KCNs, we generate additional ACKs until we reach KCN_TARGET...
static unsigned long long rekey_max_bytes
How often we do rekey based on number of bytes transmitted.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1304
uint8_t gcm_tag[(128/8)]
128-bit authentication tag for the following encrypted message, from GCM.

References SenderAddress::acks_available, SharedSecret::bytes_sent, UDPBox::gcm_tag, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_sh2s(), GNUNET_STATISTICS_update(), GNUNET_YES, kce_destroy(), kce_generate_cb(), SenderAddress::kce_send_ack_on_finish, SenderAddress::kce_task, SenderAddress::kce_task_finished, KCN_THRESHOLD, UDPBox::kid, SharedSecret::prev, rekey_max_bytes, secret_destroy(), SharedSecret::sender, KeyCacheEntry::sequence_number, SharedSecret::sequence_used, KeyCacheEntry::ss, SenderAddress::ss_tail, 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:

◆ 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
targetpeer to generate address for
addresstarget address
address_lennumber of bytes in address
Returns
data structure to keep track of key material for decrypting data from target

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

1974{
1975 struct SenderAddress *sender;
1976 struct GNUNET_HashContext *hsh;
1977 struct GNUNET_HashCode sender_key;
1978
1980 GNUNET_CRYPTO_hash_context_read (hsh, address, address_len);
1981 GNUNET_CRYPTO_hash_context_read (hsh, target, sizeof(*target));
1982 GNUNET_CRYPTO_hash_context_finish (hsh, &sender_key);
1983
1984 sender = GNUNET_CONTAINER_multihashmap_get (senders, &sender_key);
1985 if (NULL != sender)
1986 {
1988 return sender;
1989 }
1990 sender = GNUNET_new (struct SenderAddress);
1991 sender->key = sender_key;
1992 sender->target = *target;
1993 sender->address = GNUNET_memdup (address, address_len);
1994 sender->address_len = address_len;
1996 senders,
1997 &sender->key,
1998 sender,
2001 "# senders active",
2003 GNUNET_NO);
2004 sender->timeout =
2007 sender,
2008 sender->timeout.abs_value_us);
2009 sender->nt = GNUNET_NT_scanner_get_type (is, address, address_len);
2010 if (NULL == timeout_task)
2012 return sender;
2013}
static struct GNUNET_NT_InterfaceScanner * is
Network scanner to determine network types.
static void reschedule_sender_timeout(struct SenderAddress *sender)
Increment sender timeout due to activity.
static char * address
GNS address for this phone.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_HeapNode * GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap, void *element, GNUNET_CONTAINER_HeapCostType cost)
Inserts a new element into the heap.
void GNUNET_CRYPTO_hash_context_read(struct GNUNET_HashContext *hc, const void *buf, size_t size)
Add data to be hashed.
Definition: crypto_hash.c:363
void GNUNET_CRYPTO_hash_context_finish(struct GNUNET_HashContext *hc, struct GNUNET_HashCode *r_hash)
Finish the hash computation.
Definition: crypto_hash.c:387
struct GNUNET_HashContext * GNUNET_CRYPTO_hash_context_start(void)
Start incremental hashing operation.
Definition: crypto_hash.c:347
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
enum GNUNET_NetworkType GNUNET_NT_scanner_get_type(struct GNUNET_NT_InterfaceScanner *is, const struct sockaddr *addr, socklen_t addrlen)
Returns where the address is located: loopback, LAN or WAN.
Definition: nt.c:309
socklen_t address_len
Length of the address.
enum GNUNET_NetworkType nt
Which network type does this queue use?

References GNUNET_TIME_Absolute::abs_value_us, address, SenderAddress::address, SenderAddress::address_len, check_timeouts(), GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), 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::key, SenderAddress::nt, receivers, reschedule_sender_timeout(), 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_HpkeEncapsulation enc,
const struct UDPConfirmation uc 
)
static

Check signature from uc against ephemeral.

Parameters
ephemeralkey that is signed
ucsignature of claimant
Returns
GNUNET_OK if signature is valid

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

2026{
2027 struct UdpHandshakeSignature uhs;
2028
2029 uhs.purpose.purpose = htonl (
2031 uhs.purpose.size = htonl (sizeof(uhs));
2032 uhs.sender = uc->sender;
2033 uhs.receiver = my_identity;
2034 uhs.enc = *enc;
2035 uhs.monotonic_time = uc->monotonic_time;
2038 &uhs,
2039 &uc->sender_sig,
2040 &uc->sender.public_key);
2041}
static struct GNUNET_PeerIdentity my_identity
Our public key.
static OpusEncoder * enc
OPUS encoder.
static struct GNUNET_FS_UnindexContext * uc
#define GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE
Signature used by UDP communicator handshake.
#define GNUNET_CRYPTO_eddsa_verify(purp, ps, sig, pub)
Verify EdDSA signature.
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
Signature we use to verify that the ephemeral key was really chosen by the specified sender.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose must be GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE.

References enc, UdpHandshakeSignature::enc, 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
addressthe address to convert, must be AF_INET or AF_INET6.
address_lennumber of bytes in address
Returns
string representation of address

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

2055{
2056 char *ret;
2057
2058 switch (address->sa_family)
2059 {
2060 case AF_INET:
2062 "%s-%s",
2064 GNUNET_a2s (address, address_len));
2065 break;
2066
2067 case AF_INET6:
2069 "%s-%s",
2071 GNUNET_a2s (address, address_len));
2072 break;
2073
2074 default:
2075 GNUNET_assert (0);
2076 }
2077 return ret;
2078}
static int ret
Final status code.
Definition: gnunet-arm.c:93
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages).
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.

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

Referenced by create_receiver(), sock_read(), and udp_socket_notify().

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

◆ get_socket()

static struct GNUNET_NETWORK_Handle * get_socket ( struct ReceiverAddress receiver)
static

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

2083{
2085
2086 if (NULL == receiver->udp_sock)
2087 {
2088 if (AF_INET6 == receiver->address->sa_family)
2090 else
2092 }
2093 else
2094 udp_sock = receiver->udp_sock;
2095
2096 return udp_sock;
2097}
static struct GNUNET_NETWORK_Handle * udp_sock
Our socket.
static struct GNUNET_NETWORK_Handle * default_v4_sock
Our IPv4 socket.
handle to a socket
Definition: network.c:53

References default_v4_sock, default_v6_sock, receiver(), and udp_sock.

Referenced by mq_send_d(), and send_msg_with_kx().

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,
sa_family_t  family,
socklen_t *  sock_len 
)
static

Convert UDP bind specification to a struct sockaddr *

Parameters
bindtobind specification to convert
familyaddress family to enforce
[out]sock_lenset to the length of the address
Returns
converted bindto specification

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

2112{
2113 struct sockaddr *in;
2114 unsigned int port;
2115 char dummy[2];
2116 char *colon;
2117 char *cp;
2118
2119 if (1 == sscanf (bindto, "%u%1s", &port, dummy))
2120 {
2121 /* interpreting value as just a PORT number */
2122 if (port > UINT16_MAX)
2123 {
2125 "BINDTO specification `%s' invalid: value too large for port\n",
2126 bindto);
2127 return NULL;
2128 }
2129 if ((AF_INET == family) || (GNUNET_YES == disable_v6))
2130 {
2131 struct sockaddr_in *i4;
2132
2133 i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
2134 i4->sin_family = AF_INET;
2135 i4->sin_port = htons ((uint16_t) port);
2136 *sock_len = sizeof(struct sockaddr_in);
2137 in = (struct sockaddr *) i4;
2138 }
2139 else
2140 {
2141 struct sockaddr_in6 *i6;
2142
2143 i6 = GNUNET_malloc (sizeof(struct sockaddr_in6));
2144 i6->sin6_family = AF_INET6;
2145 i6->sin6_port = htons ((uint16_t) port);
2146 *sock_len = sizeof(struct sockaddr_in6);
2147 in = (struct sockaddr *) i6;
2148 }
2149 return in;
2150 }
2151 cp = GNUNET_strdup (bindto);
2152 colon = strrchr (cp, ':');
2153 if (NULL != colon)
2154 {
2155 /* interpret value after colon as port */
2156 *colon = '\0';
2157 colon++;
2158 if (1 == sscanf (colon, "%u%1s", &port, dummy))
2159 {
2160 /* interpreting value as just a PORT number */
2161 if (port > UINT16_MAX)
2162 {
2164 "BINDTO specification `%s' invalid: value too large for port\n",
2165 bindto);
2166 GNUNET_free (cp);
2167 return NULL;
2168 }
2169 }
2170 else
2171 {
2172 GNUNET_log (
2174 "BINDTO specification `%s' invalid: last ':' not followed by number\n",
2175 bindto);
2176 GNUNET_free (cp);
2177 return NULL;
2178 }
2179 }
2180 else
2181 {
2182 /* interpret missing port as 0, aka pick any free one */
2183 port = 0;
2184 }
2185 if (AF_INET6 != family)
2186 {
2187 /* try IPv4 */
2188 struct sockaddr_in v4;
2189
2190 memset (&v4, 0, sizeof(v4));
2191 if (1 == inet_pton (AF_INET, cp, &v4.sin_addr))
2192 {
2193 v4.sin_family = AF_INET;
2194 v4.sin_port = htons ((uint16_t) port);
2195#if HAVE_SOCKADDR_IN_SIN_LEN
2196 v4.sin_len = sizeof(struct sockaddr_in);
2197#endif
2198 in = GNUNET_memdup (&v4, sizeof(struct sockaddr_in));
2199 *sock_len = sizeof(struct sockaddr_in);
2200 GNUNET_free (cp);
2201 return in;
2202 }
2203 }
2204 if (AF_INET != family)
2205 {
2206 /* try IPv6 */
2207 struct sockaddr_in6 v6;
2208 const char *start;
2209
2210 memset (&v6, 0, sizeof(v6));
2211 start = cp;
2212 if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
2213 {
2214 start++; /* skip over '[' */
2215 cp[strlen (cp) - 1] = '\0'; /* eat ']' */
2216 }
2217 if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
2218 {
2219 v6.sin6_family = AF_INET6;
2220 v6.sin6_port = htons ((uint16_t) port);
2221#if HAVE_SOCKADDR_IN_SIN_LEN
2222 v6.sin6_len = sizeof(struct sockaddr_in6);
2223#endif
2224 in = GNUNET_memdup (&v6, sizeof(v6));
2225 *sock_len = sizeof(v6);
2226 GNUNET_free (cp);
2227 return in;
2228 }
2229 }
2230 /* #5528 FIXME (feature!): maybe also try getnameinfo()? */
2231 GNUNET_free (cp);
2232 return NULL;
2233}
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:38
static uint16_t port
Port number.
Definition: gnunet-bcd.c:146
static int disable_v6
IPv6 disabled or not.
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_malloc(size)
Wrapper around malloc.

References disable_v6, dummy, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memdup, GNUNET_strdup, GNUNET_YES, port, and start.

Referenced by create_receiver(), and create_udp_socket().

Here is the caller graph for this function:

◆ sock_read()

static void sock_read ( void *  cls)
static

Socket read task.

Parameters
clsNULL

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

2350{
2351 struct sockaddr_storage sa;
2352 struct sockaddr_in *addr_verify;
2353 socklen_t salen = sizeof(sa);
2354 char buf[UINT16_MAX];
2355 ssize_t rcvd;
2356
2357 struct GNUNET_NETWORK_Handle *udp_sock = cls;
2358
2361 udp_sock,
2362 &sock_read,
2363 udp_sock);
2366 udp_sock,
2367 &sock_read,
2368 udp_sock);
2369 while (1)
2370 {
2372 buf,
2373 sizeof(buf),
2374 (struct sockaddr *) &sa,
2375 &salen);
2376 if (-1 == rcvd)
2377 {
2378 struct sockaddr *addr = (struct sockaddr*) &sa;
2379
2380 if (EAGAIN == errno)
2381 break; // We are done reading data
2383 "Failed to recv from %s family %d failed sock %p\n",
2384 GNUNET_a2s ((struct sockaddr*) &sa,
2385 sizeof (*addr)),
2386 addr->sa_family,
2387 udp_sock);
2389 return;
2390 }
2392 "Read %llu bytes\n",
2393 (unsigned long long) rcvd);
2394 if (0 == rcvd)
2395 {
2396 GNUNET_break_op (0);
2398 "Read 0 bytes from UDP socket\n");
2399 return;
2400 }
2401
2402 /* first, see if it is a GNUNET_BurstMessage */
2403 if (rcvd == sizeof (struct GNUNET_BurstMessage))
2404 {
2405 struct GNUNET_BurstMessage *bm = (struct GNUNET_BurstMessage *) buf;
2406 struct sockaddr *addr = (struct sockaddr*) &sa;
2407 char *address = sockaddr_to_udpaddr_string (addr, sizeof (*addr));
2408
2409 GNUNET_assert (0 == bm->local_port);
2411 "Received a burst message for default port\n");
2412 create_receiver (&bm->peer,
2413 address,
2414 NULL);
2415 if (AF_INET6 == addr->sa_family)
2417 else
2421 return;
2422 }
2423 /* second, see if it is a UDPBox */
2424 if (rcvd > sizeof(struct UDPBox))
2425 {
2426 const struct UDPBox *box;
2427 struct KeyCacheEntry *kce;
2428
2429 box = (const struct UDPBox *) buf;
2431 if (NULL != kce)
2432 {
2434 "Found KCE with kid %s\n",
2435 GNUNET_sh2s (&box->kid));
2436 decrypt_box (box, (size_t) rcvd, kce);
2437 continue;
2438 }
2439 }
2440
2441 /* next, check if it is a broadcast */
2442 if (sizeof(struct UDPBroadcast) == rcvd)
2443 {
2444 const struct UDPBroadcast *ub;
2445 struct UdpBroadcastSignature uhs;
2446 struct GNUNET_PeerIdentity sender;
2447
2448 addr_verify = GNUNET_memdup (&sa, salen);
2449 addr_verify->sin_port = 0;
2451 "received UDPBroadcast from %s\n",
2452 GNUNET_a2s ((const struct sockaddr *) addr_verify, salen));
2453 ub = (const struct UDPBroadcast *) buf;
2454 uhs.purpose.purpose = htonl (
2456 uhs.purpose.size = htonl (sizeof(uhs));
2457 uhs.sender = ub->sender;
2458 sender = ub->sender;
2459 if (0 == memcmp (&sender, &my_identity, sizeof (struct
2461 {
2463 "Received our own broadcast\n");
2464 GNUNET_free (addr_verify);
2465 continue;
2466 }
2468 "checking UDPBroadcastSignature for %s\n",
2469 GNUNET_i2s (&sender));
2470 GNUNET_CRYPTO_hash ((struct sockaddr *) addr_verify, salen,
2471 &uhs.h_address);
2472 if (GNUNET_OK ==
2475 &uhs,
2476 &ub->sender_sig,
2477 &ub->sender.public_key))
2478 {
2479 char *addr_s;
2481
2482 addr_s =
2483 sockaddr_to_udpaddr_string ((const struct sockaddr *) &sa, salen);
2484 GNUNET_STATISTICS_update (stats, "# broadcasts received", 1, GNUNET_NO);
2485 /* use our own mechanism to determine network type */
2486 nt =
2487 GNUNET_NT_scanner_get_type (is, (const struct sockaddr *) &sa, salen);
2489 "validating address %s received from UDPBroadcast\n",
2490 GNUNET_i2s (&sender));
2492 GNUNET_free (addr_s);
2493 GNUNET_free (addr_verify);
2494 continue;
2495 }
2496 else
2497 {
2499 "VerifyingPeer %s is verifying UDPBroadcast\n",
2502 "Verifying UDPBroadcast from %s failed\n",
2503 GNUNET_i2s (&ub->sender));
2504 }
2505 GNUNET_free (addr_verify);
2506 /* continue with KX, mostly for statistics... */
2507 }
2508
2509
2510 /* finally, test if it is a KX */
2511 if (rcvd < sizeof(struct UDPConfirmation) + sizeof(struct InitialKX))
2512 {
2514 "# messages dropped (no kid, too small for KX)",
2515 1,
2516 GNUNET_NO);
2517 continue;
2518 }
2520 "Got KX\n");
2521 {
2522 const struct InitialKX *kx;
2523 struct SharedSecret *ss;
2524 char pbuf[rcvd - sizeof(struct InitialKX)];
2525 const struct UDPConfirmation *uc;
2526 struct SenderAddress *sender;
2527
2528 kx = (const struct InitialKX *) buf;
2531 "Before DEC\n");
2532
2533 if (GNUNET_OK != try_decrypt (ss,
2534 kx->gcm_tag,
2535 0,
2536 &buf[sizeof(*kx)],
2537 sizeof(pbuf),
2538 pbuf))
2539 {
2541 "Unable to decrypt tag, dropping...\n");
2542 GNUNET_free (ss);
2544 stats,
2545 "# messages dropped (no kid, AEAD decryption failed)",
2546 1,
2547 GNUNET_NO);
2548 continue;
2549 }
2551 "Before VERIFY\n");
2552
2553 uc = (const struct UDPConfirmation *) pbuf;
2554
2555 if (GNUNET_OK != verify_confirmation (&kx->enc, uc)) // TODO: need ephemeral instead of representative
2556 {
2557 GNUNET_break_op (0);
2558 GNUNET_free (ss);
2560 "# messages dropped (sender signature invalid)",
2561 1,
2562 GNUNET_NO);
2563 continue;
2564 }
2566 "Before SETUP_SENDER\n");
2567
2568 calculate_cmac (ss);
2569 sender = setup_sender (&uc->sender, (const struct sockaddr *) &sa, salen);
2570 ss->sender = sender;
2571 GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss);
2572 if ((KCN_THRESHOLD > ss->sender->acks_available) &&
2573 (NULL == ss->sender->kce_task) &&
2575 {
2576 // TODO This task must be per sender! FIXME: This is a nice todo, but I do not know what must be done here to fix.
2580 ss);
2581 }
2582 sender->num_secrets++;
2583 GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
2585 "# messages decrypted without BOX",
2586 1,
2587 GNUNET_NO);
2588 try_handle_plaintext (sender, &uc[1], sizeof(pbuf) - sizeof(*uc));
2589 if (0 == purge_secrets (sender->ss_tail))
2590 {
2591 // No secret purged. Delete oldest.
2592 if (sender->num_secrets > MAX_SECRETS)
2593 {
2594 secret_destroy (sender->ss_tail);
2595 }
2596 }
2597 }
2598 }
2599}
static struct GNUNET_SCHEDULER_Task * read_v6_task
ID of read IPv6 task.
static struct GNUNET_SCHEDULER_Task * read_v4_task
ID of read IPv4 task.
static int verify_confirmation(const struct GNUNET_CRYPTO_HpkeEncapsulation *enc, const struct UDPConfirmation *uc)
Check signature from uc against ephemeral.
static struct SenderAddress * setup_sender(const struct GNUNET_PeerIdentity *target, const struct sockaddr *address, socklen_t address_len)
Create sender address for target.
static void sock_read(void *cls)
Socket read task.
static struct SharedSecret * setup_initial_shared_secret_dec(const struct GNUNET_CRYPTO_HpkeEncapsulation *c)
Setup shared secret for decryption for initial handshake.
static struct GNUNET_TRANSPORT_ApplicationHandle * ah
Our handle to report addresses for validation to TRANSPORT.
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.
static enum GNUNET_GenericReturnValue create_receiver(const struct GNUNET_PeerIdentity *peer, const char *address, struct GNUNET_NETWORK_Handle *udp_sock)
static void decrypt_box(const struct UDPBox *box, size_t box_len, struct KeyCacheEntry *kce)
We received a box with matching kce.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
#define GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST
Signature used by UDP broadcasts.
void GNUNET_TRANSPORT_communicator_burst_finished(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
The communicator tells the transport service that it finished the burst.
void GNUNET_TRANSPORT_application_validate(struct GNUNET_TRANSPORT_ApplicationHandle *ch, const struct GNUNET_PeerIdentity *peer, enum GNUNET_NetworkType nt, const char *addr)
An application (or a communicator) has received a HELLO (or other address data of another peer) and w...
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
void * GNUNET_CONTAINER_multishortmap_get(const struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key)
Given a key find a value in the map matching the key.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_stop_burst(struct GNUNET_NETWORK_Handle *do_not_touch)
Method to stop all sockets we established to the other peer.
Definition: nat.c:564
ssize_t GNUNET_NETWORK_socket_recvfrom(const struct GNUNET_NETWORK_Handle *desc, void *buffer, size_t length, struct sockaddr *src_addr, socklen_t *addrlen)
Read data from a socket (always non-blocking).
Definition: network.c:688
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:44
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1511
Message send during burst mode.
struct GNUNET_PeerIdentity peer
The peer who send the msg.
unsigned int local_port
The local port the message was send from.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
uint8_t gcm_tag[(128/8)]
HMAC for the following encrypted message, using GCM.
struct GNUNET_CRYPTO_HpkeEncapsulation enc
Representative of ephemeral key for KX.
struct GNUNET_ShortHashCode kid
Key and IV identification code.
Broadcast by peer in LAN announcing its presence.
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Sender's signature of type GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST.
struct GNUNET_PeerIdentity sender
Sender's peer identity.
struct GNUNET_PeerIdentity sender
Sender's identity.
Signature we use to verify that the broadcast was really made by the peer that claims to have made it...

References SenderAddress::acks_available, address, ah, calculate_cmac(), ch, create_receiver(), decrypt_box(), default_v4_sock, default_v6_sock, InitialKX::enc, InitialKX::gcm_tag, GNUNET_a2s(), GNUNET_assert, 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_ERROR, 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_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_sh2s(), GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST, GNUNET_STATISTICS_update(), GNUNET_stop_burst(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_application_validate(), GNUNET_TRANSPORT_communicator_burst_finished(), GNUNET_YES, UdpBroadcastSignature::h_address, is, kce_generate_cb(), SenderAddress::kce_send_ack_on_finish, SenderAddress::kce_task, SenderAddress::kce_task_finished, KCN_THRESHOLD, key_cache, UDPBox::kid, GNUNET_BurstMessage::local_port, MAX_SECRETS, my_identity, nt, GNUNET_BurstMessage::peer, GNUNET_PeerIdentity::public_key, purge_secrets(), GNUNET_CRYPTO_EccSignaturePurpose::purpose, UdpBroadcastSignature::purpose, read_v4_task, read_v6_task, secret_destroy(), UDPConfirmation::sender, UdpBroadcastSignature::sender, UDPBroadcast::sender, SharedSecret::sender, UDPBroadcast::sender_sig, setup_initial_shared_secret_dec(), setup_sender(), GNUNET_CRYPTO_EccSignaturePurpose::size, sock_read(), sockaddr_to_udpaddr_string(), stats, try_decrypt(), try_handle_plaintext(), uc, udp_sock, and verify_confirmation().

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

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

◆ create_receiver()

static enum GNUNET_GenericReturnValue create_receiver ( const struct GNUNET_PeerIdentity peer,
const char *  address,
struct GNUNET_NETWORK_Handle udp_sock 
)
static

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

2244{
2245 struct GNUNET_HashContext *hsh;
2246 struct ReceiverAddress *receiver;
2247 struct GNUNET_HashCode receiver_key;
2248 const char *path;
2249 struct sockaddr *in;
2250 socklen_t in_len;
2251
2252 if (0 != strncmp (address,
2254 strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
2255 {
2256 GNUNET_break_op (0);
2257 return GNUNET_SYSERR;
2258 }
2259 path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
2260 in = udp_address_to_sockaddr (path, AF_UNSPEC, &in_len);
2261
2262 if (NULL == in)
2263 {
2265 "Failed to setup UDP socket address\n");
2266 return GNUNET_SYSERR;
2267 }
2268 if ((AF_INET6 == in->sa_family) &&
2270 {
2272 "IPv6 disabled, skipping %s\n", address);
2273 GNUNET_free (in);
2274 return GNUNET_SYSERR;
2275 }
2276 else if (AF_INET == in->sa_family)
2277 {
2278 struct sockaddr_in *sin = (struct sockaddr_in *) in;
2279 if (0 == sin->sin_port)
2280 {
2281 GNUNET_free (in);
2282 return GNUNET_NO;
2283 }
2284 }
2285
2287 GNUNET_CRYPTO_hash_context_read (hsh, in, in_len);
2288 GNUNET_CRYPTO_hash_context_read (hsh, peer, sizeof(*peer));
2289 GNUNET_CRYPTO_hash_context_finish (hsh, &receiver_key);
2290
2292 if (NULL != receiver)
2293 {
2295 "receiver %s already exist or is being connected to\n",
2296 address);
2297 return GNUNET_NO;
2298 }
2299
2301 receiver->udp_sock = udp_sock;
2302 receiver->key = receiver_key;
2303 receiver->address = in;
2304 receiver->address_len = in_len;
2305 receiver->target = *peer;
2306 eddsa_pub_to_hpke_key (&receiver->target.public_key,
2307 &receiver->target_hpke_key);
2308 receiver->nt = GNUNET_NT_scanner_get_type (is, in, in_len);
2310 receivers,
2311 &receiver->key,
2312 receiver,
2315 "Added %s to receivers with address %s and sock %p\n",
2316 GNUNET_i2s_full (&receiver->target),
2317 address,
2318 udp_sock);
2319 receiver->timeout =
2322 receiver,
2323 receiver->timeout.abs_value_us);
2325 "# receivers active",
2327 GNUNET_NO);
2328 receiver->foreign_addr =
2329 sockaddr_to_udpaddr_string (receiver->address, receiver->address_len);
2330 if (NULL != udp_sock)
2333 udp_sock,
2334 &sock_read,
2335 udp_sock);
2337 if (NULL == timeout_task)
2339 return GNUNET_OK;
2340}
static void setup_receiver_mq(struct ReceiverAddress *receiver)
Setup the MQ for the receiver.
static struct sockaddr * udp_address_to_sockaddr(const char *bindto, sa_family_t family, socklen_t *sock_len)
Convert UDP bind specification to a struct sockaddr *
static void eddsa_pub_to_hpke_key(struct GNUNET_CRYPTO_EddsaPublicKey *edpk, struct GNUNET_CRYPTO_EcdhePublicKey *pk)

References address, check_timeouts(), COMMUNICATOR_ADDRESS_PREFIX, disable_v6, eddsa_pub_to_hpke_key(), GNUNET_break_op, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s_full(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_NT_scanner_get_type(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, is, receiver(), receivers, receivers_heap, setup_receiver_mq(), sock_read(), sockaddr_to_udpaddr_string(), stats, timeout_task, udp_address_to_sockaddr(), and udp_sock.

Referenced by mq_init(), sock_read(), and udp_socket_notify().

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_ciphercipher to use
dgramdatagram to pad
pad_sizenumber of bytes of padding to append

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

2611{
2612 char pad[pad_size];
2613
2615 if (sizeof(pad) > sizeof(struct GNUNET_MessageHeader))
2616 {
2617 struct GNUNET_MessageHeader hdr =
2618 { .size = htons (sizeof(pad)),
2620
2621 memcpy (pad, &hdr, sizeof(hdr));
2622 }
2624 0 ==
2625 gcry_cipher_encrypt (out_cipher, dgram, sizeof(pad), pad, sizeof(pad)));
2626}
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).

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(), and send_msg_with_kx().

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

◆ send_msg_with_kx()

static void send_msg_with_kx ( const struct GNUNET_MessageHeader msg,
struct ReceiverAddress receiver,
struct GNUNET_MQ_Handle mq 
)
static

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

2633{
2634 uint16_t msize = ntohs (msg->size);
2635 struct UdpHandshakeSignature uhs;
2636 struct UDPConfirmation uc;
2637 struct InitialKX kx;
2638 char dgram[receiver->kx_mtu + sizeof(uc) + sizeof(kx)];
2639 size_t dpos;
2640 gcry_cipher_hd_t out_cipher;
2641 struct SharedSecret *ss;
2642
2643 if (msize > receiver->kx_mtu)
2644 {
2645 GNUNET_break (0);
2646 if (GNUNET_YES != receiver->receiver_destroy_called)
2648 return;
2649 }
2651
2652 /* setup key material */
2654
2655 if (0 == purge_secrets (receiver->ss_tail))
2656 {
2657 // No secret purged. Delete oldest.
2658 if (receiver->num_secrets > MAX_SECRETS)
2659 {
2660 secret_destroy (receiver->ss_tail);
2661 }
2662 }
2663
2664 setup_cipher (&ss->master, 0, &out_cipher);
2665 /* compute 'uc' */
2666 uc.sender = my_identity;
2667 uc.monotonic_time =
2669 uhs.purpose.purpose = htonl (
2671 uhs.purpose.size = htonl (sizeof(uhs));
2672 uhs.sender = my_identity;
2673 uhs.receiver = receiver->target;
2674 uhs.monotonic_time = uc.monotonic_time;
2676 &uhs,
2677 &uc.sender_sig);
2678 /* Leave space for kx */
2679 dpos = sizeof(kx);
2680 /* Append encrypted uc to dgram */
2681 GNUNET_assert (0 == gcry_cipher_encrypt (out_cipher,
2682 &dgram[dpos],
2683 sizeof(uc),
2684 &uc,
2685 sizeof(uc)));
2686 dpos += sizeof(uc);
2687 /* Append encrypted payload to dgram */
2689 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
2690 dpos += msize;
2691 do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
2692 /* Datagram starts with kx */
2693 kx.enc = uhs.enc;
2695 0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag)));
2696 gcry_cipher_close (out_cipher);
2697 memcpy (dgram, &kx, sizeof(kx));
2699 dgram,
2700 sizeof(dgram),
2701 receiver->address,
2702 receiver->address_len))
2703 {
2706 "Sending KX with payload size %u to %s family %d failed sock %p\n",
2707 msize,
2708 GNUNET_a2s (receiver->address,
2709 receiver->address_len),
2710 receiver->address->sa_family,
2714 return;
2715 }
2717 "Sending KX with payload size %u to %s with socket %p\n",
2718 msize,
2719 GNUNET_a2s (receiver->address,
2720 receiver->address_len),
2723}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct SharedSecret * setup_initial_shared_secret_ephemeral(struct GNUNET_CRYPTO_HpkeEncapsulation *c, struct ReceiverAddress *receiver)
Setup new shared secret for encryption using KEM for initial handshake.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static void reschedule_receiver_timeout(struct ReceiverAddress *receiver)
Increment receiver timeout due to activity.
static void do_pad(gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
Pad dgram by pad_size using out_cipher.
static struct GNUNET_NETWORK_Handle * get_socket(struct ReceiverAddress *receiver)
#define GNUNET_CRYPTO_eddsa_sign(priv, ps, sig)
EdDSA sign a given block.
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:437
ssize_t GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc, const void *message, size_t length, const struct sockaddr *dest_addr, socklen_t dest_len)
Send data to a particular destination (always non-blocking).
Definition: network.c:772
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_monotonic(const struct GNUNET_CONFIGURATION_Handle *cfg)
Obtain the current time and make sure it is monotonically increasing.
Definition: time.c:864
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:640

References cfg, do_pad(), UdpHandshakeSignature::enc, InitialKX::enc, InitialKX::gcm_tag, get_socket(), GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_eddsa_sign, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_sendto(), 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, purge_secrets(), GNUNET_CRYPTO_EccSignaturePurpose::purpose, UdpHandshakeSignature::purpose, receiver(), UdpHandshakeSignature::receiver, receiver_destroy(), reschedule_receiver_timeout(), secret_destroy(), UdpHandshakeSignature::sender, setup_cipher(), setup_initial_shared_secret_ephemeral(), GNUNET_MessageHeader::size, GNUNET_CRYPTO_EccSignaturePurpose::size, and uc.

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:

◆ 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
mqthe message queue
msgthe message to send
impl_stateour struct ReceiverAddress

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

2738{
2739 struct ReceiverAddress *receiver = impl_state;
2740
2741 GNUNET_assert (mq == receiver->kx_mq);
2743}
static void send_msg_with_kx(const struct GNUNET_MessageHeader *msg, struct ReceiverAddress *receiver, struct GNUNET_MQ_Handle *mq)

References GNUNET_assert, mq, msg, receiver(), and send_msg_with_kx().

Referenced by setup_receiver_mq().

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

◆ create_rekey()

static void create_rekey ( struct ReceiverAddress receiver,
struct SharedSecret ss,
struct UDPRekey rekey 
)
static

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

2749{
2750 struct SharedSecret *ss_rekey;
2751
2753 /* setup key material */
2754 ss_rekey = setup_shared_secret_ephemeral (&rekey->ephemeral,
2755 receiver);
2756 ss_rekey->sequence_allowed = 0;
2758 "Setup secret with k = %s\n",
2759 GNUNET_sh2s (&ss_rekey->master));
2761 "Setup secret with H(k) = %s\n",
2762 GNUNET_h2s (&(ss_rekey->cmac)));
2763
2764 /* Append encrypted payload to dgram */
2766 rekey->header.size = htons (sizeof (struct UDPRekey));
2767}
static struct SharedSecret * setup_shared_secret_ephemeral(struct GNUNET_CRYPTO_HpkeEncapsulation *ephemeral, struct ReceiverAddress *receiver)
Setup new shared secret for encryption using KEM.
int rekey_initiated
rekey initiated for this secret?
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY.

References SharedSecret::cmac, UDPRekey::ephemeral, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY, GNUNET_sh2s(), GNUNET_YES, UDPRekey::header, SharedSecret::master, receiver(), SharedSecret::rekey_initiated, SharedSecret::sequence_allowed, setup_shared_secret_ephemeral(), GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

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
mqthe message queue
msgthe message to send
impl_stateour struct ReceiverAddress

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

2782{
2783 struct ReceiverAddress *receiver = impl_state;
2784 struct UDPRekey rekey;
2785 struct SharedSecret *ss;
2786 int inject_rekey = GNUNET_NO;
2787 uint16_t msize = ntohs (msg->size);
2788
2789 GNUNET_assert (mq == receiver->d_mq);
2790 if ((msize > receiver->d_mtu) ||
2791 (0 == receiver->acks_available))
2792 {
2794 "msize: %u, mtu: %llu, acks: %u\n",
2795 (unsigned int) msize,
2796 (unsigned long long) receiver->d_mtu,
2797 receiver->acks_available);
2798
2799 GNUNET_break (0);
2800 if (GNUNET_YES != receiver->receiver_destroy_called)
2802 return;
2803 }
2805
2806 if (receiver->num_secrets > MAX_SECRETS)
2807 {
2808 if ((0 == purge_secrets (receiver->ss_tail)) &&
2809 (NULL != receiver->ss_tail))
2810 {
2811 // No secret purged. Delete oldest.
2812 secret_destroy (receiver->ss_tail);
2813 }
2814 }
2815 /* begin "BOX" encryption method, scan for ACKs from tail! */
2816 ss = receiver->ss_tail;
2817 while (NULL != ss)
2818 {
2819 size_t payload_len = sizeof(struct UDPBox) + receiver->d_mtu;
2821 "Considering SS %s sequence used: %u sequence allowed: %u bytes sent: %lu.\n",
2822 GNUNET_sh2s (&ss->master), ss->sequence_used,
2823 ss->sequence_allowed, ss->bytes_sent);
2824 if (ss->sequence_used >= ss->sequence_allowed)
2825 {
2826 // GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2827 // "Skipping ss because no acks to use.\n");
2828 ss = ss->prev;
2829 continue;
2830 }
2831 if (ss->bytes_sent >= rekey_max_bytes)
2832 {
2833 struct SharedSecret *ss_tmp;
2835 "Skipping ss because rekey bytes reached.\n");
2836 // FIXME cleanup ss with too many bytes sent!
2837 ss_tmp = ss->prev;
2838 secret_destroy (ss);
2839 ss = ss_tmp;
2840 continue;
2841 }
2842 if (ss->bytes_sent > rekey_max_bytes * 0.7)
2843 {
2844 if (ss->rekey_initiated == GNUNET_NO)
2845 {
2847 "Injecting rekey for ss with byte sent %lu\n",
2848 (unsigned long) ss->bytes_sent);
2849 create_rekey (receiver, ss, &rekey);
2851 payload_len += sizeof (rekey);
2853 }
2854 }
2855 if (0 < ss->sequence_used)
2857 "Trying to send UDPBox with shared secret %s sequence_used %u and ss->sequence_allowed %u\n",
2858 GNUNET_sh2s (&ss->master),
2859 ss->sequence_used,
2860 ss->sequence_allowed);
2861 {
2862 char dgram[payload_len];
2863 struct UDPBox *box;
2864 gcry_cipher_hd_t out_cipher;
2865 size_t dpos;
2866
2867 box = (struct UDPBox *) dgram;
2868 ss->sequence_used++;
2869 get_kid (&ss->master, ss->sequence_used, &box->kid);
2870 setup_cipher (&ss->master, ss->sequence_used, &out_cipher);
2871 /* Append encrypted payload to dgram */
2872 dpos = sizeof(struct UDPBox);
2873 if (GNUNET_YES == inject_rekey)
2874 {
2876 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], sizeof (rekey),
2877 &rekey, sizeof (rekey)));
2878 dpos += sizeof (rekey);
2879 }
2881 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
2882 dpos += msize;
2883 do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
2884 GNUNET_assert (0 == gcry_cipher_gettag (out_cipher,
2885 box->gcm_tag,
2886 sizeof(box->gcm_tag)));
2887 gcry_cipher_close (out_cipher);
2888
2890 dgram,
2891 payload_len, // FIXME why always send sizeof dgram?
2892 receiver->address,
2893 receiver->address_len))
2894 {
2897 "Sending UDPBox to %s family %d failed sock %p failed\n",
2898 GNUNET_a2s (receiver->address,
2899 receiver->address_len),
2900 receiver->address->sa_family,
2903 return;
2904 }
2906 "Sending UDPBox with payload size %u, %u acks left, %lu bytes sent with socket %p\n",
2907 msize,
2908 receiver->acks_available,
2909 (unsigned long) ss->bytes_sent,
2911 ss->bytes_sent += sizeof (dgram);
2912 receiver->acks_available--;
2914 return;
2915 }
2916 }
2918 "No suitable ss found, sending as KX...\n");
2920}
static void inject_rekey(struct Queue *queue)
Inject a struct TCPRekey message into the queue's plaintext buffer.
static void create_rekey(struct ReceiverAddress *receiver, struct SharedSecret *ss, struct UDPRekey *rekey)

References SharedSecret::bytes_sent, create_rekey(), do_pad(), UDPBox::gcm_tag, get_kid(), get_socket(), GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_sendto(), GNUNET_NO, GNUNET_sh2s(), GNUNET_YES, inject_rekey(), UDPBox::kid, SharedSecret::master, MAX_SECRETS, mq, msg, SharedSecret::prev, purge_secrets(), receiver(), receiver_destroy(), SharedSecret::rekey_initiated, rekey_max_bytes, reschedule_receiver_timeout(), secret_destroy(), send_msg_with_kx(), SharedSecret::sequence_allowed, SharedSecret::sequence_used, setup_cipher(), and GNUNET_MessageHeader::size.

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
mqthe message queue to destroy
impl_stateour struct ReceiverAddress

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

2933{
2934 struct ReceiverAddress *receiver = impl_state;
2936 "Default MQ destroyed\n");
2937 if (mq == receiver->d_mq)
2938 {
2939 receiver->d_mq = NULL;
2940 if (GNUNET_YES != receiver->receiver_destroy_called)
2942 }
2943}

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
mqthe message queue to destroy
impl_stateour struct ReceiverAddress

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

2956{
2957 struct ReceiverAddress *receiver = impl_state;
2959 "KX MQ destroyed\n");
2960 if (mq == receiver->kx_mq)
2961 {
2962 receiver->kx_mq = NULL;
2963 if (GNUNET_YES != receiver->receiver_destroy_called)
2965 }
2966}

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
mqmessage queue
impl_stateour struct RecvierAddress

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

2977{
2978 /* Cancellation is impossible with UDP; bail */
2979 GNUNET_assert (0);
2980}

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
clsour struct ReceiverAddress
errorerror code

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

2994{
2995 struct ReceiverAddress *receiver = cls;
2996
2998 "MQ error in queue to %s: %d\n",
2999 GNUNET_i2s (&receiver->target),
3000 (int) error);
3002}

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
clsclosure
peeridentity of the other peer
addresswhere 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 3094 of file gnunet-communicator-udp.c.

3095{
3096 (void) cls;
3098 "create receiver for mq_init\n");
3099 return create_receiver (peer,
3100 address,
3101 NULL);
3102}

References address, create_receiver(), GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

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_HashCode target,
void *  value 
)
static

Iterator over all receivers to clean up.

Parameters
clsNULL
targetunused
valuethe queue to destroy
Returns
GNUNET_OK to continue to iterate

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

3117{
3118 struct ReceiverAddress *receiver = value;
3119
3120 (void) cls;
3121 (void) target;
3123 return GNUNET_OK;
3124}
struct GNUNET_PeerIdentity target
To whom are we talking to.

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_HashCode target,
void *  value 
)
static

Iterator over all senders to clean up.

Parameters
clsNULL
targetunused
valuethe queue to destroy
Returns
GNUNET_OK to continue to iterate

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

3139{
3140 struct SenderAddress *sender = value;
3141
3142 (void) cls;
3143 (void) target;
3144
3145
3146 sender_destroy (sender);
3147 return GNUNET_OK;
3148}

References GNUNET_OK, 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
clsNULL (always)

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

3158{
3160 "do_shutdown\n");
3161 GNUNET_stop_burst (NULL);
3162 if (NULL != nat)
3163 {
3165 nat = NULL;
3166 }
3167 while (NULL != bi_head)
3169 if (NULL != broadcast_task)
3170 {
3172 broadcast_task = NULL;
3173 }
3174 if (NULL != timeout_task)
3175 {
3177 timeout_task = NULL;
3178 }
3179 if (NULL != read_v6_task)
3180 {
3182 read_v6_task = NULL;
3183 }
3184 if (NULL != read_v4_task)
3185 {
3187 read_v4_task = NULL;
3188 }
3189 if (NULL != default_v6_sock)
3190 {
3193 default_v6_sock = NULL;
3194 }
3195 if (NULL != default_v4_sock)
3196 {
3199 default_v4_sock = NULL;
3200 }
3203 NULL);
3207 NULL);
3212 if (NULL != timeout_task)
3213 {
3215 timeout_task = NULL;
3216 }
3217 if (NULL != ch)
3218 {
3220 ch = NULL;
3221 }
3222 if (NULL != ah)
3223 {
3225 ah = NULL;
3226 }
3227 if (NULL != pils)
3228 {
3230 pils = NULL;
3231 }
3232 if (NULL != stats)
3233 {
3235 stats = NULL;
3236 }
3237 if (NULL != my_private_key)
3238 {
3240 my_private_key = NULL;
3241 }
3242 if (NULL != is)
3243 {
3245 is = NULL;
3246 }
3248 "do_shutdown finished\n");
3249}
static int get_receiver_delete_it(void *cls, const struct GNUNET_HashCode *target, void *value)
Iterator over all receivers to clean up.
static struct GNUNET_SCHEDULER_Task * broadcast_task
ID of master broadcast task.
static int get_sender_delete_it(void *cls, const struct GNUNET_HashCode *target, void *value)
Iterator over all senders to clean up.
static struct GNUNET_NAT_Handle * nat
Connection to NAT service.
static void bi_destroy(struct BroadcastInterface *bi)
An interface went away, stop broadcasting on it.
static struct GNUNET_PILS_Handle * pils
For PILS.
void GNUNET_PILS_disconnect(struct GNUNET_PILS_Handle *handle)
Disconnect from the PILS service.
Definition: pils_api.c:390
void GNUNET_TRANSPORT_application_done(struct GNUNET_TRANSPORT_ApplicationHandle *ch)
Shutdown TRANSPORT application client.
void GNUNET_TRANSPORT_communicator_disconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Disconnect from the transport service.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void GNUNET_CONTAINER_multishortmap_destroy(struct GNUNET_CONTAINER_MultiShortmap *map)
Destroy a hash map.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
void GNUNET_NAT_unregister(struct GNUNET_NAT_Handle *nh)
Stop port redirection and public IP address detection for the given handle.
Definition: nat_api.c:703
void GNUNET_NT_scanner_done(struct GNUNET_NT_InterfaceScanner *is)
Terminate interface scanner.
Definition: nt.c:428
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).

References ah, bi_destroy(), bi_head, broadcast_task, ch, default_v4_sock, default_v6_sock, get_receiver_delete_it(), get_sender_delete_it(), GNUNET_break, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NAT_unregister(), GNUNET_NETWORK_socket_close(), GNUNET_NT_scanner_done(), GNUNET_OK, GNUNET_PILS_disconnect(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_stop_burst(), GNUNET_TRANSPORT_application_done(), GNUNET_TRANSPORT_communicator_disconnect(), GNUNET_YES, is, key_cache, my_private_key, nat, pils, read_v4_task, read_v6_task, receivers, receivers_heap, senders, senders_heap, stats, and timeout_task.

Referenced by run().

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

◆ handle_ack_by_sender()

static int handle_ack_by_sender ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

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

3261{
3262 struct ReceiverAddress *receiver = value;
3263 struct AckInfo *ai = cls;
3264
3265 if (0 != GNUNET_memcmp (ai->sender, &receiver->target))
3266 {
3267 return GNUNET_YES;
3268 }
3269 handle_ack ((void*) ai->ack, key, receiver);
3270 return GNUNET_YES;
3271}
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.

References ai, GNUNET_memcmp, GNUNET_YES, handle_ack(), key, receiver(), and value.

Referenced by enc_notify_cb().

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
clsclosure, NULL
senderwhich peer sent the notification
msgpayload

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

3287{
3288 struct AckInfo ai;
3289
3290 (void) cls;
3292 "Storing UDPAck received from backchannel from %s\n",
3295 (ntohs (msg->size) != sizeof(struct UDPAck)))
3296 {
3297 GNUNET_break_op (0);
3298 return;
3299 }
3300 ai.ack = (const struct UDPAck *) msg;
3301 ai.sender = sender;
3304 &ai);
3305}
static int handle_ack_by_sender(void *cls, const struct GNUNET_HashCode *key, void *value)
const struct GNUNET_PeerIdentity * sender

References ai, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s_full(), GNUNET_log, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK, handle_ack_by_sender(), msg, receivers, AckInfo::sender, 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
clsclosure
app_ctx[in,out]location where the app can store stuff on add and retrieve it on remove
add_removeGNUNET_YES to add a new public IP address, GNUNET_NO to remove a previous (now invalid) one
acaddress class the address belongs to
addreither the previous or the new public IP address
addrlenactual length of the addr

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

3328{
3329 char *my_addr;
3331
3332 if (GNUNET_YES == add_remove)
3333 {
3335
3336 GNUNET_asprintf (&my_addr,
3337 "%s-%s",
3339 GNUNET_a2s (addr, addrlen));
3340 nt = GNUNET_NT_scanner_get_type (is, addr, addrlen);
3341 ai =
3343 my_addr,
3344 nt,
3346 GNUNET_free (my_addr);
3347 *app_ctx = ai;
3348 }
3349 else
3350 {
3351 ai = *app_ctx;
3353 *app_ctx = NULL;
3354 }
3355}
void GNUNET_TRANSPORT_communicator_address_remove(struct GNUNET_TRANSPORT_AddressIdentifier *ai)
Notify transport service about an address that this communicator no longer provides for this peer.
struct GNUNET_TRANSPORT_AddressIdentifier * GNUNET_TRANSPORT_communicator_address_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const char *address, enum GNUNET_NetworkType nt, struct GNUNET_TIME_Relative expiration)
Notify transport service about an address that this communicator provides for this peer.
Internal representation of an address a communicator is currently providing for the transport service...

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
clsa struct BroadcastInterface

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

3365{
3366 struct BroadcastInterface *bi = cls;
3367 struct GNUNET_TIME_Relative delay;
3368
3369 delay = BROADCAST_FREQUENCY;
3370 delay.rel_value_us =
3372 bi->broadcast_task =
3374
3375 switch (bi->sa->sa_family)
3376 {
3377 case AF_INET: {
3378 static int yes = 1;
3379 static int no = 0;
3380 ssize_t sent;
3381
3382 if (GNUNET_OK !=
3384 SOL_SOCKET,
3385 SO_BROADCAST,
3386 &yes,
3387 sizeof(int)))
3389 "setsockopt");
3391 "creating UDPBroadcast from %s\n",
3392 GNUNET_i2s (&(bi->bcm.sender)));
3394 "sending UDPBroadcast to add %s\n",
3395 GNUNET_a2s (bi->ba, bi->salen));
3397 &bi->bcm,
3398 sizeof(bi->bcm),
3399 bi->ba,
3400 bi->salen);
3401 if (-1 == sent)
3403 "sendto");
3405 SOL_SOCKET,
3406 SO_BROADCAST,
3407 &no,
3408 sizeof(int)))
3410 "setsockopt");
3411 break;
3412 }
3413
3414 case AF_INET6: {
3415 ssize_t sent;
3416 struct sockaddr_in6 dst;
3417
3418 dst.sin6_family = AF_INET6;
3419 dst.sin6_port = htons (my_port);
3420 dst.sin6_addr = bi->mcreq.ipv6mr_multiaddr;
3421 dst.sin6_scope_id = ((struct sockaddr_in6 *) bi->ba)->sin6_scope_id;
3422
3424 "sending UDPBroadcast\n");
3426 &bi->bcm,
3427 sizeof(bi->bcm),
3428 (const struct sockaddr *) &dst,
3429 sizeof(dst));
3430 if (-1 == sent)
3432 break;
3433 }
3434
3435 default:
3436 GNUNET_break (0);
3437 break;
3438 }
3439}
static uint16_t my_port
Port number to which we are actually bound.
static void ifc_broadcast(void *cls)
Broadcast our presence on one of our interfaces.
#define BROADCAST_FREQUENCY
How often do we broadcast our presence on the LAN?
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Generate a random unsigned 64-bit value.
Interface we broadcast our presence on.
socklen_t salen
Number of bytes in sa.
struct UDPBroadcast bcm
Message we broadcast on this interface.

References BroadcastInterface::ba, BroadcastInterface::bcm, BROADCAST_FREQUENCY, BroadcastInterface::broadcast_task, default_v4_sock, default_v6_sock, 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(), ifc_broadcast(), BroadcastInterface::mcreq, my_port, GNUNET_TIME_Relative::rel_value_us, BroadcastInterface::sa, BroadcastInterface::salen, and UDPBroadcast::sender.

Referenced by iface_proc(), and ifc_broadcast().

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
clsNULL
namename of the interface (can be NULL for unknown)
isDefaultis this presumably the default interface
addraddress of this interface (can be NULL for unknown or unassigned)
broadcast_addrthe broadcast address (can be NULL for unknown or unassigned)
netmaskthe network mask (can be NULL for unknown or unassigned)
addrlenlength of the address
Returns
GNUNET_OK to continue iteration, GNUNET_SYSERR to abort

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

3464{
3465 struct BroadcastInterface *bi;
3466 enum GNUNET_NetworkType network;
3467 struct UdpBroadcastSignature ubs;
3468
3469 (void) cls;
3470 (void) netmask;
3471 if (NULL == my_private_key)
3472 return GNUNET_YES;
3473 if (NULL == addr)
3474 return GNUNET_YES; /* need to know our address! */
3475 network = GNUNET_NT_scanner_get_type (is, addr, addrlen);
3476 if (GNUNET_NT_LOOPBACK == network)
3477 {
3478 /* Broadcasting on loopback does not make sense */
3479 return GNUNET_YES;
3480 }
3481 for (bi = bi_head; NULL != bi; bi = bi->next)
3482 {
3483 if ((bi->salen == addrlen) && (0 == memcmp (addr, bi->sa, addrlen)))
3484 {
3485 bi->found = GNUNET_YES;
3486 return GNUNET_OK;
3487 }
3488 }
3489
3490 if ((AF_INET6 == addr->sa_family) && (NULL == broadcast_addr))
3491 return GNUNET_OK; /* broadcast_addr is required for IPv6! */
3492 if ((AF_INET6 == addr->sa_family) && (NULL != default_v6_sock))
3493 return GNUNET_OK; /* not using IPv6 */
3494
3495 bi = GNUNET_new (struct BroadcastInterface);
3496 bi->sa = GNUNET_memdup (addr,
3497 addrlen);
3498 if ( (NULL != broadcast_addr) &&
3499 (addrlen == sizeof (struct sockaddr_in)) )
3500 {
3501 struct sockaddr_in *ba;
3502
3503 ba = GNUNET_memdup (broadcast_addr,
3504 addrlen);
3505 ba->sin_port = htons (2086); /* always GNUnet port, ignore configuration! */
3506 bi->ba = (struct sockaddr *) ba;
3507 }
3508 bi->salen = addrlen;
3509 bi->found = GNUNET_YES;
3510 bi->bcm.sender = my_identity;
3511 ubs.purpose.purpose = htonl (
3513 ubs.purpose.size = htonl (sizeof(ubs));
3514 ubs.sender = my_identity;
3516 "creating UDPBroadcastSignature for %s\n",
3517 GNUNET_a2s (addr, addrlen));
3518 GNUNET_CRYPTO_hash (addr, addrlen, &ubs.h_address);
3520 &ubs,
3521 &bi->bcm.sender_sig);
3522 if (NULL != bi->ba)
3523 {
3526 }
3527 if ((AF_INET6 == addr->sa_family) && (NULL != broadcast_addr))
3528 {
3529 /* Create IPv6 multicast request */
3530 const struct sockaddr_in6 *s6 =
3531 (const struct sockaddr_in6 *) broadcast_addr;
3532
3534 1 == inet_pton (AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr));
3535
3536 /* http://tools.ietf.org/html/rfc2553#section-5.2:
3537 *
3538 * IPV6_JOIN_GROUP
3539 *
3540 * Join a multicast group on a specified local interface. If the
3541 * interface index is specified as 0, the kernel chooses the local
3542 * interface. For example, some kernels look up the multicast
3543 * group in the normal IPv6 routing table and using the resulting
3544 * interface; we do this for each interface, so no need to use
3545 * zero (anymore...).
3546 */
3547 bi->mcreq.ipv6mr_interface = s6->sin6_scope_id;
3548
3549 /* Join the multicast group */
3551 IPPROTO_IPV6,
3552 IPV6_JOIN_GROUP,
3553 &bi->mcreq,
3554 sizeof(bi->mcreq)))
3555 {
3557 }
3558 }
3559 return GNUNET_OK;
3560}
@ GNUNET_NT_LOOPBACK
Loopback (same host).
Definition: gnunet_nt_lib.h:53
struct BroadcastInterface * next
Kept in a DLL.
int found
Was this interface found in the last iface_proc() scan?

References BroadcastInterface::ba, BroadcastInterface::bcm, bi_head, bi_tail, BroadcastInterface::broadcast_task, default_v6_sock, 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, 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, and GNUNET_CRYPTO_EccSignaturePurpose::size.

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
clsNULL, unused

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

3570{
3571 struct BroadcastInterface *bin;
3572
3573 (void) cls;
3574 for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bi->next)
3575 bi->found = GNUNET_NO;
3577 for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bin)
3578 {
3579 bin = bi->next;
3580 if (GNUNET_NO == bi->found)
3581 bi_destroy (bi);
3582 }
3584 &do_broadcast,
3585 NULL);
3586}
static void do_broadcast(void *cls)
Scan interfaces to broadcast our presence on the LAN.
#define INTERFACE_SCAN_FREQUENCY
How often do we scan for changes to our network interfaces?
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.
void GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
Enumerate all network interfaces.
Definition: os_network.c:397

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

Referenced by do_broadcast(), pid_change_cb(), and 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 3590 of file gnunet-communicator-udp.c.

3593{
3594 /* FIXME: support reversal: #5529 */
3596 "No connection reversal implemented!\n");
3597}
@ GNUNET_ERROR_TYPE_INFO

References GNUNET_ERROR_TYPE_INFO, and GNUNET_log.

Referenced by run().

Here is the caller graph for this function:

◆ udp_socket_notify()

static void udp_socket_notify ( struct GNUNET_UdpSocketInfo sock_info)
static

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

3602{
3604 sizeof (*sock_info->actual_address
3605 ));
3606 create_receiver (sock_info->pid,
3607 address,
3608 default_v4_sock == sock_info->udp_sock ||
3609 default_v6_sock == sock_info->udp_sock ?
3610 NULL : sock_info->udp_sock);
3612 GNUNET_free (sock_info);
3613}
struct sockaddr * actual_address
The address of the other peer we received a burst message from.
struct GNUNET_NETWORK_Handle * udp_sock
struct GNUNET_PeerIdentity * pid
The peer we like to connect to.

References GNUNET_UdpSocketInfo::actual_address, address, ch, create_receiver(), default_v4_sock, default_v6_sock, GNUNET_free, GNUNET_TRANSPORT_communicator_burst_finished(), GNUNET_UdpSocketInfo::pid, sockaddr_to_udpaddr_string(), and GNUNET_UdpSocketInfo::udp_sock.

Referenced by start_burst().

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

◆ start_burst()

static void start_burst ( const char *  addr,
struct GNUNET_TIME_Relative  rtt,
struct GNUNET_PeerIdentity pid 
)
static

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

3620{
3621 struct GNUNET_UdpSocketInfo *sock_info;
3622
3624 "Communicator was called to start burst to address %s from %s\n",
3625 addr,
3626 my_ipv4);
3627
3628 GNUNET_stop_burst (NULL);
3629
3630 sock_info = GNUNET_new (struct GNUNET_UdpSocketInfo);
3631 sock_info->pid = GNUNET_new (struct GNUNET_PeerIdentity);
3632 sock_info->address = GNUNET_strdup (addr);
3633 sock_info->bind_address = my_ipv4;
3634 sock_info->has_port = GNUNET_YES;
3635 sock_info->udp_sock = default_v4_sock;
3636 sock_info->rtt = rtt;
3637 GNUNET_memcpy (sock_info->pid, pid, sizeof (struct GNUNET_PeerIdentity));
3638 sock_info->std_port = my_port;
3640 "1 sock addr %s addr %s rtt %lu %u\n",
3641 sock_info->address,
3642 addr,
3643 (unsigned long) sock_info->rtt.rel_value_us,
3644 my_port);
3645 burst_task = GNUNET_get_udp_socket (sock_info,
3647 GNUNET_free (sock_info);
3648}
static void udp_socket_notify(struct GNUNET_UdpSocketInfo *sock_info)
char * my_ipv4
Our ipv4 address.
static struct GNUNET_SCHEDULER_Task * burst_task
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_SCHEDULER_Task * GNUNET_get_udp_socket(struct GNUNET_UdpSocketInfo *sock_info, GNUNET_NotifyUdpSocket nus)
Method to get a UDP socket for a peer that is natted.
Definition: nat.c:509
uint64_t rel_value_us
The actual value.
Struct with the socket we like to use to send messages to another peer.
const char * bind_address
Our address without port.
enum GNUNET_GenericReturnValue has_port
Flag indicating, if the address is without port information.
struct GNUNET_TIME_Relative rtt
The actual RTT between the peers.
char * address
The address of the other peer without port.
unsigned int std_port
Default local port we are bound to.

References GNUNET_UdpSocketInfo::address, GNUNET_UdpSocketInfo::bind_address, burst_task, default_v4_sock, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_get_udp_socket(), GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_stop_burst(), GNUNET_strdup, GNUNET_YES, GNUNET_UdpSocketInfo::has_port, my_ipv4, my_port, GNUNET_UdpSocketInfo::pid, pid, GNUNET_TIME_Relative::rel_value_us, GNUNET_UdpSocketInfo::rtt, GNUNET_UdpSocketInfo::std_port, GNUNET_UdpSocketInfo::udp_sock, and udp_socket_notify().

Referenced by reconnect(), and run().

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

◆ create_udp_socket()

static struct GNUNET_NETWORK_Handle * create_udp_socket ( const char *  bindto,
sa_family_t  family,
struct sockaddr **  out,
socklen_t *  out_len 
)
static

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

3656{
3657 struct GNUNET_NETWORK_Handle *sock;
3658 struct sockaddr *in;
3659 socklen_t in_len;
3660 struct sockaddr_storage in_sto;
3661 socklen_t sto_len;
3662
3663 in = udp_address_to_sockaddr (bindto, family, &in_len);
3664 if (NULL == in)
3665 {
3667 "Failed to setup UDP socket address with path `%s'\n",
3668 bindto);
3669 return NULL;
3670 }
3671
3672 if ((AF_UNSPEC != family) && (in->sa_family != family))
3673 {
3675 "Invalid UDP socket address setup with path `%s'\n",
3676 bindto);
3677 GNUNET_free (in);
3678 return NULL;
3679 }
3680
3681 sock =
3682 GNUNET_NETWORK_socket_create (in->sa_family,
3683 SOCK_DGRAM,
3684 IPPROTO_UDP);
3685 if (NULL == sock)
3686 {
3689 "Failed to create socket for %s family %d\n",
3690 GNUNET_a2s (in,
3691 in_len),
3692 in->sa_family);
3693 GNUNET_free (in);
3694 return NULL;
3695 }
3696 if (GNUNET_OK !=
3698 in,
3699 in_len))
3700 {
3702 "bind",
3703 bindto);
3705 "Failed to bind socket for %s family %d sock %p\n",
3706 GNUNET_a2s (in,
3707 in_len),
3708 in->sa_family,
3709 sock);
3711 sock = NULL;
3712 GNUNET_free (in);
3713 return NULL;
3714 }
3715
3716 /* We might have bound to port 0, allowing the OS to figure it out;
3717 thus, get the real IN-address from the socket */
3718 sto_len = sizeof(in_sto);
3719 if (0 != getsockname (GNUNET_NETWORK_get_fd (sock),
3720 (struct sockaddr *) &in_sto,
3721 &sto_len))
3722 {
3723 memcpy (&in_sto, in, in_len);
3724 sto_len = in_len;
3725 }
3726 GNUNET_free (in);
3727 *out = GNUNET_malloc (sto_len);
3728 memcpy (*out, (struct sockaddr *) &in_sto, sto_len);
3729 *out_len = sto_len;
3730 return sock;
3731}
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
int GNUNET_NETWORK_get_fd(const struct GNUNET_NETWORK_Handle *desc)
Return file descriptor for this network handle.
Definition: network.c:1001
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:833
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_bind(struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Bind a socket to a particular address.
Definition: network.c:439

References GNUNET_a2s(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_NETWORK_get_fd(), GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_OK, and udp_address_to_sockaddr().

Referenced by run().

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

◆ shutdown_run()

static void shutdown_run ( struct sockaddr *  addrs[2])
static

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

3736{
3737 if (NULL != addrs[0])
3738 GNUNET_free (addrs[0]);
3739 if (NULL != addrs[1])
3740 GNUNET_free (addrs[1]);
3742}
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:567

References GNUNET_free, and GNUNET_SCHEDULER_shutdown().

Referenced by run().

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

◆ load_ikm()

static enum GNUNET_GenericReturnValue load_ikm ( )
static

FIXME: We could alternatively ask PILS for de/encaps, but at a high cost wrt async RPC calls...

Get the initial secret key for generating the peer id. This is supposed to be generated at random once in the lifetime of a peer, so all generated peer ids use the same initial secret key to optain the same peer id per set of addresses.

First check whether there's already a initial secret key. If so: return it. If no initial secret key exists yet, generate at random and store it where it will be found.

Parameters
initialsecret key the memory the initial secret key can be written to.

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

3760{
3761 char *filename;
3762 struct GNUNET_DISK_FileHandle *filehandle;
3763 int ret;
3764
3765 if (GNUNET_OK !=
3767 "pils",
3768 "SECRET_KEY_FILE",
3769 &filename))
3770 {
3772 "PILS service is lacking initial secret key file configuration setting. Exiting\n");
3773 return GNUNET_SYSERR;
3774 }
3775 if (NULL == filename)
3776 return GNUNET_SYSERR;
3778 if (GNUNET_SYSERR == ret)
3779 return GNUNET_SYSERR;
3780 if (GNUNET_NO == ret)
3781 {
3782 /* File does not exist - generate a new initial secret key and save it */
3783 // TODO consider the case that the file exists and ist not readable
3785 ikm,
3786 sizeof ikm);
3788 {
3790 "PILS service cannot create dir for saving initial secret key file. Exiting\n");
3791 return GNUNET_SYSERR;
3792 }
3793 filehandle = GNUNET_DISK_file_open (filename,
3797 | // would
3798 // the
3799 // group
3800 // need
3801 // read
3802 // perm?
3804 if (NULL == filehandle)
3805 {
3807 "PILS service had an issue with opening the initial secret key file. Exiting\n");
3808 GNUNET_DISK_file_close (filehandle);
3809 return GNUNET_SYSERR;
3810 }
3811 ret = GNUNET_DISK_file_write (filehandle,
3812 ikm,
3813 sizeof ikm);
3814 GNUNET_DISK_file_close (filehandle);
3815 if (sizeof ikm != ret)
3816 {
3818 "PILS service had an issue with writing the initial secret key to file. Exiting\n")
3819 ;
3820 return GNUNET_SYSERR;
3821 }
3822 }
3823 else
3824 {
3825 /* File existes - just read from it */
3826 off_t size;
3828 "PILS is going to read initial secret key from file %s\n",
3829 filename);
3830 filehandle = GNUNET_DISK_file_open (filename,
3833 if (NULL == filehandle)
3834 {
3836 " Not able to open file\n");
3837 return GNUNET_SYSERR;
3838 }
3839 if (GNUNET_OK != GNUNET_DISK_file_handle_size (filehandle, &size))
3840 {
3842 " File has the wrong size %lu\n",
3843 size);
3844 GNUNET_DISK_file_close (filehandle);
3845 return GNUNET_SYSERR;
3846 }
3847 if (sizeof ikm != size)
3848 {
3850 " Something is wrong with the file size, expected: %lu size, got: %lu\n",
3851 size,
3852 sizeof ikm);
3853 GNUNET_DISK_file_close (filehandle);
3854 return GNUNET_SYSERR;
3855 }
3856 ret = GNUNET_DISK_file_read (filehandle,
3857 ikm,
3858 sizeof ikm);
3859 GNUNET_DISK_file_close (filehandle);
3860 if (sizeof ikm != ret)
3861 {
3863 " Read initial secret key with wrong size %u, expected %lu\n", ret,
3864 sizeof ikm);
3865 return GNUNET_SYSERR;
3866 }
3867
3868 }
3869 return GNUNET_OK;
3870}
static unsigned char ikm[256/8]
The initial key material for the peer.
#define LOG(kind,...)
static char * filename
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1258
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:710
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test_read(const char *fil)
Check that fil corresponds to a filename and the file has read permissions.
Definition: disk.c:540
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1332
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:633
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:673
enum GNUNET_GenericReturnValue GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, off_t *size)
Get the size of an open file.
Definition: disk.c:206
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_OPEN_WRITE
Open the file for writing.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_NONE
Nobody is allowed to do anything to the file.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
static unsigned int size
Size of the "table".
Definition: peer.c:68
Handle used to access files (and pipes).

References cfg, filename, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_block(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_file_close(), GNUNET_DISK_file_handle_size(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_test_read(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_READ, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_NONE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, ikm, LOG, ret, and size.

Referenced by run().

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

◆ pid_change_cb()

void pid_change_cb ( void *  cls,
const struct GNUNET_HELLO_Parser parser,
const struct GNUNET_HashCode addr_hash 
)

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

3877{
3879 "Got PID to derive from `%s':\n",
3880 GNUNET_h2s (addr_hash));
3881 if (NULL == my_private_key)
3883
3885 (uint8_t*) ikm,
3886 addr_hash,
3892 /* start broadcasting */
3893 if (GNUNET_YES !=
3896 "DISABLE_BROADCAST"))
3897 {
3898 if (NULL == broadcast_task)
3900 }
3901}
static void eddsa_priv_to_hpke_key(struct GNUNET_CRYPTO_EddsaPrivateKey *edpk, struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
#define COMMUNICATOR_CONFIG_SECTION
Configuration section used by the communicator.
void GNUNET_PILS_derive_pid(size_t seed_key_bytes, const uint8_t seed_key[seed_key_bytes], const struct GNUNET_HashCode *addrs_hash, struct GNUNET_CRYPTO_EddsaPrivateKey *outkey)
Generate the peer id from the addresses hash and the initial secret key.
Definition: pils_api.c:507
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:201
Private ECC key encoded for transmission.

References broadcast_task, cfg, COMMUNICATOR_CONFIG_SECTION, do_broadcast(), eddsa_priv_to_hpke_key(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_new, GNUNET_PILS_derive_pid(), GNUNET_SCHEDULER_add_now(), GNUNET_YES, ikm, LOG, my_identity, my_private_key, my_x25519_private_key, and GNUNET_PeerIdentity::public_key.

Referenced by run().

Here is the call graph for this function:
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

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

3909{
3910 const struct sockaddr_in *v4;
3911 char *bindto;
3912 char *bindto6;
3913 struct sockaddr *in[2];
3914 socklen_t in_len[2];
3915
3917 "Entering the run method of udp communicator.\n");
3918
3919 cfg = c;
3921 if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
3922 (GNUNET_YES ==
3925 "DISABLE_V6")))
3926 {
3928 }
3929
3930 if (GNUNET_OK !=
3933 "BINDTO",
3934 &bindto))
3935 {
3938 "BINDTO");
3939 return;
3940 }
3942 "The udp communicator will bind to %s for IPv4\n",
3943 bindto);
3944 if (GNUNET_YES != disable_v6)
3945 {
3946 if (GNUNET_OK !=
3949 "BINDTO6",
3950 &bindto6))
3951 {
3954 "BINDTO6");
3955 return;
3956 }
3957
3959 "The udp communicator will bind to %s for IPv6\n",
3960 bindto6);
3961 }
3962 else
3963 bindto6 = NULL;
3964 if (GNUNET_OK !=
3967 "REKEY_INTERVAL",
3970
3971 if (GNUNET_OK !=
3974 "REKEY_MAX_BYTES",
3976 {
3978 }
3979
3980 memset (in, 0, sizeof(struct sockaddr*) * 2);
3981 memset (in_len, 0, sizeof(socklen_t) * 2);
3982
3983 GNUNET_assert (bindto);
3985 bindto, AF_INET, &(in[0]), &(in_len[0]));
3986 GNUNET_free (bindto);
3987
3988 if (GNUNET_YES != disable_v6)
3989 {
3990 GNUNET_assert (bindto6);
3992 bindto6, AF_INET6, &(in[1]), &(in_len[1]));
3993 GNUNET_free (bindto6);
3994 }
3995 else
3996 default_v6_sock = NULL;
3997
3998 if ((NULL == default_v4_sock) && (NULL == default_v6_sock))
3999 return;
4000
4001 my_port = 0;
4002 if (NULL != default_v4_sock)
4003 {
4004 GNUNET_assert (in[0]);
4006 "transport",
4007 "Bound to `%s' sock %p\n",
4008 GNUNET_a2s ((const struct sockaddr *) in[0],
4009 in_len[0]),
4011
4012 v4 = (const struct sockaddr_in *) in[0];
4013
4014 my_ipv4 = GNUNET_malloc (INET_ADDRSTRLEN);
4015 my_port = ntohs (((struct sockaddr_in *) in[0])->sin_port);
4016 inet_ntop (AF_INET, &v4->sin_addr, my_ipv4, in_len[0]);
4017 }
4018 if (NULL != default_v6_sock)
4019 {
4020 GNUNET_assert (in[1]);
4022 "transport",
4023 "Bound to `%s' sock %p\n",
4024 GNUNET_a2s ((const struct sockaddr *) in[1],
4025 in_len[1]),
4027 my_port = ntohs (((struct sockaddr_in6 *) in[1])->sin6_port);
4028 }
4029 stats = GNUNET_STATISTICS_create ("communicator-udp", cfg);
4038 /* start reading */
4039 if (NULL != default_v4_sock)
4042 &sock_read,
4044 else
4045 read_v4_task = NULL;
4046 if (NULL != default_v6_sock)
4049 &sock_read,
4051 else
4052 read_v6_task = NULL;
4057 &mq_init,
4058 NULL,
4060 NULL,
4061 &start_burst);
4062 if (NULL == ch)
4063 {
4064 GNUNET_break (0);
4065 shutdown_run (in);
4066 return;
4067 }
4069 if (NULL == ah)
4070 {
4071 GNUNET_break (0);
4072 shutdown_run (in);
4073 return;
4074 }
4075 /* start broadcasting */
4076 if (GNUNET_YES !=
4079 "DISABLE_BROADCAST"))
4080 {
4082 }
4083 load_ikm ();
4085 GNUNET_assert (NULL != pils);
4086
4089 IPPROTO_UDP,
4090 (NULL != in[0]? 1 : 0)
4091 + (NULL != in[1]? 1 : 0),
4092 (const struct sockaddr**)
4093 (NULL != in[0]? in : &(in[1])),
4094 NULL != in[0]? in_len : &(in_len[1]),
4097 NULL /* closure */);
4098 if (NULL != in[0])
4099 GNUNET_free (in[0]);
4100 if (NULL != in[1])
4101 GNUNET_free (in[1]);
4102}
void pid_change_cb(void *cls, const struct GNUNET_HELLO_Parser *parser, const struct GNUNET_HashCode *addr_hash)
#define DEFAULT_REKEY_TIME_INTERVAL
How often do we rekey based on time (at least)
static struct GNUNET_NETWORK_Handle * create_udp_socket(const char *bindto, sa_family_t family, struct sockaddr **out, socklen_t *out_len)
static void try_connection_reversal(void *cls, const struct sockaddr *addr, socklen_t addrlen)
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 (...
static struct GNUNET_TIME_Relative rekey_interval
The rekey interval.
static void start_burst(const char *addr, struct GNUNET_TIME_Relative rtt, struct GNUNET_PeerIdentity *pid)
static void do_shutdown(void *cls)
Shutdown the UNIX communicator.
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 ...
#define DEFAULT_REKEY_MAX_BYTES
Default value for how often we do rekey based on number of bytes transmitted? (additionally randomize...
static void shutdown_run(struct sockaddr *addrs[2])
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 abou...
static enum GNUNET_GenericReturnValue load_ikm()
FIXME: We could alternatively ask PILS for de/encaps, but at a high cost wrt async RPC calls....
struct GNUNET_PILS_Handle * GNUNET_PILS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_PILS_PidChangeCallback pid_change_cb, void *cls)
Connect to the PILS service.
Definition: pils_api.c:367
struct GNUNET_TRANSPORT_ApplicationHandle * GNUNET_TRANSPORT_application_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the TRANSPORT application client handle.
struct GNUNET_TRANSPORT_CommunicatorHandle * GNUNET_TRANSPORT_communicator_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section_name, const char *addr_prefix, enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc, GNUNET_TRANSPORT_CommunicatorMqInit mq_init, void *mq_init_cls, GNUNET_TRANSPORT_CommunicatorNotify notify_cb, void *notify_cb_cls, GNUNET_TRANSPORT_StartBurstNotify sb)
Connect to the transport service.
@ GNUNET_TRANSPORT_CC_UNRELIABLE
Transmission is unreliable (e.g.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_size(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *size)
Get a configuration value that should be a size in bytes.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
struct GNUNET_CONTAINER_MultiShortmap * GNUNET_CONTAINER_multishortmap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
struct GNUNET_CONTAINER_Heap * GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
Create a new heap.
@ GNUNET_CONTAINER_HEAP_ORDER_MIN
Heap with the minimum cost at the root.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
void GNUNET_log_from_nocheck(enum GNUNET_ErrorType kind, const char *comp, const char *message,...) __attribute__((format(printf
Log function that specifies an alternative component.
struct GNUNET_NAT_Handle * GNUNET_NAT_register(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section, uint8_t proto, unsigned int num_addrs, const struct sockaddr **addrs, const socklen_t *addrlens, GNUNET_NAT_AddressCallback address_callback, GNUNET_NAT_ReversalCallback reversal_callback, void *callback_cls)
Attempt to enable port redirection and detect public IP address contacting UPnP or NAT-PMP routers on...
Definition: nat_api.c:366
enum GNUNET_GenericReturnValue GNUNET_NETWORK_test_pf(int pf)
Test if the given protocol family is supported by this system.
Definition: network.c:79
struct GNUNET_NT_InterfaceScanner * GNUNET_NT_scanner_init(void)
Initialize the address characterization client handle.
Definition: nt.c:407
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1339
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.

References ah, broadcast_task, cfg, ch, COMMUNICATOR_ADDRESS_PREFIX, COMMUNICATOR_CONFIG_SECTION, create_udp_socket(), DEFAULT_REKEY_MAX_BYTES, DEFAULT_REKEY_TIME_INTERVAL, default_v4_sock, default_v6_sock, disable_v6, do_broadcast(), do_shutdown(), enc_notify_cb(), GNUNET_a2s(), GNUNET_assert, 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_multihashmap_create(), GNUNET_CONTAINER_multishortmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_from_nocheck(), GNUNET_malloc, GNUNET_NAT_register(), GNUNET_NETWORK_test_pf(), GNUNET_NO, GNUNET_NT_scanner_init(), GNUNET_OK, GNUNET_PILS_connect(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_application_init(), GNUNET_TRANSPORT_CC_UNRELIABLE, GNUNET_TRANSPORT_communicator_connect(), GNUNET_YES, is, key_cache, load_ikm(), mq_init(), my_ipv4, my_port, nat, nat_address_cb(), pid_change_cb(), pils, read_v4_task, read_v6_task, receivers, receivers_heap, rekey_interval, rekey_max_bytes, senders, senders_heap, shutdown_run(), sock_read(), start_burst(), stats, and try_connection_reversal().

Here is the call graph for this function:

Variable Documentation

◆ ikm

unsigned char ikm[256/8]
static

The initial key material for the peer.

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

Referenced by load_ikm(), and pid_change_cb().

◆ pils

struct GNUNET_PILS_Handle* pils
static

For PILS.

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

Referenced by do_shutdown(), and run().

◆ rekey_interval

struct GNUNET_TIME_Relative rekey_interval
static

The rekey interval.

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

Referenced by 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 776 of file gnunet-communicator-udp.c.

Referenced by decrypt_box(), mq_send_d(), and run().

◆ key_cache

struct GNUNET_CONTAINER_MultiShortmap* key_cache
static

Cache of pre-generated key IDs.

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

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

◆ read_v4_task

struct GNUNET_SCHEDULER_Task* read_v4_task
static

ID of read IPv4 task.

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

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

◆ read_v6_task

struct GNUNET_SCHEDULER_Task* read_v6_task
static

ID of read IPv6 task.

Definition at line 791 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 796 of file gnunet-communicator-udp.c.

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

◆ broadcast_task

struct GNUNET_SCHEDULER_Task* broadcast_task
static

ID of master broadcast task.

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

Referenced by do_broadcast(), do_shutdown(), pid_change_cb(), and run().

◆ stats

◆ ch

◆ receivers

struct GNUNET_CONTAINER_MultiHashMap* receivers
static

Receivers (map from peer identity to struct ReceiverAddress)

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

Referenced by create_receiver(), do_shutdown(), enc_notify_cb(), receiver_destroy(), run(), setup_sender(), and try_handle_plaintext().

◆ senders

struct GNUNET_CONTAINER_MultiHashMap* senders
static

Senders (map from peer identity to struct SenderAddress)

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

Referenced by do_shutdown(), run(), sender_destroy(), and setup_sender().

◆ senders_heap

struct GNUNET_CONTAINER_Heap* senders_heap
static

Expiration heap for senders (contains struct SenderAddress)

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

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

◆ receivers_heap

struct GNUNET_CONTAINER_Heap* receivers_heap
static

Expiration heap for receivers (contains struct ReceiverAddress)

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

Referenced by check_timeouts(), create_receiver(), do_shutdown(), and run().

◆ bi_head

struct BroadcastInterface* bi_head
static

Broadcast interface tasks.

Kept in a DLL.

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

Referenced by bi_destroy(), do_broadcast(), do_shutdown(), and iface_proc().

◆ bi_tail

struct BroadcastInterface* bi_tail
static

Broadcast interface tasks.

Kept in a DLL.

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

Referenced by bi_destroy(), and iface_proc().

◆ default_v4_sock

struct GNUNET_NETWORK_Handle* default_v4_sock
static

Our IPv4 socket.

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

Referenced by do_shutdown(), get_socket(), ifc_broadcast(), run(), sock_read(), start_burst(), and udp_socket_notify().

◆ default_v6_sock

struct GNUNET_NETWORK_Handle* default_v6_sock
static

◆ my_identity

struct GNUNET_PeerIdentity my_identity
static

Our public key.

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

Referenced by iface_proc(), pid_change_cb(), send_msg_with_kx(), sock_read(), and verify_confirmation().

◆ my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey* my_private_key
static

Our private key.

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

Referenced by do_shutdown(), iface_proc(), pid_change_cb(), send_msg_with_kx(), and setup_shared_secret_dec().

◆ my_x25519_private_key

struct GNUNET_CRYPTO_EcdhePrivateKey my_x25519_private_key
static

Our private key for HPKE.

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

Referenced by pid_change_cb(), and setup_initial_shared_secret_dec().

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Our configuration.

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

Referenced by load_ikm(), pid_change_cb(), run(), and send_msg_with_kx().

◆ ah

Our handle to report addresses for validation to TRANSPORT.

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

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

◆ is

struct GNUNET_NT_InterfaceScanner* is
static

Network scanner to determine network types.

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

Referenced by create_receiver(), do_shutdown(), iface_proc(), nat_address_cb(), run(), setup_sender(), and sock_read().

◆ nat

struct GNUNET_NAT_Handle* nat
static

Connection to NAT service.

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

Referenced by do_shutdown(), and run().

◆ my_port

uint16_t my_port
static

Port number to which we are actually bound.

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

Referenced by ifc_broadcast(), run(), and start_burst().

◆ my_ipv4

char* my_ipv4

Our ipv4 address.

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

Referenced by run(), and start_burst().

◆ disable_v6

int disable_v6
static

IPv6 disabled or not.

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

Referenced by create_receiver(), run(), and udp_address_to_sockaddr().

◆ burst_task

struct GNUNET_SCHEDULER_Task* burst_task
static

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

Referenced by start_burst().