From ac71165822501c42b00980db2fb7f5e2144f3d20 Mon Sep 17 00:00:00 2001 From: t3sserakt Date: Mon, 25 Jan 2021 15:47:10 +0100 Subject: - fixed bug in tcp com challenge logic. added test case for bidirectional test. --- src/transport/Makefile.am | 18 +- src/transport/gnunet-communicator-tcp.c | 654 +++++++++++++++++--------------- src/transport/gnunet-communicator-udp.c | 1 + src/transport/test_communicator_basic.c | 570 +++++++++++++++++----------- 4 files changed, 705 insertions(+), 538 deletions(-) diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am index a2fc3811e..0251b001e 100644 --- a/src/transport/Makefile.am +++ b/src/transport/Makefile.am @@ -618,7 +618,8 @@ check_PROGRAMS += \ test_communicator_basic-udp \ test_communicator_rekey-tcp \ test_communicator_rekey-udp \ - test_communicator_backchannel-udp + test_communicator_backchannel-udp \ + test_communicator_bidirect-tcp endif endif @@ -696,7 +697,8 @@ TESTS += \ test_communicator_basic-udp \ test_communicator_rekey-tcp \ test_communicator_rekey-udp \ - test_communicator_backchannel-udp + test_communicator_backchannel-udp \ + test_communicator_bidirect-tcp endif endif @@ -857,6 +859,14 @@ test_communicator_backchannel_udp_LDADD = \ $(top_builddir)/src/testing/libgnunettesting.la \ $(top_builddir)/src/util/libgnunetutil.la \ $(top_builddir)/src/statistics/libgnunetstatistics.la + +test_communicator_bidirect_tcp_SOURCES = \ + test_communicator_basic.c +test_communicator_bidirect_tcp_LDADD = \ + libgnunettransporttesting2.la \ + $(top_builddir)/src/testing/libgnunettesting.la \ + $(top_builddir)/src/util/libgnunetutil.la \ + $(top_builddir)/src/statistics/libgnunetstatistics.la endif test_plugin_unix_SOURCES = \ @@ -1567,4 +1577,6 @@ test_communicator_tcp_rekey_peer2.conf \ test_communicator_udp_rekey_peer1.conf \ test_communicator_udp_rekey_peer2.conf \ test_communicator_udp_backchannel_peer1.conf \ -test_communicator_udp_backchannel_peer2.conf +test_communicator_udp_backchannel_peer2.conf \ +test_communicator_tcp_bidirect_peer1.conf \ +test_communicator_tcp_bidirect_peer2.conf diff --git a/src/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c index 0c79fc1b4..ed82dba9f 100644 --- a/src/transport/gnunet-communicator-tcp.c +++ b/src/transport/gnunet-communicator-tcp.c @@ -589,6 +589,11 @@ struct Queue */ struct ChallengeNonceP challenge; + /** + * Challenge value received. In case of inbound connection we have to remember the value, because we send the challenge back later after we received the GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK. + */ + struct ChallengeNonceP challenge_received; + /** * Iteration Context for retrieving the monotonic time send with key for rekeying. */ @@ -834,7 +839,7 @@ int addrs_lens; * Size of data received without KX challenge played back. */ // TODO remove? -// size_t unverified_size; +size_t unverified_size; /** * Database for peer's HELLOs. @@ -1188,23 +1193,6 @@ setup_cipher (const struct GNUNET_HashCode *dh, 0)); } - -/** - * Setup cipher of @a queue for decryption. - * - * @param ephemeral ephemeral key we received from the other peer - * @param queue[in,out] queue to initialize decryption cipher for - */ -static void -setup_in_cipher (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, - struct Queue *queue) -{ - struct GNUNET_HashCode dh; - - GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &dh); - setup_cipher (&dh, &my_identity, &queue->in_cipher, &queue->in_hmac); -} - /** * Callback called when peerstore store operation for rekey monotime value is finished. * @param cls Queue context the store operation was executed. @@ -1278,6 +1266,23 @@ rekey_monotime_cb (void *cls, queue); } +/** + * Setup cipher of @a queue for decryption. + * + * @param ephemeral ephemeral key we received from the other peer + * @param queue[in,out] queue to initialize decryption cipher for + */ +static void +setup_in_cipher (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, + struct Queue *queue) +{ + struct GNUNET_HashCode dh; + + GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &dh); + setup_cipher (&dh, &my_identity, &queue->in_cipher, &queue->in_hmac); +} + + /** * Handle @a rekey message on @a queue. The message was already * HMAC'ed, but we should additionally still check the signature. @@ -1415,6 +1420,220 @@ handshake_ack_monotime_cb (void *cls, queue); } +/** + * Sending challenge with TcpConfirmationAck back to sender of ephemeral key. + * + * @param tc The TCPConfirmation originally send. + * @param queue The queue context. + */ +static void +send_challenge (struct ChallengeNonceP challenge, struct Queue *queue) +{ + struct TCPConfirmationAck tca; + struct TcpHandshakeAckSignature thas; + + GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG, + "transport", + "sending challenge\n"); + + tca.header.type = ntohs ( + GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK); + tca.header.size = ntohs (sizeof(tca)); + tca.challenge = challenge; + tca.sender = my_identity; + tca.monotonic_time = + GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); + thas.purpose.purpose = htonl ( + GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE_ACK); + thas.purpose.size = htonl (sizeof(thas)); + thas.sender = my_identity; + thas.receiver = queue->target; + thas.monotonic_time = tca.monotonic_time; + thas.challenge = tca.challenge; + GNUNET_CRYPTO_eddsa_sign (my_private_key, + &thas, + &tca.sender_sig); + GNUNET_assert (0 == + gcry_cipher_encrypt (queue->out_cipher, + &queue->cwrite_buf[queue->cwrite_off], + sizeof(tca), + &tca, + sizeof(tca))); + queue->cwrite_off += sizeof(tca); + GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG, + "transport", + "sending challenge done\n"); +} + +/** + * Setup cipher for outgoing data stream based on target and + * our ephemeral private key. + * + * @param queue queue to setup outgoing (encryption) cipher for + */ +static void +setup_out_cipher (struct Queue *queue) +{ + struct GNUNET_HashCode dh; + + GNUNET_CRYPTO_ecdh_eddsa (&queue->ephemeral, &queue->target.public_key, &dh); + /* we don't need the private key anymore, drop it! */ + memset (&queue->ephemeral, 0, sizeof(queue->ephemeral)); + setup_cipher (&dh, &queue->target, &queue->out_cipher, &queue->out_hmac); + queue->rekey_time = GNUNET_TIME_relative_to_absolute (rekey_interval); + queue->rekey_left_bytes = + GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, REKEY_MAX_BYTES); +} + + +/** + * Inject a `struct TCPRekey` message into the queue's plaintext + * buffer. + * + * @param queue queue to perform rekeying on + */ +static void +inject_rekey (struct Queue *queue) +{ + struct TCPRekey rekey; + struct TcpRekeySignature thp; + + GNUNET_assert (0 == queue->pwrite_off); + memset (&rekey, 0, sizeof(rekey)); + GNUNET_CRYPTO_ecdhe_key_create (&queue->ephemeral); + rekey.header.type = ntohs (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY); + rekey.header.size = ntohs (sizeof(rekey)); + GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &rekey.ephemeral); + rekey.monotonic_time = + GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); + thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); + thp.purpose.size = htonl (sizeof(thp)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "inject_rekey size %u\n", + thp.purpose.size); + thp.sender = my_identity; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "sender %s\n", + GNUNET_p2s (&thp.sender.public_key)); + thp.receiver = queue->target; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "receiver %s\n", + GNUNET_p2s (&thp.receiver.public_key)); + thp.ephemeral = rekey.ephemeral; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "ephemeral %s\n", + GNUNET_e2s (&thp.ephemeral)); + thp.monotonic_time = rekey.monotonic_time; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "time %s\n", + GNUNET_STRINGS_absolute_time_to_string ( + GNUNET_TIME_absolute_ntoh (thp.monotonic_time))); + GNUNET_CRYPTO_eddsa_sign (my_private_key, + &thp, + &rekey.sender_sig); + calculate_hmac (&queue->out_hmac, &rekey, sizeof(rekey), &rekey.hmac); + /* Encrypt rekey message with 'old' cipher */ + GNUNET_assert (0 == + gcry_cipher_encrypt (queue->out_cipher, + &queue->cwrite_buf[queue->cwrite_off], + sizeof(rekey), + &rekey, + sizeof(rekey))); + queue->cwrite_off += sizeof(rekey); + /* Setup new cipher for successive messages */ + gcry_cipher_close (queue->out_cipher); + setup_out_cipher (queue); +} + +/** + * We have been notified that our socket is ready to write. + * Then reschedule this function to be called again once more is available. + * + * @param cls a `struct Queue` + */ +static void +queue_write (void *cls) +{ + struct Queue *queue = cls; + ssize_t sent; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "In queue write\n"); + queue->write_task = NULL; + if (0 != queue->cwrite_off) + { + sent = GNUNET_NETWORK_socket_send (queue->sock, + queue->cwrite_buf, + queue->cwrite_off); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sent %lu bytes to TCP queue\n", sent); + if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno)) + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); + queue_destroy (queue); + return; + } + if (sent > 0) + { + size_t usent = (size_t) sent; + queue->cwrite_off -= usent; + memmove (queue->cwrite_buf, + &queue->cwrite_buf[usent], + queue->cwrite_off); + reschedule_queue_timeout (queue); + } + } + /* can we encrypt more? (always encrypt full messages, needed + such that #mq_cancel() can work!) */ + if ((0 < queue->rekey_left_bytes) && + (queue->pwrite_off > 0) && + (queue->cwrite_off + queue->pwrite_off <= BUF_SIZE)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Encrypting %lu bytes\n", queue->pwrite_off); + GNUNET_assert (0 == + gcry_cipher_encrypt (queue->out_cipher, + &queue->cwrite_buf[queue->cwrite_off], + queue->pwrite_off, + queue->pwrite_buf, + queue->pwrite_off)); + if (queue->rekey_left_bytes > queue->pwrite_off) + queue->rekey_left_bytes -= queue->pwrite_off; + else + queue->rekey_left_bytes = 0; + queue->cwrite_off += queue->pwrite_off; + queue->pwrite_off = 0; + } + // if ((-1 != unverified_size)&& ((0 == queue->pwrite_off) && + if (((0 == queue->pwrite_off) && + ((0 == queue->rekey_left_bytes) || + (0 == + GNUNET_TIME_absolute_get_remaining ( + queue->rekey_time).rel_value_us)))) + { + inject_rekey (queue); + } + if ((0 == queue->pwrite_off) && (! queue->finishing) && + (GNUNET_YES == queue->mq_awaits_continue)) + { + queue->mq_awaits_continue = GNUNET_NO; + GNUNET_MQ_impl_send_continue (queue->mq); + } + /* did we just finish writing 'finish'? */ + if ((0 == queue->cwrite_off) && (GNUNET_YES == queue->finishing)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Finishing queue\n"); + queue_destroy (queue); + return; + } + /* do we care to write more? */ + if ((0 < queue->cwrite_off) || (0 < queue->pwrite_off)) + queue->write_task = + GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + queue->sock, + &queue_write, + queue); +} + /** * Test if we have received a full message in plaintext. * If so, handle it. @@ -1450,16 +1669,16 @@ try_handle_plaintext (struct Queue *queue) return 0; /* not even a header */ } - /* if ((-1 != unverified_size) && (unverified_size > INITIAL_CORE_KX_SIZE)) */ - /* { */ - /* GNUNET_log (GNUNET_ERROR_TYPE_ERROR, */ - /* "Already received data of size %lu bigger than KX size %lu!\n", */ - /* unverified_size, */ - /* INITIAL_CORE_KX_SIZE); */ - /* GNUNET_break_op (0); */ - /* queue_finish (queue); */ - /* return 0; */ - /* } */ + if ((-1 != unverified_size) && (unverified_size > INITIAL_CORE_KX_SIZE)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Already received data of size %lu bigger than KX size %lu!\n", + unverified_size, + INITIAL_CORE_KX_SIZE); + GNUNET_break_op (0); + queue_finish (queue); + return 0; + } type = ntohs (hdr->type); switch (type) @@ -1520,43 +1739,53 @@ try_handle_plaintext (struct Queue *queue) queue); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Handling plaintext, ack processed!"); - - // unverified_size = -1; - - /* char *foreign_addr; */ - - /* switch (queue->address->sa_family) */ - /* { */ - /* case AF_INET: */ - /* GNUNET_asprintf (&foreign_addr, */ - /* "%s-%s", */ - /* COMMUNICATOR_ADDRESS_PREFIX, */ - /* GNUNET_a2s (queue->address, queue->address_len)); */ - /* break; */ - - /* case AF_INET6: */ - /* GNUNET_asprintf (&foreign_addr, */ - /* "%s-%s", */ - /* COMMUNICATOR_ADDRESS_PREFIX, */ - /* GNUNET_a2s (queue->address, queue->address_len)); */ - /* break; */ - - /* default: */ - /* GNUNET_assert (0); */ - /* } */ - - /* queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch, */ - /* &queue->target, */ - /* foreign_addr, */ - /* 0 /\* no MTU *\/, */ - /* GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, */ - /* 0, /\* Priority *\/ */ - /* queue->nt, */ - /* queue->cs, */ - /* queue->mq); */ - - /* GNUNET_free (foreign_addr); */ + "Handling plaintext, ack processed!\n"); + + if (GNUNET_TRANSPORT_CS_INBOUND == queue->cs) + { + send_challenge (queue->challenge_received, queue); + queue->write_task = + GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + queue->sock, + &queue_write, + queue); + } + + unverified_size = -1; + + char *foreign_addr; + + switch (queue->address->sa_family) + { + case AF_INET: + GNUNET_asprintf (&foreign_addr, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_a2s (queue->address, queue->address_len)); + break; + + case AF_INET6: + GNUNET_asprintf (&foreign_addr, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_a2s (queue->address, queue->address_len)); + break; + + default: + GNUNET_assert (0); + } + + queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch, + &queue->target, + foreign_addr, + 0 /* no MTU */, + GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, + 0, /* Priority */ + queue->nt, + queue->cs, + queue->mq); + + GNUNET_free (foreign_addr); size = ntohs (hdr->size); break; @@ -1633,8 +1862,8 @@ try_handle_plaintext (struct Queue *queue) return 0; } GNUNET_assert (0 != size); - /* if (-1 != unverified_size) */ - /* unverified_size += size; */ + if (-1 != unverified_size) + unverified_size += size; return size; } @@ -2043,178 +2272,6 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len) return in; } - -/** - * Setup cipher for outgoing data stream based on target and - * our ephemeral private key. - * - * @param queue queue to setup outgoing (encryption) cipher for - */ -static void -setup_out_cipher (struct Queue *queue) -{ - struct GNUNET_HashCode dh; - - GNUNET_CRYPTO_ecdh_eddsa (&queue->ephemeral, &queue->target.public_key, &dh); - /* we don't need the private key anymore, drop it! */ - memset (&queue->ephemeral, 0, sizeof(queue->ephemeral)); - setup_cipher (&dh, &queue->target, &queue->out_cipher, &queue->out_hmac); - queue->rekey_time = GNUNET_TIME_relative_to_absolute (rekey_interval); - queue->rekey_left_bytes = - GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, REKEY_MAX_BYTES); -} - - -/** - * Inject a `struct TCPRekey` message into the queue's plaintext - * buffer. - * - * @param queue queue to perform rekeying on - */ -static void -inject_rekey (struct Queue *queue) -{ - struct TCPRekey rekey; - struct TcpRekeySignature thp; - - GNUNET_assert (0 == queue->pwrite_off); - memset (&rekey, 0, sizeof(rekey)); - GNUNET_CRYPTO_ecdhe_key_create (&queue->ephemeral); - rekey.header.type = ntohs (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY); - rekey.header.size = ntohs (sizeof(rekey)); - GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &rekey.ephemeral); - rekey.monotonic_time = - GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); - thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); - thp.purpose.size = htonl (sizeof(thp)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "inject_rekey size %u\n", - thp.purpose.size); - thp.sender = my_identity; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "sender %s\n", - GNUNET_p2s (&thp.sender.public_key)); - thp.receiver = queue->target; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "receiver %s\n", - GNUNET_p2s (&thp.receiver.public_key)); - thp.ephemeral = rekey.ephemeral; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "ephemeral %s\n", - GNUNET_e2s (&thp.ephemeral)); - thp.monotonic_time = rekey.monotonic_time; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "time %s\n", - GNUNET_STRINGS_absolute_time_to_string ( - GNUNET_TIME_absolute_ntoh (thp.monotonic_time))); - GNUNET_CRYPTO_eddsa_sign (my_private_key, - &thp, - &rekey.sender_sig); - calculate_hmac (&queue->out_hmac, &rekey, sizeof(rekey), &rekey.hmac); - /* Encrypt rekey message with 'old' cipher */ - GNUNET_assert (0 == - gcry_cipher_encrypt (queue->out_cipher, - &queue->cwrite_buf[queue->cwrite_off], - sizeof(rekey), - &rekey, - sizeof(rekey))); - queue->cwrite_off += sizeof(rekey); - /* Setup new cipher for successive messages */ - gcry_cipher_close (queue->out_cipher); - setup_out_cipher (queue); -} - - -/** - * We have been notified that our socket is ready to write. - * Then reschedule this function to be called again once more is available. - * - * @param cls a `struct Queue` - */ -static void -queue_write (void *cls) -{ - struct Queue *queue = cls; - ssize_t sent; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "In queue write\n"); - queue->write_task = NULL; - if (0 != queue->cwrite_off) - { - sent = GNUNET_NETWORK_socket_send (queue->sock, - queue->cwrite_buf, - queue->cwrite_off); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Sent %lu bytes to TCP queue\n", sent); - if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno)) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); - queue_destroy (queue); - return; - } - if (sent > 0) - { - size_t usent = (size_t) sent; - queue->cwrite_off -= usent; - memmove (queue->cwrite_buf, - &queue->cwrite_buf[usent], - queue->cwrite_off); - reschedule_queue_timeout (queue); - } - } - /* can we encrypt more? (always encrypt full messages, needed - such that #mq_cancel() can work!) */ - if ((0 < queue->rekey_left_bytes) && - (queue->pwrite_off > 0) && - (queue->cwrite_off + queue->pwrite_off <= BUF_SIZE)) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Encrypting %lu bytes\n", queue->pwrite_off); - GNUNET_assert (0 == - gcry_cipher_encrypt (queue->out_cipher, - &queue->cwrite_buf[queue->cwrite_off], - queue->pwrite_off, - queue->pwrite_buf, - queue->pwrite_off)); - if (queue->rekey_left_bytes > queue->pwrite_off) - queue->rekey_left_bytes -= queue->pwrite_off; - else - queue->rekey_left_bytes = 0; - queue->cwrite_off += queue->pwrite_off; - queue->pwrite_off = 0; - } - // if ((-1 != unverified_size)&& ((0 == queue->pwrite_off) && - if (((0 == queue->pwrite_off) && - ((0 == queue->rekey_left_bytes) || - (0 == - GNUNET_TIME_absolute_get_remaining ( - queue->rekey_time).rel_value_us)))) - { - inject_rekey (queue); - } - if ((0 == queue->pwrite_off) && (! queue->finishing) && - (GNUNET_YES == queue->mq_awaits_continue)) - { - queue->mq_awaits_continue = GNUNET_NO; - GNUNET_MQ_impl_send_continue (queue->mq); - } - /* did we just finish writing 'finish'? */ - if ((0 == queue->cwrite_off) && (GNUNET_YES == queue->finishing)) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Finishing queue\n"); - queue_destroy (queue); - return; - } - /* do we care to write more? */ - if ((0 < queue->cwrite_off) || (0 < queue->pwrite_off)) - queue->write_task = - GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, - queue->sock, - &queue_write, - queue); -} - - /** * Signature of functions implementing the sending functionality of a * message queue. @@ -2348,39 +2405,39 @@ boot_queue (struct Queue *queue) NULL, &mq_error, queue); - { - char *foreign_addr; - - switch (queue->address->sa_family) - { - case AF_INET: - GNUNET_asprintf (&foreign_addr, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_a2s (queue->address, queue->address_len)); - break; - - case AF_INET6: - GNUNET_asprintf (&foreign_addr, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_a2s (queue->address, queue->address_len)); - break; - - default: - GNUNET_assert (0); - } - queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch, - &queue->target, - foreign_addr, - 0 /* no MTU */, - GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, - 0, /* Priority */ - queue->nt, - queue->cs, - queue->mq); - GNUNET_free (foreign_addr); - } + /* { */ + /* char *foreign_addr; */ + + /* switch (queue->address->sa_family) */ + /* { */ + /* case AF_INET: */ + /* GNUNET_asprintf (&foreign_addr, */ + /* "%s-%s", */ + /* COMMUNICATOR_ADDRESS_PREFIX, */ + /* GNUNET_a2s (queue->address, queue->address_len)); */ + /* break; */ + + /* case AF_INET6: */ + /* GNUNET_asprintf (&foreign_addr, */ + /* "%s-%s", */ + /* COMMUNICATOR_ADDRESS_PREFIX, */ + /* GNUNET_a2s (queue->address, queue->address_len)); */ + /* break; */ + + /* default: */ + /* GNUNET_assert (0); */ + /* } */ + /* queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch, */ + /* &queue->target, */ + /* foreign_addr, */ + /* 0 /\* no MTU *\/, */ + /* GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, */ + /* 0, /\* Priority *\/ */ + /* queue->nt, */ + /* queue->cs, */ + /* queue->mq); */ + /* GNUNET_free (foreign_addr); */ + /* } */ } @@ -2594,48 +2651,6 @@ free_proto_queue (struct ProtoQueue *pq) GNUNET_free (pq); } -/** - * Sending challenge with TcpConfirmationAck back to sender of ephemeral key. - * - * @param tc The TCPConfirmation originally send. - * @param queue The queue context. - */ -static void -send_challenge (struct ChallengeNonceP challenge, struct Queue *queue) -{ - struct TCPConfirmationAck tca; - struct TcpHandshakeAckSignature thas; - - GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG, - "transport", - "sending challenge\n"); - - tca.header.type = ntohs ( - GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK); - tca.header.size = ntohs (sizeof(tca)); - tca.challenge = challenge; - tca.sender = my_identity; - tca.monotonic_time = - GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); - thas.purpose.purpose = htonl ( - GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE_ACK); - thas.purpose.size = htonl (sizeof(thas)); - thas.sender = my_identity; - thas.receiver = queue->target; - thas.monotonic_time = tca.monotonic_time; - thas.challenge = tca.challenge; - GNUNET_CRYPTO_eddsa_sign (my_private_key, - &thas, - &tca.sender_sig); - GNUNET_assert (0 == - gcry_cipher_encrypt (queue->out_cipher, - &queue->cwrite_buf[queue->cwrite_off], - sizeof(tca), - &tca, - sizeof(tca))); - queue->cwrite_off += sizeof(tca); -} - /** * Read from the socket of the proto queue until we have enough data * to upgrade to full queue. @@ -2722,7 +2737,8 @@ proto_read_kx (void *cls) &queue_write, queue); // TODO To early! Move it somewhere else. - // send_challenge (tc, queue); + // send_challenge (tc.challenge, queue); + queue->challenge_received = tc.challenge; GNUNET_CONTAINER_DLL_remove (proto_head, proto_tail, pq); GNUNET_free (pq); @@ -2853,6 +2869,12 @@ queue_read_kx (void *cls) return; } send_challenge (tc.challenge, queue); + queue->write_task = + GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + queue->sock, + &queue_write, + queue); + /* update queue timeout */ reschedule_queue_timeout (queue); /* prepare to continue with regular read task immediately */ @@ -2866,7 +2888,7 @@ queue_read_kx (void *cls) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "cread_off set to %lu bytes\n", queue->cread_off); - if (0 < queue->cread_off) + if (0 <= queue->cread_off) queue->read_task = GNUNET_SCHEDULER_add_now (&queue_read, queue); } diff --git a/src/transport/gnunet-communicator-udp.c b/src/transport/gnunet-communicator-udp.c index 018da8f0e..2e09bc9d2 100644 --- a/src/transport/gnunet-communicator-udp.c +++ b/src/transport/gnunet-communicator-udp.c @@ -1882,6 +1882,7 @@ consider_ss_ack (struct SharedSecret *ss, int initial) // kce_generate (ss, ++ss->sequence_allowed); // kce_generate (ss, ++ss->sequence_allowed); + // TODO This task must be per sender! kce_task = GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL, kce_generate_cb, ss); diff --git a/src/transport/test_communicator_basic.c b/src/transport/test_communicator_basic.c index 0250de474..ffc21e47a 100644 --- a/src/transport/test_communicator_basic.c +++ b/src/transport/test_communicator_basic.c @@ -42,7 +42,7 @@ #define NUM_PEERS 2 -static struct GNUNET_SCHEDULER_Task *to_task; +static struct GNUNET_SCHEDULER_Task *to_task[NUM_PEERS]; static int queue_est = GNUNET_NO; @@ -59,27 +59,29 @@ static struct GNUNET_STATISTICS_Handle *stats[NUM_PEERS]; static char *cfg_peers_name[NUM_PEERS]; +static int finished[NUM_PEERS]; + static int ret; static int bidirect = GNUNET_NO; static size_t long_message_size; -static struct GNUNET_TIME_Absolute start_short; +static struct GNUNET_TIME_Absolute start_short[NUM_PEERS]; -static struct GNUNET_TIME_Absolute start_long; +static struct GNUNET_TIME_Absolute start_long[NUM_PEERS]; -static struct GNUNET_TIME_Absolute timeout; +static struct GNUNET_TIME_Absolute timeout[NUM_PEERS]; -static struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *my_tc; +// static struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *my_tc; static char *communicator_name; static char *test_name; -static struct GNUNET_STATISTICS_GetHandle *box_stats; +static struct GNUNET_STATISTICS_GetHandle *box_stats[NUM_PEERS]; -static struct GNUNET_STATISTICS_GetHandle *rekey_stats; +static struct GNUNET_STATISTICS_GetHandle *rekey_stats[NUM_PEERS]; #define TEST_SECTION "test-setup" @@ -97,7 +99,7 @@ static struct GNUNET_STATISTICS_GetHandle *rekey_stats; #define PEER_B 1 -static unsigned int iterations_left = TOTAL_ITERATIONS; +static unsigned int iterations_left[NUM_PEERS]; #define TIMEOUT_MULTIPLIER 1 @@ -118,11 +120,11 @@ enum TestPhase TP_SIZE_CHECK }; -static unsigned int phase_short; +static unsigned int phase_short[NUM_PEERS]; -static unsigned int phase_long; +static unsigned int phase_long[NUM_PEERS]; -static unsigned int phase_size; +static unsigned int phase_size[NUM_PEERS]; static long long unsigned int allowed_packet_loss_short; @@ -140,26 +142,23 @@ static struct GNUNET_TIME_Relative delay_short; static struct GNUNET_TIME_Relative delay_long; -static size_t num_sent_short = 0; - -static size_t num_sent_long = 0; - -static size_t num_sent_size = 0; +static size_t num_sent_short[NUM_PEERS]; -static uint32_t ack = 0; +static size_t num_sent_long[NUM_PEERS]; -static enum TestPhase phase; +static size_t num_sent_size[NUM_PEERS]; -static size_t num_received_short = 0; +static uint32_t ack[NUM_PEERS]; -static size_t num_received_long = 0; +static enum TestPhase phase[NUM_PEERS]; -static size_t num_received_size = 0; +static size_t num_received_short[NUM_PEERS]; -static uint64_t avg_latency = 0; +static size_t num_received_long[NUM_PEERS]; -static struct GNUNET_TIME_Relative duration; +static size_t num_received_size[NUM_PEERS]; +static uint64_t avg_latency[NUM_PEERS]; static void communicator_available_cb ( @@ -284,43 +283,87 @@ make_payload (size_t payload_size) return payload; } +static struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle * +get_tc_h (unsigned int peer_nr) +{ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got peer %u\n", + peer_nr); + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Handle %p peer 0\n", + tc_hs[0]); + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Handle %p peer 1\n", + tc_hs[1]); + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Handle %p get\n", + tc_hs[peer_nr]); + + return tc_hs[peer_nr]; +} + + +static unsigned int +get_peer_nr_from_tc (struct + GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h) +{ + if (tc_h == get_tc_h (0)) + return PEER_A; + else + return PEER_B; +} + +static unsigned int +get_peer_nr (void *cls, unsigned int get_the_other_one) +{ + if (0 == strcmp ((char*) cls, cfg_peers_name[0])) + return get_the_other_one ? PEER_B : PEER_A; + else + return get_the_other_one ? PEER_A : PEER_B; +} static void latency_timeout (void *cls) { + struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; + unsigned int peer_nr; size_t num_sent = 0; size_t num_received = 0; - to_task = NULL; - if (GNUNET_TIME_absolute_get_remaining (timeout).rel_value_us > 0) + peer_nr = get_peer_nr_from_tc (tc_h); + to_task[peer_nr] = NULL; + if (GNUNET_TIME_absolute_get_remaining (timeout[peer_nr]).rel_value_us > 0) { - to_task = GNUNET_SCHEDULER_add_at (timeout, - &latency_timeout, - NULL); + to_task[peer_nr] = GNUNET_SCHEDULER_add_at (timeout[peer_nr], + &latency_timeout, + cls); return; } - switch (phase) + switch (phase[peer_nr]) { case TP_INIT: GNUNET_assert (0); break; case TP_BURST_SHORT: - num_sent = num_sent_short; - num_received = num_received_short; + num_sent = num_sent_short[peer_nr]; + num_received = num_received_short[peer_nr]; break; case TP_BURST_LONG: - num_sent = num_sent_long; - num_received = num_received_long; + num_sent = num_sent_long[peer_nr]; + num_received = num_received_long[peer_nr]; break; case TP_SIZE_CHECK: - num_sent = num_sent_size; - num_received = num_received_size; + num_sent = num_sent_size[peer_nr]; + num_received = num_received_size[peer_nr]; break; } LOG (GNUNET_ERROR_TYPE_ERROR, "Latency too high. Test failed. (Phase: %d. Sent: %lu, Received: %lu)\n", - phase, num_sent, num_received); + phase[peer_nr], num_sent, num_received); ret = 2; GNUNET_SCHEDULER_shutdown (); } @@ -328,31 +371,36 @@ latency_timeout (void *cls) static void size_test (void *cls) { + unsigned int peer_nr; char *payload; size_t max_size = 64000; + struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; + peer_nr = get_peer_nr_from_tc (tc_h); LOG (GNUNET_ERROR_TYPE_DEBUG, "size_test_cb %u\n", - (unsigned int) num_sent_size); - GNUNET_assert (TP_SIZE_CHECK == phase); + (unsigned int) num_sent_size[peer_nr]); + GNUNET_assert (TP_SIZE_CHECK == phase[peer_nr]); if (LONG_MESSAGE_SIZE != long_message_size) max_size = long_message_size; - if (ack + 10 > max_size) + if (ack[peer_nr] + 10 > max_size) return; /* Leave some room for our protocol, so not 2^16 exactly */ - ack += 10; - payload = make_payload (ack); - num_sent_size++; - GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, - (ack < max_size) + ack[peer_nr] += 10; + payload = make_payload (ack[peer_nr]); + num_sent_size[peer_nr]++; + GNUNET_TRANSPORT_TESTING_transport_communicator_send (tc_h, + (ack[peer_nr] < + max_size) ? &size_test : NULL, - NULL, + cls, payload, - ack); + ack[peer_nr]); GNUNET_free (payload); - timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply ( - GNUNET_TIME_UNIT_SECONDS, - TIMEOUT_MULTIPLIER)); + timeout[peer_nr] = GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_relative_multiply ( + GNUNET_TIME_UNIT_SECONDS, + TIMEOUT_MULTIPLIER)); } @@ -362,24 +410,28 @@ long_test (void *cls); static void long_test_cb (void *cls) { + unsigned int peer_nr; char *payload; + struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; + + peer_nr = get_peer_nr_from_tc (tc_h); LOG (GNUNET_ERROR_TYPE_DEBUG, "long_test_cb %u/%u\n", - (unsigned int) num_sent_long, - (unsigned int) num_received_long); + (unsigned int) num_sent_long[peer_nr], + (unsigned int) num_received_long[peer_nr]); payload = make_payload (long_message_size); - num_sent_long++; - GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, + num_sent_long[peer_nr]++; + GNUNET_TRANSPORT_TESTING_transport_communicator_send (tc_h, (burst_packets_long == - num_sent_long) + num_sent_long[peer_nr]) ? NULL : &long_test, - NULL, + cls, payload, long_message_size); GNUNET_free (payload); - timeout = GNUNET_TIME_relative_to_absolute ( + timeout[peer_nr] = GNUNET_TIME_relative_to_absolute ( GNUNET_TIME_relative_multiply ( GNUNET_TIME_UNIT_SECONDS, TIMEOUT_MULTIPLIER)); @@ -391,7 +443,7 @@ long_test (void *cls) { GNUNET_SCHEDULER_add_delayed (delay_long, &long_test_cb, - NULL); + cls); } @@ -402,26 +454,33 @@ short_test (void *cls); static void short_test_cb (void *cls) { + struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; + unsigned int peer_nr; char *payload; + peer_nr = get_peer_nr_from_tc (tc_h); + LOG (GNUNET_ERROR_TYPE_DEBUG, - "short_test_cb %u/%u\n", - (unsigned int) num_sent_short, - (unsigned int) num_received_short); + "short_test_cb %u/%u for peer %u and handle %p\n", + (unsigned int) num_sent_short[peer_nr], + (unsigned int) num_received_short[peer_nr], + peer_nr, + tc_h); payload = make_payload (SHORT_MESSAGE_SIZE); - num_sent_short++; - GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, + num_sent_short[peer_nr]++; + GNUNET_TRANSPORT_TESTING_transport_communicator_send (tc_h, (burst_packets_short == - num_sent_short) + num_sent_short[peer_nr]) ? NULL : &short_test, - NULL, + cls, payload, SHORT_MESSAGE_SIZE); GNUNET_free (payload); - timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply ( - GNUNET_TIME_UNIT_SECONDS, - TIMEOUT_MULTIPLIER)); + timeout[peer_nr] = GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_relative_multiply ( + GNUNET_TIME_UNIT_SECONDS, + TIMEOUT_MULTIPLIER)); } @@ -430,7 +489,7 @@ short_test (void *cls) { GNUNET_SCHEDULER_add_delayed (delay_short, &short_test_cb, - NULL); + cls); } @@ -462,9 +521,14 @@ short_test (void *cls) static void process_statistics_box_done (void *cls, int success) { - if (NULL != box_stats) - box_stats = NULL; - if (NULL == rekey_stats) + struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; + unsigned int peer_nr; + + peer_nr = get_peer_nr_from_tc (tc_h); + + if (NULL != box_stats[peer_nr]) + box_stats[peer_nr] = NULL; + if (NULL == rekey_stats[peer_nr]) { LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished\n"); @@ -476,9 +540,14 @@ process_statistics_box_done (void *cls, int success) static void process_statistics_rekey_done (void *cls, int success) { - if (NULL != rekey_stats) - rekey_stats = NULL; - if (NULL == box_stats) + struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; + unsigned int peer_nr; + + peer_nr = get_peer_nr_from_tc (tc_h); + + if (NULL != rekey_stats[peer_nr]) + rekey_stats[peer_nr] = NULL; + if (NULL == box_stats[peer_nr]) { LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished\n"); @@ -533,24 +602,37 @@ process_statistics (void *cls, } static void -choose_phase () +choose_phase (struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h) { - if (GNUNET_YES == phase_short) + unsigned int peer_nr; + + peer_nr = get_peer_nr_from_tc (tc_h); + + if (GNUNET_YES == phase_short[peer_nr]) { - phase = TP_BURST_SHORT; - start_short = GNUNET_TIME_absolute_get (); - short_test (NULL); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Choose phase short with peer %u and Handle %p\n", + peer_nr, + tc_h); + phase[peer_nr] = TP_BURST_SHORT; + start_short[peer_nr] = GNUNET_TIME_absolute_get (); + short_test (tc_h); } - else if (GNUNET_YES == phase_long) + else if (GNUNET_YES == phase_long[peer_nr]) { - phase = TP_BURST_LONG; - start_long = GNUNET_TIME_absolute_get (); - long_test (NULL); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Choose phase long with peer %u\n", + peer_nr); + phase[peer_nr] = TP_BURST_LONG; + start_long[peer_nr] = GNUNET_TIME_absolute_get (); + long_test (tc_h); } - else if (GNUNET_YES == phase_size) + else if (GNUNET_YES == phase_size[peer_nr]) { - phase = TP_SIZE_CHECK; - size_test (NULL); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Choose phase size\n"); + phase[peer_nr] = TP_SIZE_CHECK; + size_test (tc_h); } else { @@ -560,28 +642,33 @@ choose_phase () "backchannel", test_name))) ) { - if (NULL != box_stats) - GNUNET_STATISTICS_get_cancel (box_stats); - box_stats = GNUNET_STATISTICS_get (stats[1], - "C-UDP", - "# messages decrypted with BOX", - process_statistics_box_done, - &process_statistics, - NULL); - if (NULL != rekey_stats) - GNUNET_STATISTICS_get_cancel (rekey_stats); - rekey_stats = GNUNET_STATISTICS_get (stats[0], - "C-UDP", - "# rekeying successful", - process_statistics_rekey_done, - &process_statistics, - NULL); + if (NULL != box_stats[peer_nr]) + GNUNET_STATISTICS_get_cancel (box_stats[peer_nr]); + box_stats[peer_nr] = GNUNET_STATISTICS_get (stats[1], + "C-UDP", + "# messages decrypted with BOX", + process_statistics_box_done, + &process_statistics, + tc_h); + if (NULL != rekey_stats[peer_nr]) + GNUNET_STATISTICS_get_cancel (rekey_stats[peer_nr]); + rekey_stats[peer_nr] = GNUNET_STATISTICS_get (stats[0], + "C-UDP", + "# rekeying successful", + process_statistics_rekey_done, + &process_statistics, + tc_h); } else { - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Finished\n"); - GNUNET_SCHEDULER_shutdown (); + if (((PEER_A == peer_nr) && finished[PEER_B]) || ((PEER_B == peer_nr) && + finished[PEER_A])) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Finished\n"); + GNUNET_SCHEDULER_shutdown (); + } + finished[peer_nr] = GNUNET_YES; } } } @@ -604,37 +691,54 @@ add_queue_cb (void *cls, tc_queue, size_t mtu) { - if (TP_INIT != phase) - return; - if (0 != strcmp ((char*) cls, cfg_peers_name[0])) + + unsigned int peer_nr; + + peer_nr = get_peer_nr (cls, GNUNET_NO); + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Handle %p add %u %u\n", + tc_h, + peer_nr, + get_peer_nr_from_tc (tc_h)); + + if ((GNUNET_NO == bidirect)&&(0 != strcmp ((char*) cls, cfg_peers_name[0]))) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Queue available at receiving peer\n"); return; // TODO? + } + else if (TP_INIT != phase[peer_nr]) + return; LOG (GNUNET_ERROR_TYPE_DEBUG, "Queue established, starting test...\n"); // start_short = GNUNET_TIME_absolute_get (); - my_tc = tc_h; + // my_tc = tc_h; if (0 != mtu) /* Message header overhead */ long_message_size = mtu - sizeof(struct GNUNET_TRANSPORT_SendMessageTo) - sizeof(struct GNUNET_MessageHeader); else long_message_size = LONG_MESSAGE_SIZE; // phase = TP_BURST_SHORT; - timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply ( - GNUNET_TIME_UNIT_SECONDS, - TIMEOUT_MULTIPLIER)); - GNUNET_assert (NULL == to_task); - to_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply ( - GNUNET_TIME_UNIT_SECONDS, - TIMEOUT_MULTIPLIER), - &latency_timeout, - NULL); + timeout[peer_nr] = GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_relative_multiply ( + GNUNET_TIME_UNIT_SECONDS, + TIMEOUT_MULTIPLIER)); + GNUNET_assert (NULL == to_task[peer_nr]); + to_task[peer_nr] = GNUNET_SCHEDULER_add_delayed ( + GNUNET_TIME_relative_multiply ( + GNUNET_TIME_UNIT_SECONDS, + TIMEOUT_MULTIPLIER), + &latency_timeout, + tc_h); // prepare_test (NULL); // short_test (NULL); - choose_phase (); + choose_phase (tc_h); } static void -update_avg_latency (const char*payload) +update_avg_latency (const char *payload, unsigned int peer_nr) { struct GNUNET_TIME_AbsoluteNBO *ts_n; struct GNUNET_TIME_Absolute ts; @@ -645,31 +749,33 @@ update_avg_latency (const char*payload) ts = GNUNET_TIME_absolute_ntoh (*ts_n); latency = GNUNET_TIME_absolute_get_duration (ts); - switch (phase) + switch (phase[peer_nr]) { case TP_INIT: GNUNET_assert (0); break; case TP_BURST_SHORT: - num_received = num_received_short; + num_received = num_received_short[peer_nr]; break; case TP_BURST_LONG: - num_received = num_received_long; + num_received = num_received_long[peer_nr]; break; case TP_SIZE_CHECK: - num_received = num_received_size; + num_received = num_received_size[peer_nr]; break; } if (1 >= num_received) - avg_latency = latency.rel_value_us; + avg_latency[peer_nr] = latency.rel_value_us; else - avg_latency = ((avg_latency * (num_received - 1)) + latency.rel_value_us) - / num_received; + avg_latency[peer_nr] = ((avg_latency[peer_nr] * (num_received - 1)) + + latency.rel_value_us) + / num_received; LOG (GNUNET_ERROR_TYPE_DEBUG, - "Latency of received packet: %s with avg latency %lu\n", + "Latency of received packet by peer %u: %s with avg latency %lu\n", + peer_nr, GNUNET_STRINGS_relative_time_to_string (latency, GNUNET_YES), - avg_latency); + avg_latency[peer_nr]); } @@ -679,25 +785,31 @@ static void load_phase_config () { - phase_short = GNUNET_CONFIGURATION_get_value_yesno (cfg_peers[0], - TEST_SECTION, - "PHASE_SHORT"); - if (GNUNET_SYSERR == phase_short) - phase_short = GNUNET_YES; + phase_short[0] = GNUNET_CONFIGURATION_get_value_yesno (cfg_peers[0], + TEST_SECTION, + "PHASE_SHORT"); + if (GNUNET_SYSERR == phase_short[0]) + phase_short[0] = GNUNET_YES; - phase_long = GNUNET_CONFIGURATION_get_value_yesno (cfg_peers[0], - TEST_SECTION, - "PHASE_LONG"); + phase_short[1] = phase_short[0]; - if (GNUNET_SYSERR == phase_long) - phase_long = GNUNET_YES; + phase_long[0] = GNUNET_CONFIGURATION_get_value_yesno (cfg_peers[0], + TEST_SECTION, + "PHASE_LONG"); - phase_size = GNUNET_CONFIGURATION_get_value_yesno (cfg_peers[0], - TEST_SECTION, - "PHASE_SIZE"); + if (GNUNET_SYSERR == phase_long[0]) + phase_long[0] = GNUNET_YES; - if (GNUNET_SYSERR == phase_size) - phase_size = GNUNET_YES; + phase_long[1] = phase_long[0]; + + phase_size[0] = GNUNET_CONFIGURATION_get_value_yesno (cfg_peers[0], + TEST_SECTION, + "PHASE_SIZE"); + + if (GNUNET_SYSERR == phase_size[0]) + phase_size[0] = GNUNET_YES; + + phase_size[1] = phase_size[0]; } /** @@ -716,18 +828,24 @@ incoming_message_cb ( const char *payload, size_t payload_len) { - if (0 != strcmp ((char*) cls, - cfg_peers_name[NUM_PEERS - 1])) + unsigned int peer_nr; + static struct GNUNET_TIME_Relative duration; + + peer_nr = get_peer_nr (cls, GNUNET_YES); + + if ((GNUNET_NO == bidirect)&&(0 != strcmp ((char*) cls, + cfg_peers_name[NUM_PEERS - 1]))) { LOG (GNUNET_ERROR_TYPE_WARNING, "unexpected receiver...\n"); return; } /* Reset timeout */ - timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply ( - GNUNET_TIME_UNIT_SECONDS, - TIMEOUT_MULTIPLIER)); - switch (phase) + timeout[peer_nr] = GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_relative_multiply ( + GNUNET_TIME_UNIT_SECONDS, + TIMEOUT_MULTIPLIER)); + switch (phase[peer_nr]) { case TP_INIT: GNUNET_break (0); @@ -735,34 +853,37 @@ incoming_message_cb ( case TP_BURST_SHORT: { GNUNET_assert (SHORT_MESSAGE_SIZE == payload_len); - num_received_short++; - duration = GNUNET_TIME_absolute_get_duration (start_short); - update_avg_latency (payload); - if ((num_sent_short == burst_packets_short) && (num_received_short > - burst_packets_short / 100 - * - allowed_packet_loss_short) ) + num_received_short[peer_nr]++; + duration = GNUNET_TIME_absolute_get_duration (start_short[peer_nr]); + update_avg_latency (payload, peer_nr); + if ((num_sent_short[peer_nr] == burst_packets_short) && + (num_received_short[peer_nr] > + burst_packets_short + / 100 + * + allowed_packet_loss_short) ) { LOG (GNUNET_ERROR_TYPE_MESSAGE, - "Short size packet test done.\n"); + "Short size packet test for peer %u done.\n", + peer_nr); char *goodput = GNUNET_STRINGS_byte_size_fancy ( - (SHORT_MESSAGE_SIZE * num_received_short * 1000 * 1000) + (SHORT_MESSAGE_SIZE * num_received_short[peer_nr] * 1000 * 1000) / duration.rel_value_us); LOG (GNUNET_ERROR_TYPE_MESSAGE, "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n", - (unsigned long) num_received_short, - (unsigned long) num_sent_short, + (unsigned long) num_received_short[peer_nr], + (unsigned long) num_sent_short[peer_nr], (unsigned long long) duration.rel_value_us, goodput, - (unsigned long long) avg_latency); + (unsigned long long) avg_latency[peer_nr]); GNUNET_free (goodput); // start_long = GNUNET_TIME_absolute_get (); // phase = TP_BURST_LONG; // num_sent_short = 0; - avg_latency = 0; + avg_latency[peer_nr] = 0; // num_received = 0; - phase_short = GNUNET_NO; - choose_phase (); + phase_short[peer_nr] = GNUNET_NO; + choose_phase (get_tc_h (peer_nr)); // long_test (NULL); } break; @@ -775,37 +896,40 @@ incoming_message_cb ( "Ignoring packet with wrong length\n"); return; // Ignore } - num_received_long++; - duration = GNUNET_TIME_absolute_get_duration (start_long); - update_avg_latency (payload); - if ((num_sent_long == burst_packets_long) && (num_received_long > - burst_packets_long - / 100 - * allowed_packet_loss_short) ) + num_received_long[peer_nr]++; + duration = GNUNET_TIME_absolute_get_duration (start_long[peer_nr]); + update_avg_latency (payload, peer_nr); + if ((num_sent_long[peer_nr] == burst_packets_long) && + (num_received_long[peer_nr] > + burst_packets_long + / 100 + * + allowed_packet_loss_short) ) { LOG (GNUNET_ERROR_TYPE_MESSAGE, - "Long size packet test done.\n"); + "Long size packet test for peer %u done.\n", + peer_nr); char *goodput = GNUNET_STRINGS_byte_size_fancy ( - (long_message_size * num_received_long * 1000 * 1000) + (long_message_size * num_received_long[peer_nr] * 1000 * 1000) / duration. rel_value_us); LOG (GNUNET_ERROR_TYPE_MESSAGE, "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n", - (unsigned long) num_received_long, - (unsigned long) num_sent_long, + (unsigned long) num_received_long[peer_nr], + (unsigned long) num_sent_long[peer_nr], (unsigned long long) duration.rel_value_us, goodput, - (unsigned long long) avg_latency); + (unsigned long long) avg_latency[peer_nr]); GNUNET_free (goodput); - ack = 0; + ack[peer_nr] = 0; // phase = TP_SIZE_CHECK; // num_received = 0; // num_sent_long = 0; - avg_latency = 0; + avg_latency[peer_nr] = 0; // size_test (NULL); - phase_long = GNUNET_NO; - choose_phase (); + phase_long[peer_nr] = GNUNET_NO; + choose_phase (get_tc_h (peer_nr)); } break; } @@ -813,39 +937,44 @@ incoming_message_cb ( { size_t max_size = 64000; - GNUNET_assert (TP_SIZE_CHECK == phase); + GNUNET_assert (TP_SIZE_CHECK == phase[peer_nr]); if (LONG_MESSAGE_SIZE != long_message_size) max_size = long_message_size; - num_received_size++; - update_avg_latency (payload); - if (num_received_size >= (max_size) / 10) + num_received_size[peer_nr]++; + update_avg_latency (payload, peer_nr); + if ((GNUNET_YES == phase_size[peer_nr]) && (num_received_size[peer_nr] >= + (max_size) / 10) ) { LOG (GNUNET_ERROR_TYPE_MESSAGE, - "Size packet test done.\n"); + "Size packet test for peer %u done.\n", + peer_nr); LOG (GNUNET_ERROR_TYPE_MESSAGE, "%lu/%lu packets -- avg latency: %llu us\n", - (unsigned long) num_received_size, - (unsigned long) num_sent_size, - (unsigned long long) avg_latency); - num_received_size = 0; - num_sent_size = 0; - avg_latency = 0; - iterations_left--; - if (0 != iterations_left) + (unsigned long) num_received_size[peer_nr], + (unsigned long) num_sent_size[peer_nr], + (unsigned long long) avg_latency[peer_nr]); + iterations_left[peer_nr]--; + phase_size[peer_nr] = GNUNET_NO; + if (0 != iterations_left[peer_nr]) { // start_short = GNUNET_TIME_absolute_get (); // phase = TP_BURST_SHORT; - num_sent_short = 0; - num_sent_long = 0; - num_received_short = 0; - num_received_long = 0; + num_received_size[peer_nr] = 0; + num_sent_size[peer_nr] = 0; + avg_latency[peer_nr] = 0; + num_sent_short[peer_nr] = 0; + num_sent_long[peer_nr] = 0; + num_received_short[peer_nr] = 0; + num_received_long[peer_nr] = 0; // short_test (NULL); - load_phase_config (); - choose_phase (); - break; + if (((PEER_A == peer_nr) && finished[PEER_B]) || ((PEER_B == + peer_nr) && + finished[PEER_A])) + { + load_phase_config (); + } } - phase_size = GNUNET_NO; - choose_phase (); + choose_phase (get_tc_h (peer_nr)); } break; } @@ -859,23 +988,23 @@ do_shutdown (void *cls) LOG (GNUNET_ERROR_TYPE_DEBUG, "shuting down test.\n"); - if (NULL != box_stats) - { - GNUNET_STATISTICS_get_cancel (box_stats); - box_stats = NULL; - } - if (NULL != rekey_stats) - { - GNUNET_STATISTICS_get_cancel (rekey_stats); - rekey_stats = NULL; - } - if (NULL != to_task) - { - GNUNET_SCHEDULER_cancel (to_task); - to_task = NULL; - } for (unsigned int i = 0; i < NUM_PEERS; i++) { + if (NULL != box_stats[i]) + { + GNUNET_STATISTICS_get_cancel (box_stats[i]); + box_stats[i] = NULL; + } + if (NULL != rekey_stats[i]) + { + GNUNET_STATISTICS_get_cancel (rekey_stats[i]); + rekey_stats[i] = NULL; + } + if (NULL != to_task[i]) + { + GNUNET_SCHEDULER_cancel (to_task[i]); + to_task[i] = NULL; + } GNUNET_TRANSPORT_TESTING_transport_communicator_service_stop (tc_hs[i]); GNUNET_STATISTICS_destroy (stats[i], GNUNET_NO); } @@ -935,7 +1064,10 @@ main (int argc, char *test_mode; char *cfg_peer; - phase = TP_INIT; + iterations_left[0] = TOTAL_ITERATIONS; + iterations_left[1] = TOTAL_ITERATIONS; + phase[0] = TP_INIT; + phase[1] = TP_INIT; ret = 1; test_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]); communicator_name = strchr (test_name, '-'); -- cgit v1.2.3 From 147e2df41699ac890b2639265434417e41b94b2f Mon Sep 17 00:00:00 2001 From: t3sserakt Date: Mon, 25 Jan 2021 16:54:28 +0100 Subject: - why is tng buildbot failing --- .buildbot/firefly-x86_64-amdepyc_test_tng.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.buildbot/firefly-x86_64-amdepyc_test_tng.sh b/.buildbot/firefly-x86_64-amdepyc_test_tng.sh index f247f5a69..031615517 100755 --- a/.buildbot/firefly-x86_64-amdepyc_test_tng.sh +++ b/.buildbot/firefly-x86_64-amdepyc_test_tng.sh @@ -3,6 +3,6 @@ # echo "Skipped" pushd src/transport -make check TESTS='test_communicator_basic-tcp test_communicator_rekey-tcp test_communicator_basic-unix test_communicator_basic-udp test_communicator_backchannel-udp test_communicator_rekey-udp test_communicator_bidirect-tcp' +make check TESTS='test_communicator_basic-tcp test_communicator_rekey-tcp' pkill --signal 9 -U buildbot gnunet popd -- cgit v1.2.3 From 4df6cc3e77969131b73895334e43eedd67e46326 Mon Sep 17 00:00:00 2001 From: t3sserakt Date: Mon, 25 Jan 2021 16:54:28 +0100 Subject: - why is tng buildbot failing --- .buildbot/firefly-x86_64-amdepyc_test_tng.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.buildbot/firefly-x86_64-amdepyc_test_tng.sh b/.buildbot/firefly-x86_64-amdepyc_test_tng.sh index f247f5a69..cace658d3 100755 --- a/.buildbot/firefly-x86_64-amdepyc_test_tng.sh +++ b/.buildbot/firefly-x86_64-amdepyc_test_tng.sh @@ -3,6 +3,6 @@ # echo "Skipped" pushd src/transport -make check TESTS='test_communicator_basic-tcp test_communicator_rekey-tcp test_communicator_basic-unix test_communicator_basic-udp test_communicator_backchannel-udp test_communicator_rekey-udp test_communicator_bidirect-tcp' +make check TESTS='test_communicator_basic-tcp test_communicator_rekey-tcp test_communicator_basic-udp test_communicator_backchannel-udp test_communicator_rekey-udp test_communicator_bidirect-tcp' pkill --signal 9 -U buildbot gnunet popd -- cgit v1.2.3