From d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb Mon Sep 17 00:00:00 2001 From: ng0 Date: Sun, 8 Sep 2019 12:33:09 +0000 Subject: uncrustify as demanded. --- src/transport/gnunet-communicator-udp.c | 2292 +++++++++++++++---------------- 1 file changed, 1141 insertions(+), 1151 deletions(-) (limited to 'src/transport/gnunet-communicator-udp.c') 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 . 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; } -- cgit v1.2.3