From c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 5 Oct 2019 15:09:28 +0200 Subject: global reindent, now with uncrustify hook enabled --- src/transport/gnunet-communicator-udp.c | 2214 ++++++++++++++++--------------- 1 file changed, 1114 insertions(+), 1100 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 228540b81..2d9fabfec 100644 --- a/src/transport/gnunet-communicator-udp.c +++ b/src/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,7 +156,8 @@ 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 */ @@ -189,7 +190,8 @@ struct UdpHandshakeSignature { * "Plaintext" header at beginning of KX message. Followed * by encrypted `struct UDPConfirmation`. */ -struct InitialKX { +struct InitialKX +{ /** * Ephemeral key for KX. */ @@ -207,7 +209,8 @@ struct InitialKX { * Encrypted continuation of UDP initial handshake, followed * by message header with payload. */ -struct UDPConfirmation { +struct UDPConfirmation +{ /** * Sender's identity */ @@ -234,7 +237,8 @@ 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. */ @@ -261,7 +265,8 @@ 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 */ @@ -285,7 +290,8 @@ 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. */ @@ -303,7 +309,8 @@ 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 @@ -336,7 +343,8 @@ 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. */ @@ -383,7 +391,8 @@ struct ReceiverAddress; /** * Shared secret we generated for a particular sender or receiver. */ -struct SharedSecret { +struct SharedSecret +{ /** * Kept in a DLL. */ @@ -448,7 +457,8 @@ 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. */ @@ -500,7 +510,8 @@ 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. */ @@ -578,7 +589,8 @@ struct ReceiverAddress { /** * Interface we broadcast our presence on. */ -struct BroadcastInterface { +struct BroadcastInterface +{ /** * Kept in a DLL. */ @@ -739,25 +751,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))) { - /* 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_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); } @@ -767,35 +779,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); } @@ -805,16 +817,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); } @@ -826,24 +838,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); } @@ -854,26 +866,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); } @@ -883,31 +895,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); } @@ -918,18 +930,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); } @@ -942,28 +954,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); } @@ -973,11 +985,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); } @@ -987,12 +999,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); } @@ -1002,7 +1014,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; @@ -1010,27 +1022,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); } @@ -1040,20 +1052,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); } @@ -1066,36 +1078,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); } @@ -1108,20 +1120,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)); } @@ -1138,29 +1150,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; } @@ -1172,12 +1184,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; } @@ -1190,20 +1202,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; } @@ -1216,7 +1228,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); /** @@ -1230,36 +1242,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))) { - 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) { - 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; + /* 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; } + } return GNUNET_YES; } @@ -1273,41 +1285,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) 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); + } } @@ -1320,29 +1332,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); + } } @@ -1354,42 +1366,43 @@ 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); + 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. */ @@ -1416,19 +1429,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; } @@ -1445,45 +1458,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); + 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; } @@ -1496,21 +1509,22 @@ 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); } @@ -1523,30 +1537,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; } @@ -1557,87 +1571,87 @@ 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); 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; + { + 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; - } + 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)) { - 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... */ + 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... */ + } /* finally, test if it is a KX */ if (rcvd < sizeof(struct UDPConfirmation) + sizeof(struct InitialKX)) - { - GNUNET_STATISTICS_update(stats, - "# messages dropped (no kid, too small for KX)", - 1, - GNUNET_NO); - return; - } + { + GNUNET_STATISTICS_update (stats, + "# messages dropped (no kid, too small for KX)", + 1, + GNUNET_NO); + return; + } { const struct InitialKX *kx; @@ -1646,48 +1660,48 @@ sock_read(void *cls) 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); } } @@ -1700,7 +1714,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; @@ -1708,88 +1722,88 @@ udp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) char *colon; char *cp; - if (1 == sscanf(bindto, "%u%1s", &port, dummy)) + if (1 == sscanf (bindto, "%u%1s", &port, dummy)) + { + /* interpreting value as just a PORT number */ + if (port > UINT16_MAX) { - /* 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; + 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; - } - return in; + 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; } - cp = GNUNET_strdup(bindto); - colon = strrchr(cp, ':'); + return in; + } + 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)) { - /* 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; - } + /* 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 + else { - /* interpret missing port as 0, aka pick any free one */ - port = 0; + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + "BINDTO specification `%s' invalid: last ':' not followed by number\n", + bindto); + GNUNET_free (cp); + return NULL; } + } + else + { + /* interpret missing port as 0, aka pick any free one */ + port = 0; + } { /* try IPv4 */ struct sockaddr_in v4; - 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 */ @@ -1797,22 +1811,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; } @@ -1825,22 +1839,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)); + 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) }; + { + 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))); } @@ -1853,123 +1867,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), &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 */ + 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) { - 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; - } + 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); } @@ -1982,15 +1996,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); + } } @@ -2001,10 +2015,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); } @@ -2018,15 +2032,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); } @@ -2038,63 +2052,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); } @@ -2117,47 +2131,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; } @@ -2171,15 +2185,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; } @@ -2193,15 +2207,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; } @@ -2212,64 +2226,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; + } } @@ -2283,24 +2297,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); } @@ -2318,39 +2332,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; + } } @@ -2360,69 +2374,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: { + { + 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 (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"); + 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: { + case AF_INET6: { ssize_t sent; struct sockaddr_in6 dst; dst.sin6_family = AF_INET6; - dst.sin6_port = htons(my_port); + 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; + 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)); + 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"); + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto"); break; } - default: - GNUNET_break(0); - break; - } + default: + GNUNET_break (0); + break; + } } @@ -2441,90 +2455,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))) { - if ((bi->salen == addrlen) && (0 == memcmp(addr, bi->sa, addrlen))) - { - bi->found = GNUNET_YES; - return GNUNET_OK; - } + 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))) { - /* 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"); - } + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt"); } + } return GNUNET_OK; } @@ -2535,23 +2549,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); } @@ -2564,10 +2578,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; @@ -2575,143 +2589,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; + 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_INET: + my_port = ntohs (((struct sockaddr_in *) in)->sin_port); + break; - case AF_INET6: - my_port = ntohs(((struct sockaddr_in6 *)in)->sin6_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); + 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, - NULL); - ch = GNUNET_TRANSPORT_communicator_connect(cfg, - COMMUNICATOR_CONFIG_SECTION, - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_TRANSPORT_CC_UNRELIABLE, - &mq_init, - NULL, - &enc_notify_cb, + read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + udp_sock, + &sock_read, NULL); + ch = GNUNET_TRANSPORT_communicator_connect (cfg, + COMMUNICATOR_CONFIG_SECTION, + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_TRANSPORT_CC_UNRELIABLE, + &mq_init, + NULL, + &enc_notify_cb, + NULL); if (NULL == ch) - { - GNUNET_break(0); - GNUNET_SCHEDULER_shutdown(); - return; - } - ah = GNUNET_TRANSPORT_application_init(cfg); + { + 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 */); } @@ -2723,26 +2737,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 }; 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)) + ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc, + argv, + "gnunet-communicator-udp", + _ ("GNUnet UDP communicator"), + options, + &run, + NULL)) ? 0 : 1; - GNUNET_free((void *)argv); + GNUNET_free ((void *) argv); return ret; } -- cgit v1.2.3