summaryrefslogtreecommitdiff
path: root/src/transport/gnunet-communicator-udp.c
diff options
context:
space:
mode:
authorng0 <ng0@n0.is>2019-09-08 12:33:09 +0000
committerng0 <ng0@n0.is>2019-09-08 12:33:09 +0000
commitd41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch)
tree9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/transport/gnunet-communicator-udp.c
parenta0fce305c565c0937d917a92712f15e9c5736260 (diff)
uncrustify as demanded.
Diffstat (limited to 'src/transport/gnunet-communicator-udp.c')
-rw-r--r--src/transport/gnunet-communicator-udp.c2292
1 files changed, 1141 insertions, 1151 deletions
diff --git a/src/transport/gnunet-communicator-udp.c b/src/transport/gnunet-communicator-udp.c
index 2c8893d75..228540b81 100644
--- a/src/transport/gnunet-communicator-udp.c
+++ b/src/transport/gnunet-communicator-udp.c
@@ -16,7 +16,7 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
/**
* @file transport/gnunet-communicator-udp.c
@@ -67,7 +67,7 @@
* How often do we scan for changes to our network interfaces?
*/
#define INTERFACE_SCAN_FREQUENCY \
- GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
+ GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
/**
* How long do we believe our addresses to remain up (before
@@ -156,8 +156,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
* the specified sender. If possible, the receiver should respond with
* a `struct UDPAck` (possibly via backchannel).
*/
-struct UdpHandshakeSignature
-{
+struct UdpHandshakeSignature {
/**
* Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE
*/
@@ -190,9 +189,7 @@ struct UdpHandshakeSignature
* "Plaintext" header at beginning of KX message. Followed
* by encrypted `struct UDPConfirmation`.
*/
-struct InitialKX
-{
-
+struct InitialKX {
/**
* Ephemeral key for KX.
*/
@@ -210,8 +207,7 @@ struct InitialKX
* Encrypted continuation of UDP initial handshake, followed
* by message header with payload.
*/
-struct UDPConfirmation
-{
+struct UDPConfirmation {
/**
* Sender's identity
*/
@@ -238,9 +234,7 @@ struct UDPConfirmation
* UDP key acknowledgement. May be sent via backchannel. Allows the
* sender to use `struct UDPBox` with the acknowledge key henceforth.
*/
-struct UDPAck
-{
-
+struct UDPAck {
/**
* Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK.
*/
@@ -267,8 +261,7 @@ struct UDPAck
* be just any global peer -- an attacker must have at least
* shared a LAN with the peer they're pretending to be here.
*/
-struct UdpBroadcastSignature
-{
+struct UdpBroadcastSignature {
/**
* Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST
*/
@@ -292,9 +285,7 @@ struct UdpBroadcastSignature
* recognized in LAN as GNUnet peers if this feature is enabled
* anyway. Also, the entire message is in cleartext.
*/
-struct UDPBroadcast
-{
-
+struct UDPBroadcast {
/**
* Sender's peer identity.
*/
@@ -312,9 +303,7 @@ struct UDPBroadcast
* UDP message box. Always sent encrypted, only allowed after
* the receiver sent a `struct UDPAck` for the base key!
*/
-struct UDPBox
-{
-
+struct UDPBox {
/**
* Key and IV identification code. KDF applied to an acknowledged
* base key and a sequence number. Sequence numbers must be used
@@ -347,9 +336,7 @@ struct SharedSecret;
* Pre-generated "kid" code (key and IV identification code) to
* quickly derive master key for a `struct UDPBox`.
*/
-struct KeyCacheEntry
-{
-
+struct KeyCacheEntry {
/**
* Kept in a DLL.
*/
@@ -396,8 +383,7 @@ struct ReceiverAddress;
/**
* Shared secret we generated for a particular sender or receiver.
*/
-struct SharedSecret
-{
+struct SharedSecret {
/**
* Kept in a DLL.
*/
@@ -462,9 +448,7 @@ struct SharedSecret
* Information we track per sender address we have recently been
* in contact with (we decrypt messages from the sender).
*/
-struct SenderAddress
-{
-
+struct SenderAddress {
/**
* To whom are we talking to.
*/
@@ -516,9 +500,7 @@ struct SenderAddress
* Information we track per receiving address we have recently been
* in contact with (encryption to receiver).
*/
-struct ReceiverAddress
-{
-
+struct ReceiverAddress {
/**
* To whom are we talking to.
*/
@@ -596,9 +578,7 @@ struct ReceiverAddress
/**
* Interface we broadcast our presence on.
*/
-struct BroadcastInterface
-{
-
+struct BroadcastInterface {
/**
* Kept in a DLL.
*/
@@ -759,25 +739,25 @@ static uint16_t my_port;
* @param bi entity to close down
*/
static void
-bi_destroy (struct BroadcastInterface *bi)
+bi_destroy(struct BroadcastInterface *bi)
{
if (AF_INET6 == bi->sa->sa_family)
- {
- /* Leave the multicast group */
- if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
- IPPROTO_IPV6,
- IPV6_LEAVE_GROUP,
- &bi->mcreq,
- sizeof (bi->mcreq)))
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
+ /* Leave the multicast group */
+ if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(udp_sock,
+ IPPROTO_IPV6,
+ IPV6_LEAVE_GROUP,
+ &bi->mcreq,
+ sizeof(bi->mcreq)))
+ {
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "setsockopt");
+ }
}
- }
- GNUNET_CONTAINER_DLL_remove (bi_head, bi_tail, bi);
- GNUNET_SCHEDULER_cancel (bi->broadcast_task);
- GNUNET_free (bi->sa);
- GNUNET_free_non_null (bi->ba);
- GNUNET_free (bi);
+ GNUNET_CONTAINER_DLL_remove(bi_head, bi_tail, bi);
+ GNUNET_SCHEDULER_cancel(bi->broadcast_task);
+ GNUNET_free(bi->sa);
+ GNUNET_free_non_null(bi->ba);
+ GNUNET_free(bi);
}
@@ -787,35 +767,35 @@ bi_destroy (struct BroadcastInterface *bi)
* @param receiver entity to close down
*/
static void
-receiver_destroy (struct ReceiverAddress *receiver)
+receiver_destroy(struct ReceiverAddress *receiver)
{
struct GNUNET_MQ_Handle *mq;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Disconnecting receiver for peer `%s'\n",
- GNUNET_i2s (&receiver->target));
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Disconnecting receiver for peer `%s'\n",
+ GNUNET_i2s(&receiver->target));
if (NULL != (mq = receiver->mq))
- {
- receiver->mq = NULL;
- GNUNET_MQ_destroy (mq);
- }
+ {
+ receiver->mq = NULL;
+ GNUNET_MQ_destroy(mq);
+ }
if (NULL != receiver->qh)
- {
- GNUNET_TRANSPORT_communicator_mq_del (receiver->qh);
- receiver->qh = NULL;
- }
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (receivers,
- &receiver->target,
- receiver));
- GNUNET_assert (receiver == GNUNET_CONTAINER_heap_remove_node (receiver->hn));
- GNUNET_STATISTICS_set (stats,
- "# receivers active",
- GNUNET_CONTAINER_multipeermap_size (receivers),
- GNUNET_NO);
- GNUNET_free (receiver->address);
- GNUNET_free (receiver->foreign_addr);
- GNUNET_free (receiver);
+ {
+ GNUNET_TRANSPORT_communicator_mq_del(receiver->qh);
+ receiver->qh = NULL;
+ }
+ GNUNET_assert(GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_remove(receivers,
+ &receiver->target,
+ receiver));
+ GNUNET_assert(receiver == GNUNET_CONTAINER_heap_remove_node(receiver->hn));
+ GNUNET_STATISTICS_set(stats,
+ "# receivers active",
+ GNUNET_CONTAINER_multipeermap_size(receivers),
+ GNUNET_NO);
+ GNUNET_free(receiver->address);
+ GNUNET_free(receiver->foreign_addr);
+ GNUNET_free(receiver);
}
@@ -825,16 +805,16 @@ receiver_destroy (struct ReceiverAddress *receiver)
* @param kce the key cache entry
*/
static void
-kce_destroy (struct KeyCacheEntry *kce)
+kce_destroy(struct KeyCacheEntry *kce)
{
struct SharedSecret *ss = kce->ss;
ss->active_kce_count--;
- GNUNET_CONTAINER_DLL_remove (ss->kce_head, ss->kce_tail, kce);
- GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (key_cache,
- &kce->kid,
- kce));
- GNUNET_free (kce);
+ GNUNET_CONTAINER_DLL_remove(ss->kce_head, ss->kce_tail, kce);
+ GNUNET_assert(GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove(key_cache,
+ &kce->kid,
+ kce));
+ GNUNET_free(kce);
}
@@ -846,24 +826,24 @@ kce_destroy (struct KeyCacheEntry *kce)
* @param kid[out] where to write the key ID
*/
static void
-get_kid (const struct GNUNET_HashCode *msec,
- uint32_t serial,
- struct GNUNET_ShortHashCode *kid)
+get_kid(const struct GNUNET_HashCode *msec,
+ uint32_t serial,
+ struct GNUNET_ShortHashCode *kid)
{
- uint32_t sid = htonl (serial);
-
- GNUNET_CRYPTO_hkdf (kid,
- sizeof (*kid),
- GCRY_MD_SHA512,
- GCRY_MD_SHA256,
- &sid,
- sizeof (sid),
- msec,
- sizeof (*msec),
- "UDP-KID",
- strlen ("UDP-KID"),
- NULL,
- 0);
+ uint32_t sid = htonl(serial);
+
+ GNUNET_CRYPTO_hkdf(kid,
+ sizeof(*kid),
+ GCRY_MD_SHA512,
+ GCRY_MD_SHA256,
+ &sid,
+ sizeof(sid),
+ msec,
+ sizeof(*msec),
+ "UDP-KID",
+ strlen("UDP-KID"),
+ NULL,
+ 0);
}
@@ -874,26 +854,26 @@ get_kid (const struct GNUNET_HashCode *msec,
* @param seq sequence number for the key cache entry
*/
static void
-kce_generate (struct SharedSecret *ss, uint32_t seq)
+kce_generate(struct SharedSecret *ss, uint32_t seq)
{
struct KeyCacheEntry *kce;
- GNUNET_assert (0 < seq);
- kce = GNUNET_new (struct KeyCacheEntry);
+ GNUNET_assert(0 < seq);
+ kce = GNUNET_new(struct KeyCacheEntry);
kce->ss = ss;
kce->sequence_number = seq;
- get_kid (&ss->master, seq, &kce->kid);
- GNUNET_CONTAINER_DLL_insert (ss->kce_head, ss->kce_tail, kce);
+ get_kid(&ss->master, seq, &kce->kid);
+ GNUNET_CONTAINER_DLL_insert(ss->kce_head, ss->kce_tail, kce);
ss->active_kce_count++;
- (void) GNUNET_CONTAINER_multishortmap_put (
+ (void)GNUNET_CONTAINER_multishortmap_put(
key_cache,
&kce->kid,
kce,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
- GNUNET_STATISTICS_set (stats,
- "# KIDs active",
- GNUNET_CONTAINER_multishortmap_size (key_cache),
- GNUNET_NO);
+ GNUNET_STATISTICS_set(stats,
+ "# KIDs active",
+ GNUNET_CONTAINER_multishortmap_size(key_cache),
+ GNUNET_NO);
}
@@ -903,31 +883,31 @@ kce_generate (struct SharedSecret *ss, uint32_t seq)
* @param ss shared secret to destroy
*/
static void
-secret_destroy (struct SharedSecret *ss)
+secret_destroy(struct SharedSecret *ss)
{
struct SenderAddress *sender;
struct ReceiverAddress *receiver;
struct KeyCacheEntry *kce;
if (NULL != (sender = ss->sender))
- {
- GNUNET_CONTAINER_DLL_remove (sender->ss_head, sender->ss_tail, ss);
- sender->num_secrets--;
- }
+ {
+ GNUNET_CONTAINER_DLL_remove(sender->ss_head, sender->ss_tail, ss);
+ sender->num_secrets--;
+ }
if (NULL != (receiver = ss->receiver))
- {
- GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
- receiver->num_secrets--;
- receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used);
- }
+ {
+ GNUNET_CONTAINER_DLL_remove(receiver->ss_head, receiver->ss_tail, ss);
+ receiver->num_secrets--;
+ receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used);
+ }
while (NULL != (kce = ss->kce_head))
- kce_destroy (kce);
- GNUNET_STATISTICS_update (stats, "# Secrets active", -1, GNUNET_NO);
- GNUNET_STATISTICS_set (stats,
- "# KIDs active",
- GNUNET_CONTAINER_multishortmap_size (key_cache),
- GNUNET_NO);
- GNUNET_free (ss);
+ kce_destroy(kce);
+ GNUNET_STATISTICS_update(stats, "# Secrets active", -1, GNUNET_NO);
+ GNUNET_STATISTICS_set(stats,
+ "# KIDs active",
+ GNUNET_CONTAINER_multishortmap_size(key_cache),
+ GNUNET_NO);
+ GNUNET_free(ss);
}
@@ -938,18 +918,18 @@ secret_destroy (struct SharedSecret *ss)
* @param sender entity to close down
*/
static void
-sender_destroy (struct SenderAddress *sender)
+sender_destroy(struct SenderAddress *sender)
{
- GNUNET_assert (
+ GNUNET_assert(
GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (senders, &sender->target, sender));
- GNUNET_assert (sender == GNUNET_CONTAINER_heap_remove_node (sender->hn));
- GNUNET_STATISTICS_set (stats,
- "# senders active",
- GNUNET_CONTAINER_multipeermap_size (senders),
- GNUNET_NO);
- GNUNET_free (sender->address);
- GNUNET_free (sender);
+ GNUNET_CONTAINER_multipeermap_remove(senders, &sender->target, sender));
+ GNUNET_assert(sender == GNUNET_CONTAINER_heap_remove_node(sender->hn));
+ GNUNET_STATISTICS_set(stats,
+ "# senders active",
+ GNUNET_CONTAINER_multipeermap_size(senders),
+ GNUNET_NO);
+ GNUNET_free(sender->address);
+ GNUNET_free(sender);
}
@@ -962,28 +942,28 @@ sender_destroy (struct SenderAddress *sender)
* @param iv[out] where to write the IV
*/
static void
-get_iv_key (const struct GNUNET_HashCode *msec,
- uint32_t serial,
- char key[AES_KEY_SIZE],
- char iv[AES_IV_SIZE])
+get_iv_key(const struct GNUNET_HashCode *msec,
+ uint32_t serial,
+ char key[AES_KEY_SIZE],
+ char iv[AES_IV_SIZE])
{
- uint32_t sid = htonl (serial);
+ uint32_t sid = htonl(serial);
char res[AES_KEY_SIZE + AES_IV_SIZE];
- GNUNET_CRYPTO_hkdf (res,
- sizeof (res),
- GCRY_MD_SHA512,
- GCRY_MD_SHA256,
- &sid,
- sizeof (sid),
- msec,
- sizeof (*msec),
- "UDP-IV-KEY",
- strlen ("UDP-IV-KEY"),
- NULL,
- 0);
- memcpy (key, res, AES_KEY_SIZE);
- memcpy (iv, &res[AES_KEY_SIZE], AES_IV_SIZE);
+ GNUNET_CRYPTO_hkdf(res,
+ sizeof(res),
+ GCRY_MD_SHA512,
+ GCRY_MD_SHA256,
+ &sid,
+ sizeof(sid),
+ msec,
+ sizeof(*msec),
+ "UDP-IV-KEY",
+ strlen("UDP-IV-KEY"),
+ NULL,
+ 0);
+ memcpy(key, res, AES_KEY_SIZE);
+ memcpy(iv, &res[AES_KEY_SIZE], AES_IV_SIZE);
}
@@ -993,11 +973,11 @@ get_iv_key (const struct GNUNET_HashCode *msec,
* @param sender address for which the timeout should be rescheduled
*/
static void
-reschedule_sender_timeout (struct SenderAddress *sender)
+reschedule_sender_timeout(struct SenderAddress *sender)
{
sender->timeout =
- GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
- GNUNET_CONTAINER_heap_update_cost (sender->hn, sender->timeout.abs_value_us);
+ GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+ GNUNET_CONTAINER_heap_update_cost(sender->hn, sender->timeout.abs_value_us);
}
@@ -1007,12 +987,12 @@ reschedule_sender_timeout (struct SenderAddress *sender)
* @param receiver address for which the timeout should be rescheduled
*/
static void
-reschedule_receiver_timeout (struct ReceiverAddress *receiver)
+reschedule_receiver_timeout(struct ReceiverAddress *receiver)
{
receiver->timeout =
- GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
- GNUNET_CONTAINER_heap_update_cost (receiver->hn,
- receiver->timeout.abs_value_us);
+ GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+ GNUNET_CONTAINER_heap_update_cost(receiver->hn,
+ receiver->timeout.abs_value_us);
}
@@ -1022,7 +1002,7 @@ reschedule_receiver_timeout (struct ReceiverAddress *receiver)
* @param cls unused, NULL
*/
static void
-check_timeouts (void *cls)
+check_timeouts(void *cls)
{
struct GNUNET_TIME_Relative st;
struct GNUNET_TIME_Relative rt;
@@ -1030,27 +1010,27 @@ check_timeouts (void *cls)
struct ReceiverAddress *receiver;
struct SenderAddress *sender;
- (void) cls;
+ (void)cls;
timeout_task = NULL;
rt = GNUNET_TIME_UNIT_FOREVER_REL;
- while (NULL != (receiver = GNUNET_CONTAINER_heap_peek (receivers_heap)))
- {
- rt = GNUNET_TIME_absolute_get_remaining (receiver->timeout);
- if (0 != rt.rel_value_us)
- break;
- receiver_destroy (receiver);
- }
+ while (NULL != (receiver = GNUNET_CONTAINER_heap_peek(receivers_heap)))
+ {
+ rt = GNUNET_TIME_absolute_get_remaining(receiver->timeout);
+ if (0 != rt.rel_value_us)
+ break;
+ receiver_destroy(receiver);
+ }
st = GNUNET_TIME_UNIT_FOREVER_REL;
- while (NULL != (sender = GNUNET_CONTAINER_heap_peek (senders_heap)))
- {
- st = GNUNET_TIME_absolute_get_remaining (sender->timeout);
- if (0 != st.rel_value_us)
- break;
- sender_destroy (sender);
- }
- delay = GNUNET_TIME_relative_min (rt, st);
+ while (NULL != (sender = GNUNET_CONTAINER_heap_peek(senders_heap)))
+ {
+ st = GNUNET_TIME_absolute_get_remaining(sender->timeout);
+ if (0 != st.rel_value_us)
+ break;
+ sender_destroy(sender);
+ }
+ delay = GNUNET_TIME_relative_min(rt, st);
if (delay.rel_value_us < GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
- timeout_task = GNUNET_SCHEDULER_add_delayed (delay, &check_timeouts, NULL);
+ timeout_task = GNUNET_SCHEDULER_add_delayed(delay, &check_timeouts, NULL);
}
@@ -1060,20 +1040,20 @@ check_timeouts (void *cls)
* @param ss[in,out] data structure to complete
*/
static void
-calculate_cmac (struct SharedSecret *ss)
+calculate_cmac(struct SharedSecret *ss)
{
- GNUNET_CRYPTO_hkdf (&ss->cmac,
- sizeof (ss->cmac),
- GCRY_MD_SHA512,
- GCRY_MD_SHA256,
- "CMAC",
- strlen ("CMAC"),
- &ss->master,
- sizeof (ss->master),
- "UDP-CMAC",
- strlen ("UDP-CMAC"),
- NULL,
- 0);
+ GNUNET_CRYPTO_hkdf(&ss->cmac,
+ sizeof(ss->cmac),
+ GCRY_MD_SHA512,
+ GCRY_MD_SHA256,
+ "CMAC",
+ strlen("CMAC"),
+ &ss->master,
+ sizeof(ss->master),
+ "UDP-CMAC",
+ strlen("UDP-CMAC"),
+ NULL,
+ 0);
}
@@ -1086,36 +1066,36 @@ calculate_cmac (struct SharedSecret *ss)
* @param plaintext_len number of bytes of plaintext received
*/
static void
-pass_plaintext_to_core (struct SenderAddress *sender,
- const void *plaintext,
- size_t plaintext_len)
+pass_plaintext_to_core(struct SenderAddress *sender,
+ const void *plaintext,
+ size_t plaintext_len)
{
const struct GNUNET_MessageHeader *hdr = plaintext;
- while (ntohs (hdr->size) < plaintext_len)
- {
- GNUNET_STATISTICS_update (stats,
- "# bytes given to core",
- ntohs (hdr->size),
- GNUNET_NO);
- (void)
- GNUNET_TRANSPORT_communicator_receive (ch,
- &sender->target,
- hdr,
- ADDRESS_VALIDITY_PERIOD,
- NULL /* no flow control possible */
- ,
- NULL);
- /* move on to next message, if any */
- plaintext_len -= ntohs (hdr->size);
- if (plaintext_len < sizeof (*hdr))
- break;
- hdr = plaintext + ntohs (hdr->size);
- }
- GNUNET_STATISTICS_update (stats,
- "# bytes padding discarded",
- plaintext_len,
- GNUNET_NO);
+ while (ntohs(hdr->size) < plaintext_len)
+ {
+ GNUNET_STATISTICS_update(stats,
+ "# bytes given to core",
+ ntohs(hdr->size),
+ GNUNET_NO);
+ (void)
+ GNUNET_TRANSPORT_communicator_receive(ch,
+ &sender->target,
+ hdr,
+ ADDRESS_VALIDITY_PERIOD,
+ NULL /* no flow control possible */
+ ,
+ NULL);
+ /* move on to next message, if any */
+ plaintext_len -= ntohs(hdr->size);
+ if (plaintext_len < sizeof(*hdr))
+ break;
+ hdr = plaintext + ntohs(hdr->size);
+ }
+ GNUNET_STATISTICS_update(stats,
+ "# bytes padding discarded",
+ plaintext_len,
+ GNUNET_NO);
}
@@ -1128,20 +1108,20 @@ pass_plaintext_to_core (struct SenderAddress *sender,
* @param cipher[out] cipher to initialize
*/
static void
-setup_cipher (const struct GNUNET_HashCode *msec,
- uint32_t serial,
- gcry_cipher_hd_t *cipher)
+setup_cipher(const struct GNUNET_HashCode *msec,
+ uint32_t serial,
+ gcry_cipher_hd_t *cipher)
{
char key[AES_KEY_SIZE];
char iv[AES_IV_SIZE];
- gcry_cipher_open (cipher,
- GCRY_CIPHER_AES256 /* low level: go for speed */,
- GCRY_CIPHER_MODE_GCM,
- 0 /* flags */);
- get_iv_key (msec, serial, key, iv);
- gcry_cipher_setkey (*cipher, key, sizeof (key));
- gcry_cipher_setiv (*cipher, iv, sizeof (iv));
+ gcry_cipher_open(cipher,
+ GCRY_CIPHER_AES256 /* low level: go for speed */,
+ GCRY_CIPHER_MODE_GCM,
+ 0 /* flags */);
+ get_iv_key(msec, serial, key, iv);
+ gcry_cipher_setkey(*cipher, key, sizeof(key));
+ gcry_cipher_setiv(*cipher, iv, sizeof(iv));
}
@@ -1158,29 +1138,29 @@ setup_cipher (const struct GNUNET_HashCode *msec,
* @return #GNUNET_OK on success
*/
static int
-try_decrypt (const struct SharedSecret *ss,
- const char tag[GCM_TAG_SIZE],
- uint32_t serial,
- const char *in_buf,
- size_t in_buf_size,
- char *out_buf)
+try_decrypt(const struct SharedSecret *ss,
+ const char tag[GCM_TAG_SIZE],
+ uint32_t serial,
+ const char *in_buf,
+ size_t in_buf_size,
+ char *out_buf)
{
gcry_cipher_hd_t cipher;
- setup_cipher (&ss->master, serial, &cipher);
- GNUNET_assert (
+ setup_cipher(&ss->master, serial, &cipher);
+ GNUNET_assert(
0 ==
- gcry_cipher_decrypt (cipher, out_buf, in_buf_size, in_buf, in_buf_size));
- if (0 != gcry_cipher_checktag (cipher, tag, GCM_TAG_SIZE))
- {
- gcry_cipher_close (cipher);
- GNUNET_STATISTICS_update (stats,
- "# AEAD authentication failures",
- 1,
- GNUNET_NO);
- return GNUNET_SYSERR;
- }
- gcry_cipher_close (cipher);
+ gcry_cipher_decrypt(cipher, out_buf, in_buf_size, in_buf, in_buf_size));
+ if (0 != gcry_cipher_checktag(cipher, tag, GCM_TAG_SIZE))
+ {
+ gcry_cipher_close(cipher);
+ GNUNET_STATISTICS_update(stats,
+ "# AEAD authentication failures",
+ 1,
+ GNUNET_NO);
+ return GNUNET_SYSERR;
+ }
+ gcry_cipher_close(cipher);
return GNUNET_OK;
}
@@ -1192,12 +1172,12 @@ try_decrypt (const struct SharedSecret *ss,
* @return new shared secret
*/
static struct SharedSecret *
-setup_shared_secret_dec (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral)
+setup_shared_secret_dec(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral)
{
struct SharedSecret *ss;
- ss = GNUNET_new (struct SharedSecret);
- GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &ss->master);
+ ss = GNUNET_new(struct SharedSecret);
+ GNUNET_CRYPTO_eddsa_ecdh(my_private_key, ephemeral, &ss->master);
return ss;
}
@@ -1210,20 +1190,20 @@ setup_shared_secret_dec (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral)
* @return new shared secret
*/
static struct SharedSecret *
-setup_shared_secret_enc (const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral,
- struct ReceiverAddress *receiver)
+setup_shared_secret_enc(const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral,
+ struct ReceiverAddress *receiver)
{
struct SharedSecret *ss;
- ss = GNUNET_new (struct SharedSecret);
- GNUNET_CRYPTO_ecdh_eddsa (ephemeral,
- &receiver->target.public_key,
- &ss->master);
- calculate_cmac (ss);
+ ss = GNUNET_new(struct SharedSecret);
+ GNUNET_CRYPTO_ecdh_eddsa(ephemeral,
+ &receiver->target.public_key,
+ &ss->master);
+ calculate_cmac(ss);
ss->receiver = receiver;
- GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
+ GNUNET_CONTAINER_DLL_insert(receiver->ss_head, receiver->ss_tail, ss);
receiver->num_secrets++;
- GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update(stats, "# Secrets active", 1, GNUNET_NO);
return ss;
}
@@ -1236,7 +1216,7 @@ setup_shared_secret_enc (const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral,
* @param receiver receiver to setup MQ for
*/
static void
-setup_receiver_mq (struct ReceiverAddress *receiver);
+setup_receiver_mq(struct ReceiverAddress *receiver);
/**
@@ -1250,36 +1230,36 @@ setup_receiver_mq (struct ReceiverAddress *receiver);
* @return #GNUNET_YES to continue to iterate
*/
static int
-handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
+handle_ack(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
{
const struct UDPAck *ack = cls;
struct ReceiverAddress *receiver = value;
- (void) pid;
+ (void)pid;
for (struct SharedSecret *ss = receiver->ss_head; NULL != ss; ss = ss->next)
- {
- if (0 == memcmp (&ack->cmac, &ss->cmac, sizeof (struct GNUNET_HashCode)))
{
- uint32_t allowed;
-
- allowed = ntohl (ack->sequence_max);
-
- if (allowed > ss->sequence_allowed)
- {
- receiver->acks_available += (allowed - ss->sequence_allowed);
- if ((allowed - ss->sequence_allowed) == receiver->acks_available)
+ if (0 == memcmp(&ack->cmac, &ss->cmac, sizeof(struct GNUNET_HashCode)))
{
- /* we just incremented from zero => MTU change! */
- setup_receiver_mq (receiver);
+ uint32_t allowed;
+
+ allowed = ntohl(ack->sequence_max);
+
+ if (allowed > ss->sequence_allowed)
+ {
+ receiver->acks_available += (allowed - ss->sequence_allowed);
+ if ((allowed - ss->sequence_allowed) == receiver->acks_available)
+ {
+ /* we just incremented from zero => MTU change! */
+ setup_receiver_mq(receiver);
+ }
+ ss->sequence_allowed = allowed;
+ /* move ss to head to avoid discarding it anytime soon! */
+ GNUNET_CONTAINER_DLL_remove(receiver->ss_head, receiver->ss_tail, ss);
+ GNUNET_CONTAINER_DLL_insert(receiver->ss_head, receiver->ss_tail, ss);
+ }
+ return GNUNET_NO;
}
- ss->sequence_allowed = allowed;
- /* move ss to head to avoid discarding it anytime soon! */
- GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
- GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
- }
- return GNUNET_NO;
}
- }
return GNUNET_YES;
}
@@ -1293,39 +1273,41 @@ handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
* @param buf_size number of bytes in @a buf
*/
static void
-try_handle_plaintext (struct SenderAddress *sender,
- const void *buf,
- size_t buf_size)
+try_handle_plaintext(struct SenderAddress *sender,
+ const void *buf,
+ size_t buf_size)
{
const struct GNUNET_MessageHeader *hdr =
- (const struct GNUNET_MessageHeader *) buf;
- const struct UDPAck *ack = (const struct UDPAck *) buf;
+ (const struct GNUNET_MessageHeader *)buf;
+ const struct UDPAck *ack = (const struct UDPAck *)buf;
uint16_t type;
- if (sizeof (*hdr) > buf_size)
+ if (sizeof(*hdr) > buf_size)
return; /* not even a header */
- if (ntohs (hdr->size) > buf_size)
+ if (ntohs(hdr->size) > buf_size)
return; /* not even a header */
- type = ntohs (hdr->type);
+ type = ntohs(hdr->type);
switch (type)
- {
- case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK:
- /* lookup master secret by 'cmac', then update sequence_max */
- GNUNET_CONTAINER_multipeermap_get_multiple (receivers,
- &sender->target,
- &handle_ack,
- (void *) ack);
- /* There could be more messages after the ACK, handle those as well */
- buf += ntohs (hdr->size);
- buf_size -= ntohs (hdr->size);
- pass_plaintext_to_core (sender, buf, buf_size);
- break;
- case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD:
- /* skip padding */
- break;
- default:
- pass_plaintext_to_core (sender, buf, buf_size);
- }
+ {
+ case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK:
+ /* lookup master secret by 'cmac', then update sequence_max */
+ GNUNET_CONTAINER_multipeermap_get_multiple(receivers,
+ &sender->target,
+ &handle_ack,
+ (void *)ack);
+ /* There could be more messages after the ACK, handle those as well */
+ buf += ntohs(hdr->size);
+ buf_size -= ntohs(hdr->size);
+ pass_plaintext_to_core(sender, buf, buf_size);
+ break;
+
+ case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD:
+ /* skip padding */
+ break;
+
+ default:
+ pass_plaintext_to_core(sender, buf, buf_size);
+ }
}
@@ -1338,29 +1320,29 @@ try_handle_plaintext (struct SenderAddress *sender,
* @param ss shared secret to generate ACKs for
*/
static void
-consider_ss_ack (struct SharedSecret *ss)
+consider_ss_ack(struct SharedSecret *ss)
{
- GNUNET_assert (NULL != ss->sender);
+ GNUNET_assert(NULL != ss->sender);
/* drop ancient KeyCacheEntries */
while ((NULL != ss->kce_head) &&
(MAX_SQN_DELTA <
ss->kce_head->sequence_number - ss->kce_tail->sequence_number))
- kce_destroy (ss->kce_tail);
+ kce_destroy(ss->kce_tail);
if (ss->active_kce_count < KCN_THRESHOLD)
- {
- struct UDPAck ack;
-
- while (ss->active_kce_count < KCN_TARGET)
- kce_generate (ss, ++ss->sequence_allowed);
- ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK);
- ack.header.size = htons (sizeof (ack));
- ack.sequence_max = htonl (ss->sequence_allowed);
- ack.cmac = ss->cmac;
- GNUNET_TRANSPORT_communicator_notify (ch,
- &ss->sender->target,
- COMMUNICATOR_ADDRESS_PREFIX,
- &ack.header);
- }
+ {
+ struct UDPAck ack;
+
+ while (ss->active_kce_count < KCN_TARGET)
+ kce_generate(ss, ++ss->sequence_allowed);
+ ack.header.type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK);
+ ack.header.size = htons(sizeof(ack));
+ ack.sequence_max = htonl(ss->sequence_allowed);
+ ack.cmac = ss->cmac;
+ GNUNET_TRANSPORT_communicator_notify(ch,
+ &ss->sender->target,
+ COMMUNICATOR_ADDRESS_PREFIX,
+ &ack.header);
+ }
}
@@ -1372,43 +1354,42 @@ consider_ss_ack (struct SharedSecret *ss)
* @param kce key index to decrypt @a box
*/
static void
-decrypt_box (const struct UDPBox *box,
- size_t box_len,
- struct KeyCacheEntry *kce)
+decrypt_box(const struct UDPBox *box,
+ size_t box_len,
+ struct KeyCacheEntry *kce)
{
struct SharedSecret *ss = kce->ss;
- char out_buf[box_len - sizeof (*box)];
-
- GNUNET_assert (NULL != ss->sender);
- if (GNUNET_OK != try_decrypt (ss,
- box->gcm_tag,
- kce->sequence_number,
- (const char *) &box[1],
- sizeof (out_buf),
- out_buf))
- {
- GNUNET_STATISTICS_update (stats,
- "# Decryption failures with valid KCE",
- 1,
- GNUNET_NO);
- kce_destroy (kce);
- return;
- }
- kce_destroy (kce);
- GNUNET_STATISTICS_update (stats,
- "# bytes decrypted with BOX",
- sizeof (out_buf),
- GNUNET_NO);
- try_handle_plaintext (ss->sender, out_buf, sizeof (out_buf));
- consider_ss_ack (ss);
+ char out_buf[box_len - sizeof(*box)];
+
+ GNUNET_assert(NULL != ss->sender);
+ if (GNUNET_OK != try_decrypt(ss,
+ box->gcm_tag,
+ kce->sequence_number,
+ (const char *)&box[1],
+ sizeof(out_buf),
+ out_buf))
+ {
+ GNUNET_STATISTICS_update(stats,
+ "# Decryption failures with valid KCE",
+ 1,
+ GNUNET_NO);
+ kce_destroy(kce);
+ return;
+ }
+ kce_destroy(kce);
+ GNUNET_STATISTICS_update(stats,
+ "# bytes decrypted with BOX",
+ sizeof(out_buf),
+ GNUNET_NO);
+ try_handle_plaintext(ss->sender, out_buf, sizeof(out_buf));
+ consider_ss_ack(ss);
}
/**
* Closure for #find_sender_by_address()
*/
-struct SearchContext
-{
+struct SearchContext {
/**
* Address we are looking for.
*/
@@ -1435,19 +1416,19 @@ struct SearchContext
* @return #GNUNET_YES if not found (continue to search), #GNUNET_NO if found
*/
static int
-find_sender_by_address (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+find_sender_by_address(void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct SearchContext *sc = cls;
struct SenderAddress *sender = value;
if ((sender->address_len == sc->address_len) &&
- (0 == memcmp (sender->address, sc->address, sender->address_len)))
- {
- sc->sender = sender;
- return GNUNET_NO; /* stop iterating! */
- }
+ (0 == memcmp(sender->address, sc->address, sender->address_len)))
+ {
+ sc->sender = sender;
+ return GNUNET_NO; /* stop iterating! */
+ }
return GNUNET_YES;
}
@@ -1464,45 +1445,45 @@ find_sender_by_address (void *cls,
* decrypting data from @a target
*/
static struct SenderAddress *
-setup_sender (const struct GNUNET_PeerIdentity *target,
- const struct sockaddr *address,
- socklen_t address_len)
+setup_sender(const struct GNUNET_PeerIdentity *target,
+ const struct sockaddr *address,
+ socklen_t address_len)
{
struct SenderAddress *sender;
- struct SearchContext sc = {.address = address,
- .address_len = address_len,
- .sender = NULL};
-
- GNUNET_CONTAINER_multipeermap_get_multiple (senders,
- target,
- &find_sender_by_address,
- &sc);
+ struct SearchContext sc = { .address = address,
+ .address_len = address_len,
+ .sender = NULL };
+
+ GNUNET_CONTAINER_multipeermap_get_multiple(senders,
+ target,
+ &find_sender_by_address,
+ &sc);
if (NULL != sc.sender)
- {
- reschedule_sender_timeout (sc.sender);
- return sc.sender;
- }
- sender = GNUNET_new (struct SenderAddress);
+ {
+ reschedule_sender_timeout(sc.sender);
+ return sc.sender;
+ }
+ sender = GNUNET_new(struct SenderAddress);
sender->target = *target;
- sender->address = GNUNET_memdup (address, address_len);
+ sender->address = GNUNET_memdup(address, address_len);
sender->address_len = address_len;
- (void) GNUNET_CONTAINER_multipeermap_put (
+ (void)GNUNET_CONTAINER_multipeermap_put(
senders,
&sender->target,
sender,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
- GNUNET_STATISTICS_set (stats,
- "# senders active",
- GNUNET_CONTAINER_multipeermap_size (receivers),
- GNUNET_NO);
+ GNUNET_STATISTICS_set(stats,
+ "# senders active",
+ GNUNET_CONTAINER_multipeermap_size(receivers),
+ GNUNET_NO);
sender->timeout =
- GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
- sender->hn = GNUNET_CONTAINER_heap_insert (senders_heap,
- sender,
- sender->timeout.abs_value_us);
- sender->nt = GNUNET_NT_scanner_get_type (is, address, address_len);
+ GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+ sender->hn = GNUNET_CONTAINER_heap_insert(senders_heap,
+ sender,
+ sender->timeout.abs_value_us);
+ sender->nt = GNUNET_NT_scanner_get_type(is, address, address_len);
if (NULL == timeout_task)
- timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL);
+ timeout_task = GNUNET_SCHEDULER_add_now(&check_timeouts, NULL);
return sender;
}
@@ -1515,21 +1496,21 @@ setup_sender (const struct GNUNET_PeerIdentity *target,
* @return #GNUNET_OK if signature is valid
*/
static int
-verify_confirmation (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral,
- const struct UDPConfirmation *uc)
+verify_confirmation(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral,
+ const struct UDPConfirmation *uc)
{
struct UdpHandshakeSignature uhs;
- uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE);
- uhs.purpose.size = htonl (sizeof (uhs));
+ uhs.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE);
+ uhs.purpose.size = htonl(sizeof(uhs));
uhs.sender = uc->sender;
uhs.receiver = my_identity;
uhs.ephemeral = *ephemeral;
uhs.monotonic_time = uc->monotonic_time;
- return GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE,
- &uhs.purpose,
- &uc->sender_sig,
- &uc->sender.public_key);
+ return GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE,
+ &uhs.purpose,
+ &uc->sender_sig,
+ &uc->sender.public_key);
}
@@ -1542,28 +1523,30 @@ verify_confirmation (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral,
* @return string representation of @a address
*/
static char *
-sockaddr_to_udpaddr_string (const struct sockaddr *address,
- socklen_t address_len)
+sockaddr_to_udpaddr_string(const struct sockaddr *address,
+ socklen_t address_len)
{
char *ret;
switch (address->sa_family)
- {
- case AF_INET:
- GNUNET_asprintf (&ret,
- "%s-%s",
- COMMUNICATOR_ADDRESS_PREFIX,
- GNUNET_a2s (address, address_len));
- break;
- case AF_INET6:
- GNUNET_asprintf (&ret,
- "%s-%s",
- COMMUNICATOR_ADDRESS_PREFIX,
- GNUNET_a2s (address, address_len));
- break;
- default:
- GNUNET_assert (0);
- }
+ {
+ case AF_INET:
+ GNUNET_asprintf(&ret,
+ "%s-%s",
+ COMMUNICATOR_ADDRESS_PREFIX,
+ GNUNET_a2s(address, address_len));
+ break;
+
+ case AF_INET6:
+ GNUNET_asprintf(&ret,
+ "%s-%s",
+ COMMUNICATOR_ADDRESS_PREFIX,
+ GNUNET_a2s(address, address_len));
+ break;
+
+ default:
+ GNUNET_assert(0);
+ }
return ret;
}
@@ -1574,137 +1557,137 @@ sockaddr_to_udpaddr_string (const struct sockaddr *address,
* @param cls NULL
*/
static void
-sock_read (void *cls)
+sock_read(void *cls)
{
struct sockaddr_storage sa;
- socklen_t salen = sizeof (sa);
+ socklen_t salen = sizeof(sa);
char buf[UINT16_MAX];
ssize_t rcvd;
- (void) cls;
- read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
- udp_sock,
- &sock_read,
- NULL);
- rcvd = GNUNET_NETWORK_socket_recvfrom (udp_sock,
- buf,
- sizeof (buf),
- (struct sockaddr *) &sa,
- &salen);
+ (void)cls;
+ read_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+ udp_sock,
+ &sock_read,
+ NULL);
+ rcvd = GNUNET_NETWORK_socket_recvfrom(udp_sock,
+ buf,
+ sizeof(buf),
+ (struct sockaddr *)&sa,
+ &salen);
if (-1 == rcvd)
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
- return;
- }
+ {
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv");
+ return;
+ }
/* first, see if it is a UDPBox */
- if (rcvd > sizeof (struct UDPBox))
- {
- const struct UDPBox *box;
- struct KeyCacheEntry *kce;
-
- box = (const struct UDPBox *) buf;
- kce = GNUNET_CONTAINER_multishortmap_get (key_cache, &box->kid);
- if (NULL != kce)
+ if (rcvd > sizeof(struct UDPBox))
{
- decrypt_box (box, (size_t) rcvd, kce);
- return;
+ const struct UDPBox *box;
+ struct KeyCacheEntry *kce;
+
+ box = (const struct UDPBox *)buf;
+ kce = GNUNET_CONTAINER_multishortmap_get(key_cache, &box->kid);
+ if (NULL != kce)
+ {
+ decrypt_box(box, (size_t)rcvd, kce);
+ return;
+ }
}
- }
/* next, check if it is a broadcast */
- if (sizeof (struct UDPBroadcast) == rcvd)
- {
- const struct UDPBroadcast *ub;
- struct UdpBroadcastSignature uhs;
-
- ub = (const struct UDPBroadcast *) buf;
- uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST);
- uhs.purpose.size = htonl (sizeof (uhs));
- uhs.sender = ub->sender;
- GNUNET_CRYPTO_hash (&sa, salen, &uhs.h_address);
- if (GNUNET_OK ==
- GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST,
- &uhs.purpose,
- &ub->sender_sig,
- &ub->sender.public_key))
+ if (sizeof(struct UDPBroadcast) == rcvd)
{
- char *addr_s;
- enum GNUNET_NetworkType nt;
-
- addr_s =
- sockaddr_to_udpaddr_string ((const struct sockaddr *) &sa, salen);
- GNUNET_STATISTICS_update (stats, "# broadcasts received", 1, GNUNET_NO);
- /* use our own mechanism to determine network type */
- nt =
- GNUNET_NT_scanner_get_type (is, (const struct sockaddr *) &sa, salen);
- GNUNET_TRANSPORT_application_validate (ah, &ub->sender, nt, addr_s);
- GNUNET_free (addr_s);
- return;
+ const struct UDPBroadcast *ub;
+ struct UdpBroadcastSignature uhs;
+
+ ub = (const struct UDPBroadcast *)buf;
+ uhs.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST);
+ uhs.purpose.size = htonl(sizeof(uhs));
+ uhs.sender = ub->sender;
+ GNUNET_CRYPTO_hash(&sa, salen, &uhs.h_address);
+ if (GNUNET_OK ==
+ GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST,
+ &uhs.purpose,
+ &ub->sender_sig,
+ &ub->sender.public_key))
+ {
+ char *addr_s;
+ enum GNUNET_NetworkType nt;
+
+ addr_s =
+ sockaddr_to_udpaddr_string((const struct sockaddr *)&sa, salen);
+ GNUNET_STATISTICS_update(stats, "# broadcasts received", 1, GNUNET_NO);
+ /* use our own mechanism to determine network type */
+ nt =
+ GNUNET_NT_scanner_get_type(is, (const struct sockaddr *)&sa, salen);
+ GNUNET_TRANSPORT_application_validate(ah, &ub->sender, nt, addr_s);
+ GNUNET_free(addr_s);
+ return;
+ }
+ /* continue with KX, mostly for statistics... */
}
- /* continue with KX, mostly for statistics... */
- }
/* finally, test if it is a KX */
- if (rcvd < sizeof (struct UDPConfirmation) + sizeof (struct InitialKX))
- {
- GNUNET_STATISTICS_update (stats,
- "# messages dropped (no kid, too small for KX)",
- 1,
- GNUNET_NO);
- return;
- }
+ if (rcvd < sizeof(struct UDPConfirmation) + sizeof(struct InitialKX))
+ {
+ GNUNET_STATISTICS_update(stats,
+ "# messages dropped (no kid, too small for KX)",
+ 1,
+ GNUNET_NO);
+ return;
+ }
{
const struct InitialKX *kx;
struct SharedSecret *ss;
- char pbuf[rcvd - sizeof (struct InitialKX)];
+ char pbuf[rcvd - sizeof(struct InitialKX)];
const struct UDPConfirmation *uc;
struct SenderAddress *sender;
- kx = (const struct InitialKX *) buf;
- ss = setup_shared_secret_dec (&kx->ephemeral);
- if (GNUNET_OK != try_decrypt (ss,
- kx->gcm_tag,
- 0,
- &buf[sizeof (*kx)],
- sizeof (pbuf),
- pbuf))
- {
- GNUNET_free (ss);
- GNUNET_STATISTICS_update (
- stats,
- "# messages dropped (no kid, AEAD decryption failed)",
- 1,
- GNUNET_NO);
- return;
- }
- uc = (const struct UDPConfirmation *) pbuf;
- if (GNUNET_OK != verify_confirmation (&kx->ephemeral, uc))
- {
- GNUNET_break_op (0);
- GNUNET_free (ss);
- GNUNET_STATISTICS_update (stats,
- "# messages dropped (sender signature invalid)",
- 1,
- GNUNET_NO);
- return;
- }
- calculate_cmac (ss);
- sender = setup_sender (&uc->sender, (const struct sockaddr *) &sa, salen);
+ kx = (const struct InitialKX *)buf;
+ ss = setup_shared_secret_dec(&kx->ephemeral);
+ if (GNUNET_OK != try_decrypt(ss,
+ kx->gcm_tag,
+ 0,
+ &buf[sizeof(*kx)],
+ sizeof(pbuf),
+ pbuf))
+ {
+ GNUNET_free(ss);
+ GNUNET_STATISTICS_update(
+ stats,
+ "# messages dropped (no kid, AEAD decryption failed)",
+ 1,
+ GNUNET_NO);
+ return;
+ }
+ uc = (const struct UDPConfirmation *)pbuf;
+ if (GNUNET_OK != verify_confirmation(&kx->ephemeral, uc))
+ {
+ GNUNET_break_op(0);
+ GNUNET_free(ss);
+ GNUNET_STATISTICS_update(stats,
+ "# messages dropped (sender signature invalid)",
+ 1,
+ GNUNET_NO);
+ return;
+ }
+ calculate_cmac(ss);
+ sender = setup_sender(&uc->sender, (const struct sockaddr *)&sa, salen);
ss->sender = sender;
- GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss);
+ GNUNET_CONTAINER_DLL_insert(sender->ss_head, sender->ss_tail, ss);
sender->num_secrets++;
- GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
- GNUNET_STATISTICS_update (stats,
- "# messages decrypted without BOX",
- 1,
- GNUNET_NO);
- try_handle_plaintext (sender, &uc[1], sizeof (pbuf) - sizeof (*uc));
- consider_ss_ack (ss);
+ GNUNET_STATISTICS_update(stats, "# Secrets active", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update(stats,
+ "# messages decrypted without BOX",
+ 1,
+ GNUNET_NO);
+ try_handle_plaintext(sender, &uc[1], sizeof(pbuf) - sizeof(*uc));
+ consider_ss_ack(ss);
if (sender->num_secrets > MAX_SECRETS)
- secret_destroy (sender->ss_tail);
+ secret_destroy(sender->ss_tail);
}
}
@@ -1717,7 +1700,7 @@ sock_read (void *cls)
* @return converted bindto specification
*/
static struct sockaddr *
-udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
+udp_address_to_sockaddr(const char *bindto, socklen_t *sock_len)
{
struct sockaddr *in;
unsigned int port;
@@ -1725,88 +1708,88 @@ udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
char *colon;
char *cp;
- if (1 == sscanf (bindto, "%u%1s", &port, dummy))
- {
- /* interpreting value as just a PORT number */
- if (port > UINT16_MAX)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "BINDTO specification `%s' invalid: value too large for port\n",
- bindto);
- return NULL;
- }
- if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
- (GNUNET_YES ==
- GNUNET_CONFIGURATION_get_value_yesno (cfg,
- COMMUNICATOR_CONFIG_SECTION,
- "DISABLE_V6")))
+ if (1 == sscanf(bindto, "%u%1s", &port, dummy))
{
- struct sockaddr_in *i4;
+ /* interpreting value as just a PORT number */
+ if (port > UINT16_MAX)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "BINDTO specification `%s' invalid: value too large for port\n",
+ bindto);
+ return NULL;
+ }
+ if ((GNUNET_NO == GNUNET_NETWORK_test_pf(PF_INET6)) ||
+ (GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_yesno(cfg,
+ COMMUNICATOR_CONFIG_SECTION,
+ "DISABLE_V6")))
+ {
+ struct sockaddr_in *i4;
- i4 = GNUNET_malloc (sizeof (struct sockaddr_in));
- i4->sin_family = AF_INET;
- i4->sin_port = htons ((uint16_t) port);
- *sock_len = sizeof (struct sockaddr_in);
- in = (struct sockaddr *) i4;
- }
- else
- {
- struct sockaddr_in6 *i6;
+ i4 = GNUNET_malloc(sizeof(struct sockaddr_in));
+ i4->sin_family = AF_INET;
+ i4->sin_port = htons((uint16_t)port);
+ *sock_len = sizeof(struct sockaddr_in);
+ in = (struct sockaddr *)i4;
+ }
+ else
+ {
+ struct sockaddr_in6 *i6;
- i6 = GNUNET_malloc (sizeof (struct sockaddr_in6));
- i6->sin6_family = AF_INET6;
- i6->sin6_port = htons ((uint16_t) port);
- *sock_len = sizeof (struct sockaddr_in6);
- in = (struct sockaddr *) i6;
+ i6 = GNUNET_malloc(sizeof(struct sockaddr_in6));
+ i6->sin6_family = AF_INET6;
+ i6->sin6_port = htons((uint16_t)port);
+ *sock_len = sizeof(struct sockaddr_in6);
+ in = (struct sockaddr *)i6;
+ }
+ return in;
}
- return in;
- }
- cp = GNUNET_strdup (bindto);
- colon = strrchr (cp, ':');
+ cp = GNUNET_strdup(bindto);
+ colon = strrchr(cp, ':');
if (NULL != colon)
- {
- /* interpet value after colon as port */
- *colon = '\0';
- colon++;
- if (1 == sscanf (colon, "%u%1s", &port, dummy))
{
- /* interpreting value as just a PORT number */
- if (port > UINT16_MAX)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "BINDTO specification `%s' invalid: value too large for port\n",
- bindto);
- GNUNET_free (cp);
- return NULL;
- }
+ /* interpet value after colon as port */
+ *colon = '\0';
+ colon++;
+ if (1 == sscanf(colon, "%u%1s", &port, dummy))
+ {
+ /* interpreting value as just a PORT number */
+ if (port > UINT16_MAX)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "BINDTO specification `%s' invalid: value too large for port\n",
+ bindto);
+ GNUNET_free(cp);
+ return NULL;
+ }
+ }
+ else
+ {
+ GNUNET_log(
+ GNUNET_ERROR_TYPE_ERROR,
+ "BINDTO specification `%s' invalid: last ':' not followed by number\n",
+ bindto);
+ GNUNET_free(cp);
+ return NULL;
+ }
}
- else
+ else
{
- GNUNET_log (
- GNUNET_ERROR_TYPE_ERROR,
- "BINDTO specification `%s' invalid: last ':' not followed by number\n",
- bindto);
- GNUNET_free (cp);
- return NULL;
+ /* interpret missing port as 0, aka pick any free one */
+ port = 0;
}
- }
- else
- {
- /* interpret missing port as 0, aka pick any free one */
- port = 0;
- }
{
/* try IPv4 */
struct sockaddr_in v4;
- if (1 == inet_pton (AF_INET, cp, &v4))
- {
- v4.sin_port = htons ((uint16_t) port);
- in = GNUNET_memdup (&v4, sizeof (v4));
- *sock_len = sizeof (v4);
- GNUNET_free (cp);
- return in;
- }
+ if (1 == inet_pton(AF_INET, cp, &v4))
+ {
+ v4.sin_port = htons((uint16_t)port);
+ in = GNUNET_memdup(&v4, sizeof(v4));
+ *sock_len = sizeof(v4);
+ GNUNET_free(cp);
+ return in;
+ }
}
{
/* try IPv6 */
@@ -1814,22 +1797,22 @@ udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
const char *start;
start = cp;
- if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
- {
- start++; /* skip over '[' */
- cp[strlen (cp) - 1] = '\0'; /* eat ']' */
- }
- if (1 == inet_pton (AF_INET6, start, &v6))
- {
- v6.sin6_port = htons ((uint16_t) port);
- in = GNUNET_memdup (&v6, sizeof (v6));
- *sock_len = sizeof (v6);
- GNUNET_free (cp);
- return in;
- }
+ if (('[' == *cp) && (']' == cp[strlen(cp) - 1]))
+ {
+ start++; /* skip over '[' */
+ cp[strlen(cp) - 1] = '\0'; /* eat ']' */
+ }
+ if (1 == inet_pton(AF_INET6, start, &v6))
+ {
+ v6.sin6_port = htons((uint16_t)port);
+ in = GNUNET_memdup(&v6, sizeof(v6));
+ *sock_len = sizeof(v6);
+ GNUNET_free(cp);
+ return in;
+ }
}
/* #5528 FIXME (feature!): maybe also try getnameinfo()? */
- GNUNET_free (cp);
+ GNUNET_free(cp);
return NULL;
}
@@ -1842,22 +1825,22 @@ udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
* @param pad_size number of bytes of padding to append
*/
static void
-do_pad (gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
+do_pad(gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
{
char pad[pad_size];
- GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, pad, sizeof (pad));
- if (sizeof (pad) > sizeof (struct GNUNET_MessageHeader))
- {
- struct GNUNET_MessageHeader hdr =
- {.size = htons (sizeof (pad)),
- .type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD)};
+ GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, pad, sizeof(pad));
+ if (sizeof(pad) > sizeof(struct GNUNET_MessageHeader))
+ {
+ struct GNUNET_MessageHeader hdr =
+ { .size = htons(sizeof(pad)),
+ .type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD) };
- memcpy (pad, &hdr, sizeof (hdr));
- }
- GNUNET_assert (
+ memcpy(pad, &hdr, sizeof(hdr));
+ }
+ GNUNET_assert(
0 ==
- gcry_cipher_encrypt (out_cipher, dgram, sizeof (pad), pad, sizeof (pad)));
+ gcry_cipher_encrypt(out_cipher, dgram, sizeof(pad), pad, sizeof(pad)));
}
@@ -1870,123 +1853,123 @@ do_pad (gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
* @param impl_state our `struct ReceiverAddress`
*/
static void
-mq_send (struct GNUNET_MQ_Handle *mq,
- const struct GNUNET_MessageHeader *msg,
- void *impl_state)
+mq_send(struct GNUNET_MQ_Handle *mq,
+ const struct GNUNET_MessageHeader *msg,
+ void *impl_state)
{
struct ReceiverAddress *receiver = impl_state;
- uint16_t msize = ntohs (msg->size);
+ uint16_t msize = ntohs(msg->size);
- GNUNET_assert (mq == receiver->mq);
+ GNUNET_assert(mq == receiver->mq);
if (msize > receiver->mtu)
- {
- GNUNET_break (0);
- receiver_destroy (receiver);
- return;
- }
- reschedule_receiver_timeout (receiver);
+ {
+ GNUNET_break(0);
+ receiver_destroy(receiver);
+ return;
+ }
+ reschedule_receiver_timeout(receiver);
if (0 == receiver->acks_available)
- {
- /* use KX encryption method */
- struct UdpHandshakeSignature uhs;
- struct UDPConfirmation uc;
- struct InitialKX kx;
- struct GNUNET_CRYPTO_EcdhePrivateKey epriv;
- char dgram[receiver->mtu + sizeof (uc) + sizeof (kx)];
- size_t dpos;
- gcry_cipher_hd_t out_cipher;
- struct SharedSecret *ss;
-
- /* setup key material */
- GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdhe_key_create2 (&epriv));
-
- ss = setup_shared_secret_enc (&epriv, receiver);
- setup_cipher (&ss->master, 0, &out_cipher);
- /* compute 'uc' */
- uc.sender = my_identity;
- uc.monotonic_time =
- GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
- uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE);
- uhs.purpose.size = htonl (sizeof (uhs));
- uhs.sender = my_identity;
- uhs.receiver = receiver->target;
- GNUNET_CRYPTO_ecdhe_key_get_public (&epriv, &uhs.ephemeral);
- uhs.monotonic_time = uc.monotonic_time;
- GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key,
+ {
+ /* use KX encryption method */
+ struct UdpHandshakeSignature uhs;
+ struct UDPConfirmation uc;
+ struct InitialKX kx;
+ struct GNUNET_CRYPTO_EcdhePrivateKey epriv;
+ char dgram[receiver->mtu + sizeof(uc) + sizeof(kx)];
+ size_t dpos;
+ gcry_cipher_hd_t out_cipher;
+ struct SharedSecret *ss;
+
+ /* setup key material */
+ GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_ecdhe_key_create2(&epriv));
+
+ ss = setup_shared_secret_enc(&epriv, receiver);
+ setup_cipher(&ss->master, 0, &out_cipher);
+ /* compute 'uc' */
+ uc.sender = my_identity;
+ uc.monotonic_time =
+ GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get_monotonic(cfg));
+ uhs.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE);
+ uhs.purpose.size = htonl(sizeof(uhs));
+ uhs.sender = my_identity;
+ uhs.receiver = receiver->target;
+ GNUNET_CRYPTO_ecdhe_key_get_public(&epriv, &uhs.ephemeral);
+ uhs.monotonic_time = uc.monotonic_time;
+ GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key,
&uhs.purpose,
&uc.sender_sig));
- /* Leave space for kx */
- dpos = sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
- /* Append encrypted uc to dgram */
- GNUNET_assert (0 == gcry_cipher_encrypt (out_cipher,
+ /* Leave space for kx */
+ dpos = sizeof(struct GNUNET_CRYPTO_EcdhePublicKey);
+ /* Append encrypted uc to dgram */
+ GNUNET_assert(0 == gcry_cipher_encrypt(out_cipher,
&dgram[dpos],
- sizeof (uc),
+ sizeof(uc),
&uc,
- sizeof (uc)));
- dpos += sizeof (uc);
- /* Append encrypted payload to dgram */
- GNUNET_assert (
- 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
- dpos += msize;
- do_pad (out_cipher, &dgram[dpos], sizeof (dgram) - dpos);
- /* Datagram starts with kx */
- kx.ephemeral = uhs.ephemeral;
- GNUNET_assert (
- 0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof (kx.gcm_tag)));
- gcry_cipher_close (out_cipher);
- memcpy (dgram, &kx, sizeof (kx));
- if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
- dgram,
- sizeof (dgram),
- receiver->address,
- receiver->address_len))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
- GNUNET_MQ_impl_send_continue (mq);
- return;
- } /* End of KX encryption method */
+ sizeof(uc)));
+ dpos += sizeof(uc);
+ /* Append encrypted payload to dgram */
+ GNUNET_assert(
+ 0 == gcry_cipher_encrypt(out_cipher, &dgram[dpos], msize, msg, msize));
+ dpos += msize;
+ do_pad(out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
+ /* Datagram starts with kx */
+ kx.ephemeral = uhs.ephemeral;
+ GNUNET_assert(
+ 0 == gcry_cipher_gettag(out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag)));
+ gcry_cipher_close(out_cipher);
+ memcpy(dgram, &kx, sizeof(kx));
+ if (-1 == GNUNET_NETWORK_socket_sendto(udp_sock,
+ dgram,
+ sizeof(dgram),
+ receiver->address,
+ receiver->address_len))
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "send");
+ GNUNET_MQ_impl_send_continue(mq);
+ return;
+ } /* End of KX encryption method */
/* begin "BOX" encryption method, scan for ACKs from tail! */
for (struct SharedSecret *ss = receiver->ss_tail; NULL != ss; ss = ss->prev)
- {
- if (ss->sequence_used < ss->sequence_allowed)
{
- char dgram[sizeof (struct UDPBox) + receiver->mtu];
- struct UDPBox *box;
- gcry_cipher_hd_t out_cipher;
- size_t dpos;
-
- box = (struct UDPBox *) dgram;
- ss->sequence_used++;
- get_kid (&ss->master, ss->sequence_used, &box->kid);
- setup_cipher (&ss->master, ss->sequence_used, &out_cipher);
- /* Append encrypted payload to dgram */
- dpos = sizeof (struct UDPBox);
- GNUNET_assert (
- 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
- dpos += msize;
- do_pad (out_cipher, &dgram[dpos], sizeof (dgram) - dpos);
- GNUNET_assert (0 == gcry_cipher_gettag (out_cipher,
- box->gcm_tag,
- sizeof (box->gcm_tag)));
- gcry_cipher_close (out_cipher);
- if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
- dgram,
- sizeof (dgram),
- receiver->address,
- receiver->address_len))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
- GNUNET_MQ_impl_send_continue (mq);
- receiver->acks_available--;
- if (0 == receiver->acks_available)
- {
- /* We have no more ACKs => MTU change! */
- setup_receiver_mq (receiver);
- }
- return;
+ if (ss->sequence_used < ss->sequence_allowed)
+ {
+ char dgram[sizeof(struct UDPBox) + receiver->mtu];
+ struct UDPBox *box;
+ gcry_cipher_hd_t out_cipher;
+ size_t dpos;
+
+ box = (struct UDPBox *)dgram;
+ ss->sequence_used++;
+ get_kid(&ss->master, ss->sequence_used, &box->kid);
+ setup_cipher(&ss->master, ss->sequence_used, &out_cipher);
+ /* Append encrypted payload to dgram */
+ dpos = sizeof(struct UDPBox);
+ GNUNET_assert(
+ 0 == gcry_cipher_encrypt(out_cipher, &dgram[dpos], msize, msg, msize));
+ dpos += msize;
+ do_pad(out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
+ GNUNET_assert(0 == gcry_cipher_gettag(out_cipher,
+ box->gcm_tag,
+ sizeof(box->gcm_tag)));
+ gcry_cipher_close(out_cipher);
+ if (-1 == GNUNET_NETWORK_socket_sendto(udp_sock,
+ dgram,
+ sizeof(dgram),
+ receiver->address,
+ receiver->address_len))
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "send");
+ GNUNET_MQ_impl_send_continue(mq);
+ receiver->acks_available--;
+ if (0 == receiver->acks_available)
+ {
+ /* We have no more ACKs => MTU change! */
+ setup_receiver_mq(receiver);
+ }
+ return;
+ }
}
- }
- GNUNET_assert (0);
+ GNUNET_assert(0);
}
@@ -1999,15 +1982,15 @@ mq_send (struct GNUNET_MQ_Handle *mq,
* @param impl_state our `struct ReceiverAddress`
*/
static void
-mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
+mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state)
{
struct ReceiverAddress *receiver = impl_state;
if (mq == receiver->mq)
- {
- receiver->mq = NULL;
- receiver_destroy (receiver);
- }
+ {
+ receiver->mq = NULL;
+ receiver_destroy(receiver);
+ }
}
@@ -2018,10 +2001,10 @@ mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
* @param impl_state our `struct RecvierAddress`
*/
static void
-mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
+mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state)
{
/* Cancellation is impossible with UDP; bail */
- GNUNET_assert (0);
+ GNUNET_assert(0);
}
@@ -2035,15 +2018,15 @@ mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
* @param error error code
*/
static void
-mq_error (void *cls, enum GNUNET_MQ_Error error)
+mq_error(void *cls, enum GNUNET_MQ_Error error)
{
struct ReceiverAddress *receiver = cls;
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "MQ error in queue to %s: %d\n",
- GNUNET_i2s (&receiver->target),
- (int) error);
- receiver_destroy (receiver);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "MQ error in queue to %s: %d\n",
+ GNUNET_i2s(&receiver->target),
+ (int)error);
+ receiver_destroy(receiver);
}
@@ -2055,61 +2038,63 @@ mq_error (void *cls, enum GNUNET_MQ_Error error)
* @param receiver receiver to setup MQ for
*/
static void
-setup_receiver_mq (struct ReceiverAddress *receiver)
+setup_receiver_mq(struct ReceiverAddress *receiver)
{
size_t base_mtu;
if (NULL != receiver->qh)
- {
- GNUNET_TRANSPORT_communicator_mq_del (receiver->qh);
- receiver->qh = NULL;
- }
- GNUNET_assert (NULL == receiver->mq);
+ {
+ GNUNET_TRANSPORT_communicator_mq_del(receiver->qh);
+ receiver->qh = NULL;
+ }
+ GNUNET_assert(NULL == receiver->mq);
switch (receiver->address->sa_family)
- {
- case AF_INET:
- base_mtu = 1480 /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */
- - sizeof (struct GNUNET_TUN_IPv4Header) /* 20 */
- - sizeof (struct GNUNET_TUN_UdpHeader) /* 8 */;
- break;
- case AF_INET6:
- base_mtu = 1280 /* Minimum MTU required by IPv6 */
- - sizeof (struct GNUNET_TUN_IPv6Header) /* 40 */
- - sizeof (struct GNUNET_TUN_UdpHeader) /* 8 */;
- break;
- default:
- GNUNET_assert (0);
- break;
- }
+ {
+ case AF_INET:
+ base_mtu = 1480 /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */
+ - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */
+ - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
+ break;
+
+ case AF_INET6:
+ base_mtu = 1280 /* Minimum MTU required by IPv6 */
+ - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */
+ - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
+ break;
+
+ default:
+ GNUNET_assert(0);
+ break;
+ }
if (0 == receiver->acks_available)
- {
- /* MTU based on full KX messages */
- receiver->mtu = base_mtu - sizeof (struct InitialKX) /* 48 */
- - sizeof (struct UDPConfirmation); /* 104 */
- }
+ {
+ /* MTU based on full KX messages */
+ receiver->mtu = base_mtu - sizeof(struct InitialKX) /* 48 */
+ - sizeof(struct UDPConfirmation); /* 104 */
+ }
else
- {
- /* MTU based on BOXed messages */
- receiver->mtu = base_mtu - sizeof (struct UDPBox);
- }
+ {
+ /* MTU based on BOXed messages */
+ receiver->mtu = base_mtu - sizeof(struct UDPBox);
+ }
/* => Effective MTU for CORE will range from 1080 (IPv6 + KX) to
1404 (IPv4 + Box) bytes, depending on circumstances... */
if (NULL == receiver->mq)
- receiver->mq = GNUNET_MQ_queue_for_callbacks (&mq_send,
- &mq_destroy,
- &mq_cancel,
- receiver,
- NULL,
- &mq_error,
- receiver);
+ receiver->mq = GNUNET_MQ_queue_for_callbacks(&mq_send,
+ &mq_destroy,
+ &mq_cancel,
+ receiver,
+ NULL,
+ &mq_error,
+ receiver);
receiver->qh =
- GNUNET_TRANSPORT_communicator_mq_add (ch,
- &receiver->target,
- receiver->foreign_addr,
- receiver->mtu,
- receiver->nt,
- GNUNET_TRANSPORT_CS_OUTBOUND,
- receiver->mq);
+ GNUNET_TRANSPORT_communicator_mq_add(ch,
+ &receiver->target,
+ receiver->foreign_addr,
+ receiver->mtu,
+ receiver->nt,
+ GNUNET_TRANSPORT_CS_OUTBOUND,
+ receiver->mq);
}
@@ -2132,47 +2117,47 @@ setup_receiver_mq (struct ReceiverAddress *receiver)
* invalid
*/
static int
-mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
+mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
{
struct ReceiverAddress *receiver;
const char *path;
struct sockaddr *in;
socklen_t in_len;
- if (0 != strncmp (address,
- COMMUNICATOR_ADDRESS_PREFIX "-",
- strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
- {
- GNUNET_break_op (0);
- return GNUNET_SYSERR;
- }
- path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
- in = udp_address_to_sockaddr (path, &in_len);
+ if (0 != strncmp(address,
+ COMMUNICATOR_ADDRESS_PREFIX "-",
+ strlen(COMMUNICATOR_ADDRESS_PREFIX "-")))
+ {
+ GNUNET_break_op(0);
+ return GNUNET_SYSERR;
+ }
+ path = &address[strlen(COMMUNICATOR_ADDRESS_PREFIX "-")];
+ in = udp_address_to_sockaddr(path, &in_len);
- receiver = GNUNET_new (struct ReceiverAddress);
+ receiver = GNUNET_new(struct ReceiverAddress);
receiver->address = in;
receiver->address_len = in_len;
receiver->target = *peer;
- receiver->nt = GNUNET_NT_scanner_get_type (is, in, in_len);
- (void) GNUNET_CONTAINER_multipeermap_put (
+ receiver->nt = GNUNET_NT_scanner_get_type(is, in, in_len);
+ (void)GNUNET_CONTAINER_multipeermap_put(
receivers,
&receiver->target,
receiver,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
receiver->timeout =
- GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
- receiver->hn = GNUNET_CONTAINER_heap_insert (receivers_heap,
- receiver,
- receiver->timeout.abs_value_us);
- GNUNET_STATISTICS_set (stats,
- "# receivers active",
- GNUNET_CONTAINER_multipeermap_size (receivers),
- GNUNET_NO);
+ GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+ receiver->hn = GNUNET_CONTAINER_heap_insert(receivers_heap,
+ receiver,
+ receiver->timeout.abs_value_us);
+ GNUNET_STATISTICS_set(stats,
+ "# receivers active",
+ GNUNET_CONTAINER_multipeermap_size(receivers),
+ GNUNET_NO);
receiver->foreign_addr =
- sockaddr_to_udpaddr_string (receiver->address, receiver->address_len);
- setup_receiver_mq (receiver);
+ sockaddr_to_udpaddr_string(receiver->address, receiver->address_len);
+ setup_receiver_mq(receiver);
if (NULL == timeout_task)
- timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL);
+ timeout_task = GNUNET_SCHEDULER_add_now(&check_timeouts, NULL);
return GNUNET_OK;
}
@@ -2186,15 +2171,15 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
* @return #GNUNET_OK to continue to iterate
*/
static int
-get_receiver_delete_it (void *cls,
- const struct GNUNET_PeerIdentity *target,
- void *value)
+get_receiver_delete_it(void *cls,
+ const struct GNUNET_PeerIdentity *target,
+ void *value)
{
struct ReceiverAddress *receiver = value;
- (void) cls;
- (void) target;
- receiver_destroy (receiver);
+ (void)cls;
+ (void)target;
+ receiver_destroy(receiver);
return GNUNET_OK;
}
@@ -2208,15 +2193,15 @@ get_receiver_delete_it (void *cls,
* @return #GNUNET_OK to continue to iterate
*/
static int
-get_sender_delete_it (void *cls,
- const struct GNUNET_PeerIdentity *target,
- void *value)
+get_sender_delete_it(void *cls,
+ const struct GNUNET_PeerIdentity *target,
+ void *value)
{
struct SenderAddress *sender = value;
- (void) cls;
- (void) target;
- sender_destroy (sender);
+ (void)cls;
+ (void)target;
+ sender_destroy(sender);
return GNUNET_OK;
}
@@ -2227,64 +2212,64 @@ get_sender_delete_it (void *cls,
* @param cls NULL (always)
*/
static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
{
if (NULL != nat)
- {
- GNUNET_NAT_unregister (nat);
- nat = NULL;
- }
+ {
+ GNUNET_NAT_unregister(nat);
+ nat = NULL;
+ }
while (NULL != bi_head)
- bi_destroy (bi_head);
+ bi_destroy(bi_head);
if (NULL != broadcast_task)
- {
- GNUNET_SCHEDULER_cancel (broadcast_task);
- broadcast_task = NULL;
- }
+ {
+ GNUNET_SCHEDULER_cancel(broadcast_task);
+ broadcast_task = NULL;
+ }
if (NULL != read_task)
- {
- GNUNET_SCHEDULER_cancel (read_task);
- read_task = NULL;
- }
+ {
+ GNUNET_SCHEDULER_cancel(read_task);
+ read_task = NULL;
+ }
if (NULL != udp_sock)
- {
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (udp_sock));
- udp_sock = NULL;
- }
- GNUNET_CONTAINER_multipeermap_iterate (receivers,
- &get_receiver_delete_it,
- NULL);
- GNUNET_CONTAINER_multipeermap_destroy (receivers);
- GNUNET_CONTAINER_multipeermap_iterate (senders, &get_sender_delete_it, NULL);
- GNUNET_CONTAINER_multipeermap_destroy (senders);
- GNUNET_CONTAINER_multishortmap_destroy (key_cache);
- GNUNET_CONTAINER_heap_destroy (senders_heap);
- GNUNET_CONTAINER_heap_destroy (receivers_heap);
+ {
+ GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(udp_sock));
+ udp_sock = NULL;
+ }
+ GNUNET_CONTAINER_multipeermap_iterate(receivers,
+ &get_receiver_delete_it,
+ NULL);
+ GNUNET_CONTAINER_multipeermap_destroy(receivers);
+ GNUNET_CONTAINER_multipeermap_iterate(senders, &get_sender_delete_it, NULL);
+ GNUNET_CONTAINER_multipeermap_destroy(senders);
+ GNUNET_CONTAINER_multishortmap_destroy(key_cache);
+ GNUNET_CONTAINER_heap_destroy(senders_heap);
+ GNUNET_CONTAINER_heap_destroy(receivers_heap);
if (NULL != ch)
- {
- GNUNET_TRANSPORT_communicator_disconnect (ch);
- ch = NULL;
- }
+ {
+ GNUNET_TRANSPORT_communicator_disconnect(ch);
+ ch = NULL;
+ }
if (NULL != ah)
- {
- GNUNET_TRANSPORT_application_done (ah);
- ah = NULL;
- }
+ {
+ GNUNET_TRANSPORT_application_done(ah);
+ ah = NULL;
+ }
if (NULL != stats)
- {
- GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
- stats = NULL;
- }
+ {
+ GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
+ stats = NULL;
+ }
if (NULL != my_private_key)
- {
- GNUNET_free (my_private_key);
- my_private_key = NULL;
- }
+ {
+ GNUNET_free(my_private_key);
+ my_private_key = NULL;
+ }
if (NULL != is)
- {
- GNUNET_NT_scanner_done (is);
- is = NULL;
- }
+ {
+ GNUNET_NT_scanner_done(is);
+ is = NULL;
+ }
}
@@ -2298,24 +2283,24 @@ do_shutdown (void *cls)
* @param msg payload
*/
static void
-enc_notify_cb (void *cls,
- const struct GNUNET_PeerIdentity *sender,
- const struct GNUNET_MessageHeader *msg)
+enc_notify_cb(void *cls,
+ const struct GNUNET_PeerIdentity *sender,
+ const struct GNUNET_MessageHeader *msg)
{
const struct UDPAck *ack;
- (void) cls;
- if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK) ||
- (ntohs (msg->size) != sizeof (struct UDPAck)))
- {
- GNUNET_break_op (0);
- return;
- }
- ack = (const struct UDPAck *) msg;
- GNUNET_CONTAINER_multipeermap_get_multiple (receivers,
- sender,
- &handle_ack,
- (void *) ack);
+ (void)cls;
+ if ((ntohs(msg->type) != GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK) ||
+ (ntohs(msg->size) != sizeof(struct UDPAck)))
+ {
+ GNUNET_break_op(0);
+ return;
+ }
+ ack = (const struct UDPAck *)msg;
+ GNUNET_CONTAINER_multipeermap_get_multiple(receivers,
+ sender,
+ &handle_ack,
+ (void *)ack);
}
@@ -2333,39 +2318,39 @@ enc_notify_cb (void *cls,
* @param addrlen actual length of the @a addr
*/
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)
+nat_address_cb(void *cls,
+ void **app_ctx,
+ int add_remove,
+ enum GNUNET_NAT_AddressClass ac,
+ const struct sockaddr *addr,
+ socklen_t addrlen)
{
char *my_addr;
struct GNUNET_TRANSPORT_AddressIdentifier *ai;
if (GNUNET_YES == add_remove)
- {
- enum GNUNET_NetworkType nt;
-
- GNUNET_asprintf (&my_addr,
- "%s-%s",
- COMMUNICATOR_ADDRESS_PREFIX,
- GNUNET_a2s (addr, addrlen));
- nt = GNUNET_NT_scanner_get_type (is, addr, addrlen);
- ai =
- GNUNET_TRANSPORT_communicator_address_add (ch,
- my_addr,
- nt,
- GNUNET_TIME_UNIT_FOREVER_REL);
- GNUNET_free (my_addr);
- *app_ctx = ai;
- }
+ {
+ enum GNUNET_NetworkType nt;
+
+ GNUNET_asprintf(&my_addr,
+ "%s-%s",
+ COMMUNICATOR_ADDRESS_PREFIX,
+ GNUNET_a2s(addr, addrlen));
+ nt = GNUNET_NT_scanner_get_type(is, addr, addrlen);
+ ai =
+ GNUNET_TRANSPORT_communicator_address_add(ch,
+ my_addr,
+ nt,
+ GNUNET_TIME_UNIT_FOREVER_REL);
+ GNUNET_free(my_addr);
+ *app_ctx = ai;
+ }
else
- {
- ai = *app_ctx;
- GNUNET_TRANSPORT_communicator_address_remove (ai);
- *app_ctx = NULL;
- }
+ {
+ ai = *app_ctx;
+ GNUNET_TRANSPORT_communicator_address_remove(ai);
+ *app_ctx = NULL;
+ }
}
@@ -2375,67 +2360,69 @@ nat_address_cb (void *cls,
* @param cls a `struct BroadcastInterface`
*/
static void
-ifc_broadcast (void *cls)
+ifc_broadcast(void *cls)
{
struct BroadcastInterface *bi = cls;
struct GNUNET_TIME_Relative delay;
delay = BROADCAST_FREQUENCY;
delay.rel_value_us =
- GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, delay.rel_value_us);
+ GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, delay.rel_value_us);
bi->broadcast_task =
- GNUNET_SCHEDULER_add_delayed (INTERFACE_SCAN_FREQUENCY, &ifc_broadcast, bi);
+ GNUNET_SCHEDULER_add_delayed(INTERFACE_SCAN_FREQUENCY, &ifc_broadcast, bi);
switch (bi->sa->sa_family)
- {
- case AF_INET: {
- static int yes = 1;
- static int no = 0;
- ssize_t sent;
-
- if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
- SOL_SOCKET,
- SO_BROADCAST,
- &yes,
- sizeof (int)))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
- sent = GNUNET_NETWORK_socket_sendto (udp_sock,
- &bi->bcm,
- sizeof (bi->bcm),
- bi->ba,
- bi->salen);
- if (-1 == sent)
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto");
- if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
- SOL_SOCKET,
- SO_BROADCAST,
- &no,
- sizeof (int)))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
- break;
- }
- case AF_INET6: {
- ssize_t sent;
- struct sockaddr_in6 dst;
-
- dst.sin6_family = AF_INET6;
- dst.sin6_port = htons (my_port);
- dst.sin6_addr = bi->mcreq.ipv6mr_multiaddr;
- dst.sin6_scope_id = ((struct sockaddr_in6 *) bi->ba)->sin6_scope_id;
-
- sent = GNUNET_NETWORK_socket_sendto (udp_sock,
- &bi->bcm,
- sizeof (bi->bcm),
- (const struct sockaddr *) &dst,
- sizeof (dst));
- if (-1 == sent)
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto");
- break;
- }
- default:
- GNUNET_break (0);
- break;
- }
+ {
+ case AF_INET: {
+ static int yes = 1;
+ static int no = 0;
+ ssize_t sent;
+
+ if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(udp_sock,
+ SOL_SOCKET,
+ SO_BROADCAST,
+ &yes,
+ sizeof(int)))
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "setsockopt");
+ sent = GNUNET_NETWORK_socket_sendto(udp_sock,
+ &bi->bcm,
+ sizeof(bi->bcm),
+ bi->ba,
+ bi->salen);
+ if (-1 == sent)
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "sendto");
+ if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(udp_sock,
+ SOL_SOCKET,
+ SO_BROADCAST,
+ &no,
+ sizeof(int)))
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "setsockopt");
+ break;
+ }
+
+ case AF_INET6: {
+ ssize_t sent;
+ struct sockaddr_in6 dst;
+
+ dst.sin6_family = AF_INET6;
+ dst.sin6_port = htons(my_port);
+ dst.sin6_addr = bi->mcreq.ipv6mr_multiaddr;
+ dst.sin6_scope_id = ((struct sockaddr_in6 *)bi->ba)->sin6_scope_id;
+
+ sent = GNUNET_NETWORK_socket_sendto(udp_sock,
+ &bi->bcm,
+ sizeof(bi->bcm),
+ (const struct sockaddr *)&dst,
+ sizeof(dst));
+ if (-1 == sent)
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "sendto");
+ break;
+ }
+
+ default:
+ GNUNET_break(0);
+ break;
+ }
}
@@ -2454,90 +2441,90 @@ ifc_broadcast (void *cls)
* @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort
*/
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)
+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)
{
struct BroadcastInterface *bi;
enum GNUNET_NetworkType network;
struct UdpBroadcastSignature ubs;
- (void) cls;
- (void) netmask;
+ (void)cls;
+ (void)netmask;
if (NULL == addr)
return GNUNET_YES; /* need to know our address! */
- network = GNUNET_NT_scanner_get_type (is, addr, addrlen);
+ network = GNUNET_NT_scanner_get_type(is, addr, addrlen);
if (GNUNET_NT_LOOPBACK == network)
- {
- /* Broadcasting on loopback does not make sense */
- return GNUNET_YES;
- }
+ {
+ /* Broadcasting on loopback does not make sense */
+ return GNUNET_YES;
+ }
for (bi = bi_head; NULL != bi; bi = bi->next)
- {
- if ((bi->salen == addrlen) && (0 == memcmp (addr, bi->sa, addrlen)))
{
- bi->found = GNUNET_YES;
- return GNUNET_OK;
+ if ((bi->salen == addrlen) && (0 == memcmp(addr, bi->sa, addrlen)))
+ {
+ bi->found = GNUNET_YES;
+ return GNUNET_OK;
+ }
}
- }
if ((AF_INET6 == addr->sa_family) && (NULL == broadcast_addr))
return GNUNET_OK; /* broadcast_addr is required for IPv6! */
if ((AF_INET6 == addr->sa_family) && (GNUNET_YES != have_v6_socket))
return GNUNET_OK; /* not using IPv6 */
- bi = GNUNET_new (struct BroadcastInterface);
- bi->sa = GNUNET_memdup (addr, addrlen);
+ bi = GNUNET_new(struct BroadcastInterface);
+ bi->sa = GNUNET_memdup(addr, addrlen);
if (NULL != broadcast_addr)
- bi->ba = GNUNET_memdup (broadcast_addr, addrlen);
+ bi->ba = GNUNET_memdup(broadcast_addr, addrlen);
bi->salen = addrlen;
bi->found = GNUNET_YES;
bi->bcm.sender = my_identity;
- ubs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST);
- ubs.purpose.size = htonl (sizeof (ubs));
+ ubs.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST);
+ ubs.purpose.size = htonl(sizeof(ubs));
ubs.sender = my_identity;
- GNUNET_CRYPTO_hash (addr, addrlen, &ubs.h_address);
- GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key,
- &ubs.purpose,
- &bi->bcm.sender_sig));
- bi->broadcast_task = GNUNET_SCHEDULER_add_now (&ifc_broadcast, bi);
- GNUNET_CONTAINER_DLL_insert (bi_head, bi_tail, bi);
+ GNUNET_CRYPTO_hash(addr, addrlen, &ubs.h_address);
+ GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key,
+ &ubs.purpose,
+ &bi->bcm.sender_sig));
+ bi->broadcast_task = GNUNET_SCHEDULER_add_now(&ifc_broadcast, bi);
+ GNUNET_CONTAINER_DLL_insert(bi_head, bi_tail, bi);
if ((AF_INET6 == addr->sa_family) && (NULL != broadcast_addr))
- {
- /* Create IPv6 multicast request */
- const struct sockaddr_in6 *s6 =
- (const struct sockaddr_in6 *) broadcast_addr;
-
- GNUNET_assert (
- 1 == inet_pton (AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr));
-
- /* http://tools.ietf.org/html/rfc2553#section-5.2:
- *
- * IPV6_JOIN_GROUP
- *
- * Join a multicast group on a specified local interface. If the
- * interface index is specified as 0, the kernel chooses the local
- * interface. For example, some kernels look up the multicast
- * group in the normal IPv6 routing table and using the resulting
- * interface; we do this for each interface, so no need to use
- * zero (anymore...).
- */
- bi->mcreq.ipv6mr_interface = s6->sin6_scope_id;
-
- /* Join the multicast group */
- if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
- IPPROTO_IPV6,
- IPV6_JOIN_GROUP,
- &bi->mcreq,
- sizeof (bi->mcreq)))
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
+ /* Create IPv6 multicast request */
+ const struct sockaddr_in6 *s6 =
+ (const struct sockaddr_in6 *)broadcast_addr;
+
+ GNUNET_assert(
+ 1 == inet_pton(AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr));
+
+ /* http://tools.ietf.org/html/rfc2553#section-5.2:
+ *
+ * IPV6_JOIN_GROUP
+ *
+ * Join a multicast group on a specified local interface. If the
+ * interface index is specified as 0, the kernel chooses the local
+ * interface. For example, some kernels look up the multicast
+ * group in the normal IPv6 routing table and using the resulting
+ * interface; we do this for each interface, so no need to use
+ * zero (anymore...).
+ */
+ bi->mcreq.ipv6mr_interface = s6->sin6_scope_id;
+
+ /* Join the multicast group */
+ if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(udp_sock,
+ IPPROTO_IPV6,
+ IPV6_JOIN_GROUP,
+ &bi->mcreq,
+ sizeof(bi->mcreq)))
+ {
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "setsockopt");
+ }
}
- }
return GNUNET_OK;
}
@@ -2548,23 +2535,23 @@ iface_proc (void *cls,
* @param cls NULL, unused
*/
static void
-do_broadcast (void *cls)
+do_broadcast(void *cls)
{
struct BroadcastInterface *bin;
- (void) cls;
+ (void)cls;
for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bi->next)
bi->found = GNUNET_NO;
- GNUNET_OS_network_interfaces_list (&iface_proc, NULL);
+ GNUNET_OS_network_interfaces_list(&iface_proc, NULL);
for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bin)
- {
- bin = bi->next;
- if (GNUNET_NO == bi->found)
- bi_destroy (bi);
- }
- broadcast_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_SCAN_FREQUENCY,
- &do_broadcast,
- NULL);
+ {
+ bin = bi->next;
+ if (GNUNET_NO == bi->found)
+ bi_destroy(bi);
+ }
+ broadcast_task = GNUNET_SCHEDULER_add_delayed(INTERFACE_SCAN_FREQUENCY,
+ &do_broadcast,
+ NULL);
}
@@ -2577,10 +2564,10 @@ do_broadcast (void *cls)
* @param c configuration
*/
static void
-run (void *cls,
- char *const *args,
- const char *cfgfile,
- const struct GNUNET_CONFIGURATION_Handle *c)
+run(void *cls,
+ char *const *args,
+ const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *c)
{
char *bindto;
struct sockaddr *in;
@@ -2588,141 +2575,143 @@ run (void *cls,
struct sockaddr_storage in_sto;
socklen_t sto_len;
- (void) cls;
+ (void)cls;
cfg = c;
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (cfg,
- COMMUNICATOR_CONFIG_SECTION,
- "BINDTO",
- &bindto))
- {
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
- COMMUNICATOR_CONFIG_SECTION,
- "BINDTO");
- return;
- }
+ GNUNET_CONFIGURATION_get_value_filename(cfg,
+ COMMUNICATOR_CONFIG_SECTION,
+ "BINDTO",
+ &bindto))
+ {
+ GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
+ COMMUNICATOR_CONFIG_SECTION,
+ "BINDTO");
+ return;
+ }
- in = udp_address_to_sockaddr (bindto, &in_len);
+ in = udp_address_to_sockaddr(bindto, &in_len);
if (NULL == in)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Failed to setup UDP socket address with path `%s'\n",
- bindto);
- GNUNET_free (bindto);
- return;
- }
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Failed to setup UDP socket address with path `%s'\n",
+ bindto);
+ GNUNET_free(bindto);
+ return;
+ }
udp_sock =
- GNUNET_NETWORK_socket_create (in->sa_family, SOCK_DGRAM, IPPROTO_UDP);
+ GNUNET_NETWORK_socket_create(in->sa_family, SOCK_DGRAM, IPPROTO_UDP);
if (NULL == udp_sock)
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
- GNUNET_free (in);
- GNUNET_free (bindto);
- return;
- }
+ {
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "socket");
+ GNUNET_free(in);
+ GNUNET_free(bindto);
+ return;
+ }
if (AF_INET6 == in->sa_family)
have_v6_socket = GNUNET_YES;
- if (GNUNET_OK != GNUNET_NETWORK_socket_bind (udp_sock, in, in_len))
- {
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "bind", bindto);
- GNUNET_NETWORK_socket_close (udp_sock);
- udp_sock = NULL;
- GNUNET_free (in);
- GNUNET_free (bindto);
- return;
- }
+ if (GNUNET_OK != GNUNET_NETWORK_socket_bind(udp_sock, in, in_len))
+ {
+ GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "bind", bindto);
+ GNUNET_NETWORK_socket_close(udp_sock);
+ udp_sock = NULL;
+ GNUNET_free(in);
+ GNUNET_free(bindto);
+ return;
+ }
/* We might have bound to port 0, allowing the OS to figure it out;
thus, get the real IN-address from the socket */
- sto_len = sizeof (in_sto);
- if (0 != getsockname (GNUNET_NETWORK_get_fd (udp_sock),
- (struct sockaddr *) &in_sto,
- &sto_len))
- {
- memcpy (&in_sto, in, in_len);
- sto_len = in_len;
- }
- GNUNET_free (in);
- GNUNET_free (bindto);
- in = (struct sockaddr *) &in_sto;
+ sto_len = sizeof(in_sto);
+ if (0 != getsockname(GNUNET_NETWORK_get_fd(udp_sock),
+ (struct sockaddr *)&in_sto,
+ &sto_len))
+ {
+ memcpy(&in_sto, in, in_len);
+ sto_len = in_len;
+ }
+ GNUNET_free(in);
+ GNUNET_free(bindto);
+ in = (struct sockaddr *)&in_sto;
in_len = sto_len;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Bound to `%s'\n",
- GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len));
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Bound to `%s'\n",
+ GNUNET_a2s((const struct sockaddr *)&in_sto, sto_len));
switch (in->sa_family)
- {
- case AF_INET:
- my_port = ntohs (((struct sockaddr_in *) in)->sin_port);
- break;
- case AF_INET6:
- my_port = ntohs (((struct sockaddr_in6 *) in)->sin6_port);
- break;
- default:
- GNUNET_break (0);
- my_port = 0;
- }
- stats = GNUNET_STATISTICS_create ("C-UDP", cfg);
- senders = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
- receivers = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
- senders_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+ {
+ case AF_INET:
+ my_port = ntohs(((struct sockaddr_in *)in)->sin_port);
+ break;
+
+ case AF_INET6:
+ my_port = ntohs(((struct sockaddr_in6 *)in)->sin6_port);
+ break;
+
+ default:
+ GNUNET_break(0);
+ my_port = 0;
+ }
+ stats = GNUNET_STATISTICS_create("C-UDP", cfg);
+ senders = GNUNET_CONTAINER_multipeermap_create(32, GNUNET_YES);
+ receivers = GNUNET_CONTAINER_multipeermap_create(32, GNUNET_YES);
+ senders_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
receivers_heap =
- GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
- key_cache = GNUNET_CONTAINER_multishortmap_create (1024, GNUNET_YES);
- GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
- is = GNUNET_NT_scanner_init ();
- my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
+ GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
+ key_cache = GNUNET_CONTAINER_multishortmap_create(1024, GNUNET_YES);
+ GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
+ is = GNUNET_NT_scanner_init();
+ my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg);
if (NULL == my_private_key)
- {
- GNUNET_log (
- GNUNET_ERROR_TYPE_ERROR,
- _ (
- "Transport service is lacking key configuration settings. Exiting.\n"));
- GNUNET_SCHEDULER_shutdown ();
- return;
- }
- GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
+ {
+ GNUNET_log(
+ GNUNET_ERROR_TYPE_ERROR,
+ _(
+ "Transport service is lacking key configuration settings. Exiting.\n"));
+ GNUNET_SCHEDULER_shutdown();
+ return;
+ }
+ GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, &my_identity.public_key);
/* start reading */
- read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
- udp_sock,
- &sock_read,
+ read_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+ udp_sock,
+ &sock_read,
+ NULL);
+ ch = GNUNET_TRANSPORT_communicator_connect(cfg,
+ COMMUNICATOR_CONFIG_SECTION,
+ COMMUNICATOR_ADDRESS_PREFIX,
+ GNUNET_TRANSPORT_CC_UNRELIABLE,
+ &mq_init,
+ NULL,
+ &enc_notify_cb,
NULL);
- ch = GNUNET_TRANSPORT_communicator_connect (cfg,
- COMMUNICATOR_CONFIG_SECTION,
- COMMUNICATOR_ADDRESS_PREFIX,
- GNUNET_TRANSPORT_CC_UNRELIABLE,
- &mq_init,
- NULL,
- &enc_notify_cb,
- NULL);
if (NULL == ch)
- {
- GNUNET_break (0);
- GNUNET_SCHEDULER_shutdown ();
- return;
- }
- ah = GNUNET_TRANSPORT_application_init (cfg);
+ {
+ GNUNET_break(0);
+ GNUNET_SCHEDULER_shutdown();
+ return;
+ }
+ ah = GNUNET_TRANSPORT_application_init(cfg);
if (NULL == ah)
- {
- GNUNET_break (0);
- GNUNET_SCHEDULER_shutdown ();
- return;
- }
+ {
+ GNUNET_break(0);
+ GNUNET_SCHEDULER_shutdown();
+ return;
+ }
/* start broadcasting */
if (GNUNET_YES !=
- GNUNET_CONFIGURATION_get_value_yesno (cfg,
- COMMUNICATOR_CONFIG_SECTION,
- "DISABLE_BROADCAST"))
- {
- broadcast_task = GNUNET_SCHEDULER_add_now (&do_broadcast, NULL);
- }
- nat = GNUNET_NAT_register (cfg,
- COMMUNICATOR_CONFIG_SECTION,
- IPPROTO_UDP,
- 1 /* one address */,
- (const struct sockaddr **) &in,
- &in_len,
- &nat_address_cb,
- NULL /* FIXME: support reversal: #5529 */,
- NULL /* closure */);
+ GNUNET_CONFIGURATION_get_value_yesno(cfg,
+ COMMUNICATOR_CONFIG_SECTION,
+ "DISABLE_BROADCAST"))
+ {
+ broadcast_task = GNUNET_SCHEDULER_add_now(&do_broadcast, NULL);
+ }
+ nat = GNUNET_NAT_register(cfg,
+ COMMUNICATOR_CONFIG_SECTION,
+ IPPROTO_UDP,
+ 1 /* one address */,
+ (const struct sockaddr **)&in,
+ &in_len,
+ &nat_address_cb,
+ NULL /* FIXME: support reversal: #5529 */,
+ NULL /* closure */);
}
@@ -2734,25 +2723,26 @@ run (void *cls,
* @return 0 ok, 1 on error
*/
int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
{
static const struct GNUNET_GETOPT_CommandLineOption options[] = {
- GNUNET_GETOPT_OPTION_END};
+ GNUNET_GETOPT_OPTION_END
+ };
int ret;
- if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+ if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
return 2;
- ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
- argv,
- "gnunet-communicator-udp",
- _ ("GNUnet UDP communicator"),
- options,
- &run,
- NULL))
- ? 0
- : 1;
- GNUNET_free ((void *) argv);
+ ret = (GNUNET_OK == GNUNET_PROGRAM_run(argc,
+ argv,
+ "gnunet-communicator-udp",
+ _("GNUnet UDP communicator"),
+ options,
+ &run,
+ NULL))
+ ? 0
+ : 1;
+ GNUNET_free((void *)argv);
return ret;
}