[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[gnunet] 02/03: meson: add remaining cadet test
|
From: |
gnunet |
|
Subject: |
[gnunet] 02/03: meson: add remaining cadet test |
|
Date: |
Sun, 15 Oct 2023 10:02:10 +0200 |
This is an automated email from the git hooks/post-receive script.
martin-schanzenbach pushed a commit to branch master
in repository gnunet.
commit e53ce84d02b5ba59495c5ae9c47d43eabbd2aa9b
Author: Martin Schanzenbach <schanzen@gnunet.org>
AuthorDate: Sun Oct 15 10:01:36 2023 +0200
meson: add remaining cadet test
---
src/cadet/Makefile.am | 8 +-
src/cadet/gnunet-cadet-profiler.c | 1157 --------------------------
src/cadet/meson.build | 13 +
src/cadet/test_cadet.c | 1605 -------------------------------------
src/cadet/test_cadet_drop.conf | 4 -
src/cadet/test_cadet_flow.c | 891 --------------------
6 files changed, 14 insertions(+), 3664 deletions(-)
diff --git a/src/cadet/Makefile.am b/src/cadet/Makefile.am
index 9f59aba3c..3f1c79de0 100644
--- a/src/cadet/Makefile.am
+++ b/src/cadet/Makefile.am
@@ -75,11 +75,6 @@ gnunet_service_cadet_LDFLAGS = -lrt \
endif
-#gnunet_cadet_profiler_SOURCES = \
-# gnunet-cadet-profiler.c
-#gnunet_cadet_profiler_LDADD = $(ld_cadet_test_lib)
-
-
test_cadet_local_mq_SOURCES = \
test_cadet_local_mq.c
test_cadet_local_mq_LDADD = \
@@ -94,5 +89,4 @@ endif
EXTRA_DIST = \
cadet.h cadet_protocol.h \
- test_cadet.conf \
- test_cadet_drop.conf
+ test_cadet.conf
diff --git a/src/cadet/gnunet-cadet-profiler.c
b/src/cadet/gnunet-cadet-profiler.c
deleted file mode 100644
index 22cbe55dc..000000000
--- a/src/cadet/gnunet-cadet-profiler.c
+++ /dev/null
@@ -1,1157 +0,0 @@
-/*
- This file is part of GNUnet.
- Copyright (C) 2011 GNUnet e.V.
-
- GNUnet is free software: you can redistribute it and/or modify it
- under the terms of the GNU Affero General Public License as published
- by the Free Software Foundation, either version 3 of the License,
- or (at your option) any later version.
-
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Affero General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-
- SPDX-License-Identifier: AGPL3.0-or-later
- */
-/**
- * @file cadet/gnunet-cadet-profiler.c
- *
- * @brief Profiler for cadet experiments.
- */
-#include "platform.h"
-#include <stdio.h>
-#include "cadet_test_lib.h"
-#include "gnunet_cadet_service.h"
-#include "gnunet_statistics_service.h"
-
-
-#define PING 1
-#define PONG 2
-
-
-/**
- * Paximum ping period in milliseconds. Real period = rand (0, PING_PERIOD)
- */
-#define PING_PERIOD 500
-
-/**
- * How long until we give up on connecting the peers?
- */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
-
-/**
- * Time to wait for stuff that should be rather fast
- */
-#define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
300)
-
-/**
- * Total number of rounds.
- */
-#define number_rounds sizeof(rounds) / sizeof(rounds[0])
-
-/**
- * Ratio of peers active. First round always is 1.0.
- */
-static float rounds[] = { 0.8, 0.6, 0.8, 0.5, 0.3, 0.8, 0.0 };
-
-/**
- * Message type for pings.
- */
-struct CadetPingMessage
-{
- /**
- * Header. Type PING/PONG.
- */
- struct GNUNET_MessageHeader header;
-
- /**
- * Message number.
- */
- uint32_t counter;
-
- /**
- * Time the message was sent.
- */
- struct GNUNET_TIME_AbsoluteNBO timestamp;
-
- /**
- * Round number.
- */
- uint32_t round_number;
-};
-
-/**
- * Peer description.
- */
-struct CadetPeer
-{
- /**
- * Testbed Operation (to get peer id, etc).
- */
- struct GNUNET_TESTBED_Operation *op;
-
- /**
- * Peer ID.
- */
- struct GNUNET_PeerIdentity id;
-
- /**
- * Cadet handle for the root peer
- */
- struct GNUNET_CADET_Handle *cadet;
-
- /**
- * Channel handle for the root peer
- */
- struct GNUNET_CADET_Channel *ch;
-
- /**
- * Channel handle for the dest peer
- */
- struct GNUNET_CADET_Channel *incoming_ch;
-
- /**
- * Channel handle for a warmup channel.
- */
- struct GNUNET_CADET_Channel *warmup_ch;
-
- /**
- * Number of payload packes sent
- */
- int data_sent;
-
- /**
- * Number of payload packets received
- */
- int data_received;
-
- /**
- * Is peer up?
- */
- int up;
-
- /**
- * Destinaton to ping.
- */
- struct CadetPeer *dest;
-
- /**
- * Incoming channel for pings.
- */
- struct CadetPeer *incoming;
-
- /**
- * Task to do the next ping.
- */
- struct GNUNET_SCHEDULER_Task *ping_task;
-
- /**
- * NTR operation for the next ping.
- */
- struct GNUNET_CADET_TransmitHandle *ping_ntr;
-
- float mean[number_rounds];
- float var[number_rounds];
- unsigned int pongs[number_rounds];
- unsigned int pings[number_rounds];
-};
-
-/**
- * Duration of each round.
- */
-static struct GNUNET_TIME_Relative round_time;
-
-/**
- * GNUNET_PeerIdentity -> CadetPeer
- */
-static struct GNUNET_CONTAINER_MultiPeerMap *ids;
-
-/**
- * Testbed peer handles.
- */
-static struct GNUNET_TESTBED_Peer **testbed_handles;
-
-/**
- * Testbed Operation (to get stats).
- */
-static struct GNUNET_TESTBED_Operation *stats_op;
-
-/**
- * Operation to get peer ids.
- */
-static struct CadetPeer *peers;
-
-/**
- * Peer ids counter.
- */
-static unsigned int p_ids;
-
-/**
- * Total number of peers.
- */
-static unsigned long long peers_total;
-
-/**
- * Number of currently running peers.
- */
-static unsigned long long peers_running;
-
-/**
- * Number of peers doing pings.
- */
-static unsigned long long peers_pinging;
-
-/**
- * Test context (to shut down).
- */
-static struct GNUNET_CADET_TEST_Context *test_ctx;
-
-/**
- * Task called to disconnect peers, before shutdown.
- */
-static struct GNUNET_SCHEDULER_Task *disconnect_task;
-
-/**
- * Task to perform tests
- */
-static struct GNUNET_SCHEDULER_Task *test_task;
-
-/**
- * Round number.
- */
-static unsigned int current_round;
-
-/**
- * Do preconnect? (Each peer creates a tunnel to one other peer).
- */
-static int do_warmup;
-
-/**
- * Warmup progress.
- */
-static unsigned int peers_warmup;
-
-/**
- * Flag to notify callbacks not to generate any new traffic anymore.
- */
-static int test_finished;
-
-/**
- * Task running each round of the benchmark.
- */
-static struct GNUNET_SCHEDULER_Task *round_task;
-
-
-/**
- * START THE TEST ITSELF, AS WE ARE CONNECTED TO THE CADET SERVICES.
- *
- * Testcase continues when the root receives confirmation of connected peers,
- * on callback function ch.
- *
- * @param cls Closure (unused).
- */
-static void
-start_test (void *cls);
-
-
-/**
- * Calculate a random delay.
- *
- * @param max Exclusive maximum, in ms.
- *
- * @return A time between 0 a max-1 ms.
- */
-static struct GNUNET_TIME_Relative
-delay_ms_rnd (unsigned int max)
-{
- unsigned int rnd;
-
- rnd = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, max);
- return GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, rnd);
-}
-
-
-/**
- * Get the index of a peer in the peers array.
- *
- * @param peer Peer whose index to get.
- *
- * @return Index of peer in peers.
- */
-static unsigned int
-get_index (struct CadetPeer *peer)
-{
- return peer - peers;
-}
-
-
-/**
- * Show the results of the test (banwidth achieved) and log them to GAUGER
- */
-static void
-show_end_data (void)
-{
- struct CadetPeer *peer;
- unsigned int i;
- unsigned int j;
-
- for (i = 0; i < number_rounds; i++)
- {
- for (j = 0; j < peers_pinging; j++)
- {
- peer = &peers[j];
- fprintf (stdout,
- "ROUND %3u PEER %3u: %10.2f / %10.2f, PINGS: %3u, PONGS: %3u\n",
- i, j, peer->mean[i], sqrt (peer->var[i] / (peer->pongs[i] - 1)),
- peer->pings[i], peer->pongs[i]);
- }
- }
-}
-
-
-/**
- * Disconnect from cadet services af all peers, call shutdown.
- *
- * @param cls Closure (unused).
- */
-static void
-disconnect_cadet_peers (void *cls)
-{
- long line = (long) cls;
- unsigned int i;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "disconnecting cadet service, called from line %ld\n",
- line);
- disconnect_task = NULL;
- for (i = 0; i < peers_total; i++)
- {
- if (NULL != peers[i].op)
- GNUNET_TESTBED_operation_done (peers[i].op);
-
- if (peers[i].up != GNUNET_YES)
- continue;
-
- if (NULL != peers[i].ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "%u: channel %p\n", i, peers[i].ch);
- GNUNET_CADET_channel_destroy (peers[i].ch);
- }
- if (NULL != peers[i].warmup_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "%u: warmup channel %p\n",
- i, peers[i].warmup_ch);
- GNUNET_CADET_channel_destroy (peers[i].warmup_ch);
- }
- if (NULL != peers[i].incoming_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "%u: incoming channel %p\n",
- i, peers[i].incoming_ch);
- GNUNET_CADET_channel_destroy (peers[i].incoming_ch);
- }
- }
- GNUNET_CADET_TEST_cleanup (test_ctx);
- GNUNET_SCHEDULER_shutdown ();
-}
-
-
-/**
- * Shut down peergroup, clean up.
- *
- * @param cls Closure (unused).
- */
-static void
-shutdown_task (void *cls)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Ending test.\n");
- if (NULL != disconnect_task)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- (void *) __LINE__);
- }
- if (NULL != round_task)
- {
- GNUNET_SCHEDULER_cancel (round_task);
- round_task = NULL;
- }
- if (NULL != test_task)
- {
- GNUNET_SCHEDULER_cancel (test_task);
- test_task = NULL;
- }
-}
-
-
-/**
- * Finish test normally: schedule disconnect and shutdown
- *
- * @param line Line in the code the abort is requested from (__LINE__).
- */
-static void
-abort_test (long line)
-{
- if (disconnect_task != NULL)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- (void *) line);
- }
-}
-
-
-/**
- * Stats callback. Finish the stats testbed operation and when all stats have
- * been iterated, shutdown the test.
- *
- * @param cls closure
- * @param op the operation that has been finished
- * @param emsg error message in case the operation has failed; will be NULL if
- * operation has executed successfully.
- */
-static void
-stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "... collecting statistics done.\n");
- GNUNET_TESTBED_operation_done (stats_op);
-
- if (NULL != disconnect_task)
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- (void *) __LINE__);
-}
-
-
-/**
- * Process statistic values.
- *
- * @param cls closure
- * @param peer the peer the statistic belong to
- * @param subsystem name of subsystem that created the statistic
- * @param name the name of the datum
- * @param value the current value
- * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if
not
- * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
- */
-static int
-stats_iterator (void *cls,
- const struct GNUNET_TESTBED_Peer *peer,
- const char *subsystem,
- const char *name,
- uint64_t value,
- int is_persistent)
-{
- uint32_t i;
-
- i = GNUNET_TESTBED_get_index (peer);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- " STATS %u - %s [%s]: %llu\n",
- i, subsystem, name,
- (unsigned long long) value);
-
- return GNUNET_OK;
-}
-
-
-/**
- * Task check that keepalives were sent and received.
- *
- * @param cls Closure (NULL).
- */
-static void
-collect_stats (void *cls)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Start collecting statistics...\n");
- stats_op = GNUNET_TESTBED_get_statistics (peers_total,
- testbed_handles,
- NULL, NULL,
- &stats_iterator,
- &stats_cont, NULL);
-}
-
-
-/**
- * @brief Finish profiler normally. Signal finish and start collecting stats.
- *
- * @param cls Closure (unused).
- */
-static void
-finish_profiler (void *cls)
-{
- test_finished = GNUNET_YES;
- show_end_data ();
- GNUNET_SCHEDULER_add_now (&collect_stats, NULL);
-}
-
-
-/**
- * Set the total number of running peers.
- *
- * @param target Desired number of running peers.
- */
-static void
-adjust_running_peers (unsigned int target)
-{
- struct GNUNET_TESTBED_Operation *op;
- unsigned int delta;
- unsigned int run;
- unsigned int i;
- unsigned int r;
-
- GNUNET_assert (target <= peers_total);
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "adjust peers to %u\n", target);
- if (target > peers_running)
- {
- delta = target - peers_running;
- run = GNUNET_YES;
- }
- else
- {
- delta = peers_running - target;
- run = GNUNET_NO;
- }
-
- for (i = 0; i < delta; i++)
- {
- do
- {
- r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
- peers_total - peers_pinging);
- r += peers_pinging;
- }
- while (peers[r].up == run || NULL != peers[r].incoming);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "St%s peer %u: %s\n",
- run ? "arting" : "opping", r, GNUNET_i2s (&peers[r].id));
-
- if (NULL != peers[r].ping_task)
- {
- GNUNET_SCHEDULER_cancel (peers[r].ping_task);
- peers[r].ping_task = NULL;
- }
- if (NULL != peers[r].ping_ntr)
- {
- GNUNET_CADET_notify_transmit_ready_cancel (peers[r].ping_ntr);
- peers[r].ping_ntr = NULL;
- }
- peers[r].up = run;
-
- if (NULL != peers[r].ch)
- GNUNET_CADET_channel_destroy (peers[r].ch);
- peers[r].ch = NULL;
- if (NULL != peers[r].dest)
- {
- if (NULL != peers[r].dest->incoming_ch)
- GNUNET_CADET_channel_destroy (peers[r].dest->incoming_ch);
- peers[r].dest->incoming_ch = NULL;
- }
-
- op = GNUNET_TESTBED_peer_manage_service (&peers[r], testbed_handles[r],
- "cadet", NULL, NULL, run);
- GNUNET_break (NULL != op);
- peers_running += run ? 1 : -1;
- GNUNET_assert (peers_running > 0);
- }
-}
-
-
-/**
- * @brief Move to next round.
- *
- * @param cls Closure (round #).
- */
-static void
-next_rnd (void *cls)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "ROUND %u\n",
- current_round);
- if (0.0 == rounds[current_round])
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Finishing\n");
- GNUNET_SCHEDULER_add_now (&finish_profiler, NULL);
- return;
- }
- adjust_running_peers (rounds[current_round] * peers_total);
- current_round++;
-
- round_task = GNUNET_SCHEDULER_add_delayed (round_time,
- &next_rnd,
- NULL);
-}
-
-
-/**
- * Transmit ping callback.
- *
- * @param cls Closure (peer for PING, NULL for PONG).
- * @param size Size of the transmit buffer.
- * @param buf Pointer to the beginning of the buffer.
- *
- * @return Number of bytes written to buf.
- */
-static size_t
-tmt_rdy_ping (void *cls, size_t size, void *buf);
-
-
-/**
- * Transmit pong callback.
- *
- * @param cls Closure (copy of PING message, to be freed).
- * @param size Size of the buffer we have.
- * @param buf Buffer to copy data to.
- */
-static size_t
-tmt_rdy_pong (void *cls, size_t size, void *buf)
-{
- struct CadetPingMessage *ping = cls;
- struct CadetPingMessage *pong;
-
- if ((0 == size) || (NULL == buf))
- {
- GNUNET_free (ping);
- return 0;
- }
- pong = (struct CadetPingMessage *) buf;
- GNUNET_memcpy (pong, ping, sizeof(*ping));
- pong->header.type = htons (PONG);
-
- GNUNET_free (ping);
- return sizeof(*ping);
-}
-
-
-/**
- * @brief Send a ping to destination
- *
- * @param cls Closure (peer).
- */
-static void
-ping (void *cls)
-{
- struct CadetPeer *peer = cls;
-
- peer->ping_task = NULL;
- if (GNUNET_YES == test_finished)
- return;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "%u -> %u (%u)\n",
- get_index (peer),
- get_index (peer->dest),
- peer->data_sent);
- peer->ping_ntr = GNUNET_CADET_notify_transmit_ready (peer->ch, GNUNET_NO,
-
GNUNET_TIME_UNIT_FOREVER_REL,
- sizeof(struct
-
CadetPingMessage),
- &tmt_rdy_ping, peer);
-}
-
-
-/**
- * @brief Reply with a pong to origin.
- *
- */
-static void
-pong (struct GNUNET_CADET_Channel *channel,
- const struct CadetPingMessage *ping)
-{
- struct CadetPingMessage *copy;
-
- copy = GNUNET_new (struct CadetPingMessage);
- *copy = *ping;
- GNUNET_CADET_notify_transmit_ready (channel, GNUNET_NO,
- GNUNET_TIME_UNIT_FOREVER_REL,
- sizeof(struct CadetPingMessage),
- &tmt_rdy_pong, copy);
-}
-
-
-/**
- * Transmit ping callback
- *
- * @param cls Closure (peer).
- * @param size Size of the buffer we have.
- * @param buf Buffer to copy data to.
- */
-static size_t
-tmt_rdy_ping (void *cls, size_t size, void *buf)
-{
- struct CadetPeer *peer = cls;
- struct CadetPingMessage *msg = buf;
-
- peer->ping_ntr = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "tmt_rdy called, filling buffer\n");
- if ((size < sizeof(struct CadetPingMessage)) || (NULL == buf))
- {
- GNUNET_break (GNUNET_YES == test_finished);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "size %u, buf %p, data_sent %u, data_received %u\n",
- (unsigned int) size,
- buf,
- peer->data_sent,
- peer->data_received);
-
- return 0;
- }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending: msg %d\n",
- peer->data_sent);
- msg->header.size = htons (size);
- msg->header.type = htons (PING);
- msg->counter = htonl (peer->data_sent++);
- msg->round_number = htonl (current_round);
- msg->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
- peer->pings[current_round]++;
- peer->ping_task = GNUNET_SCHEDULER_add_delayed (delay_ms_rnd (PING_PERIOD),
- &ping, peer);
-
- return sizeof(struct CadetPingMessage);
-}
-
-
-/**
- * Function is called whenever a PING message is received.
- *
- * @param cls closure (peer #, set from GNUNET_CADET_connect)
- * @param channel connection to the other end
- * @param channel_ctx place to store local state associated with the channel
- * @param message the actual message
- * @return GNUNET_OK to keep the connection open,
- * GNUNET_SYSERR to close it (signal serious error)
- */
-int
-ping_handler (void *cls, struct GNUNET_CADET_Channel *channel,
- void **channel_ctx,
- const struct GNUNET_MessageHeader *message)
-{
- long n = (long) cls;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "%u got PING\n",
- (unsigned int) n);
- GNUNET_CADET_receive_done (channel);
- if (GNUNET_NO == test_finished)
- pong (channel, (struct CadetPingMessage *) message);
-
- return GNUNET_OK;
-}
-
-
-/**
- * Function is called whenever a PONG message is received.
- *
- * @param cls closure (peer #, set from GNUNET_CADET_connect)
- * @param channel connection to the other end
- * @param channel_ctx place to store local state associated with the channel
- * @param message the actual message
- * @return GNUNET_OK to keep the connection open,
- * GNUNET_SYSERR to close it (signal serious error)
- */
-int
-pong_handler (void *cls, struct GNUNET_CADET_Channel *channel,
- void **channel_ctx,
- const struct GNUNET_MessageHeader *message)
-{
- long n = (long) cls;
- struct CadetPeer *peer;
- struct CadetPingMessage *msg;
- struct GNUNET_TIME_Absolute send_time;
- struct GNUNET_TIME_Relative latency;
- unsigned int r /* Ping round */;
- float delta;
-
- GNUNET_CADET_receive_done (channel);
- peer = &peers[n];
-
- msg = (struct CadetPingMessage *) message;
-
- send_time = GNUNET_TIME_absolute_ntoh (msg->timestamp);
- latency = GNUNET_TIME_absolute_get_duration (send_time);
- r = ntohl (msg->round_number);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%u <- %u (%u) latency: %s\n",
- get_index (peer),
- get_index (peer->dest),
- (uint32_t) ntohl (msg->counter),
- GNUNET_STRINGS_relative_time_to_string (latency, GNUNET_NO));
-
- /* Online variance calculation */
- peer->pongs[r]++;
- delta = latency.rel_value_us - peer->mean[r];
- peer->mean[r] = peer->mean[r] + delta / peer->pongs[r];
- peer->var[r] += delta * (latency.rel_value_us - peer->mean[r]);
-
- return GNUNET_OK;
-}
-
-
-/**
- * Handlers, for diverse services
- */
-static struct GNUNET_CADET_MessageHandler handlers[] = {
- { &ping_handler, PING, sizeof(struct CadetPingMessage) },
- { &pong_handler, PONG, sizeof(struct CadetPingMessage) },
- { NULL, 0, 0 }
-};
-
-
-/**
- * Method called whenever another peer has added us to a channel
- * the other peer initiated.
- *
- * @param cls Closure.
- * @param channel New handle to the channel.
- * @param initiator Peer that started the channel.
- * @param port Port this channel is connected to.
- * @param options channel option flags
- * @return Initial channel context for the channel
- * (can be NULL -- that's not an error).
- */
-static void *
-incoming_channel (void *cls, struct GNUNET_CADET_Channel *channel,
- const struct GNUNET_PeerIdentity *initiator,
- const struct GNUNET_HashCode *port,
- enum GNUNET_CADET_ChannelOption options)
-{
- long n = (long) cls;
- struct CadetPeer *peer;
-
- peer = GNUNET_CONTAINER_multipeermap_get (ids, initiator);
- GNUNET_assert (NULL != peer);
- if (NULL == peers[n].incoming)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "WARMUP %3u: %u <= %u\n",
- peers_warmup,
- (unsigned int) n,
- get_index (peer));
- peers_warmup++;
- if (peers_warmup < peers_total)
- return NULL;
- if (NULL != test_task)
- {
- GNUNET_SCHEDULER_cancel (test_task);
- test_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
- &start_test, NULL);
- }
- return NULL;
- }
- GNUNET_assert (peer == peers[n].incoming);
- GNUNET_assert (peer->dest == &peers[n]);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "%u <= %u %p\n",
- (unsigned int) n,
- get_index (peer),
- channel);
- peers[n].incoming_ch = channel;
-
- return NULL;
-}
-
-
-/**
- * Function called whenever an inbound channel is destroyed. Should clean up
- * any associated state.
- *
- * @param cls closure (set from GNUNET_CADET_connect)
- * @param channel connection to the other end (henceforth invalid)
- * @param channel_ctx place where local state associated
- * with the channel is stored
- */
-static void
-channel_cleaner (void *cls,
- const struct GNUNET_CADET_Channel *channel,
- void *channel_ctx)
-{
- long n = (long) cls;
- struct CadetPeer *peer = &peers[n];
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Channel %p disconnected at peer %ld\n", channel, n);
- if (peer->ch == channel)
- peer->ch = NULL;
-}
-
-
-/**
- * Select a random peer that has no incoming channel
- *
- * @param peer ID of the peer connecting. NULL if irrelevant (warmup).
- *
- * @return Random peer not yet connected to.
- */
-static struct CadetPeer *
-select_random_peer (struct CadetPeer *peer)
-{
- unsigned int r;
-
- do
- {
- r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, peers_total);
- }
- while (NULL != peers[r].incoming);
- peers[r].incoming = peer;
-
- return &peers[r];
-}
-
-
-/**
- * START THE TEST ITSELF, AS WE ARE CONNECTED TO THE CADET SERVICES.
- *
- * Testcase continues when the root receives confirmation of connected peers,
- * on callback function ch.
- *
- * @param cls Closure (unused).
- */
-static void
-start_test (void *cls)
-{
- unsigned long i;
-
- test_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Start profiler\n");
-
-
- for (i = 0; i < peers_pinging; i++)
- {
- peers[i].dest = select_random_peer (&peers[i]);
- peers[i].ch = GNUNET_CADET_channel_create (peers[i].cadet, NULL,
- &peers[i].dest->id,
- GC_u2h (1));
- if (NULL == peers[i].ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Channel %lu failed\n", i);
- GNUNET_CADET_TEST_cleanup (test_ctx);
- return;
- }
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "%lu => %u %p\n",
- i,
- get_index (peers[i].dest),
- peers[i].ch);
- peers[i].ping_task = GNUNET_SCHEDULER_add_delayed (delay_ms_rnd (2000),
- &ping, &peers[i]);
- }
- peers_running = peers_total;
- if (NULL != disconnect_task)
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (round_time,
- number_rounds
- + 1),
- &disconnect_cadet_peers,
- (void *) __LINE__);
- round_task = GNUNET_SCHEDULER_add_delayed (round_time,
- &next_rnd,
- NULL);
-}
-
-
-/**
- * Do warmup: create some channels to spread information about the topology.
- */
-static void
-warmup (void)
-{
- struct CadetPeer *peer;
- unsigned int i;
-
- for (i = 0; i < peers_total; i++)
- {
- peer = select_random_peer (NULL);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "WARMUP %u => %u\n",
- i, get_index (peer));
- peers[i].warmup_ch =
- GNUNET_CADET_channel_create (peers[i].cadet, NULL, &peer->id,
- GC_u2h (1));
- if (NULL == peers[i].warmup_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Warmup %u failed\n", i);
- GNUNET_CADET_TEST_cleanup (test_ctx);
- return;
- }
- }
-}
-
-
-/**
- * Callback to be called when the requested peer information is available
- *
- * @param cls the closure from GNUNET_TESTBED_peer_get_information()
- * @param op the operation this callback corresponds to
- * @param pinfo the result; will be NULL if the operation has failed
- * @param emsg error message if the operation has failed;
- * NULL if the operation is successful
- */
-static void
-peer_id_cb (void *cls,
- struct GNUNET_TESTBED_Operation *op,
- const struct GNUNET_TESTBED_PeerInformation *pinfo,
- const char *emsg)
-{
- long n = (long) cls;
-
- if ((NULL == pinfo) || (NULL != emsg))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "pi_cb: %s\n", emsg);
- abort_test (__LINE__);
- return;
- }
- peers[n].id = *(pinfo->result.id);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "%ld id: %s\n",
- n,
- GNUNET_i2s (&peers[n].id));
- GNUNET_break (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (ids, &peers[n].id,
&peers[n],
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
-
- GNUNET_TESTBED_operation_done (peers[n].op);
- peers[n].op = NULL;
-
- p_ids++;
- if (p_ids < peers_total)
- return;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Got all IDs, starting profiler\n");
- if (do_warmup)
- {
- struct GNUNET_TIME_Relative delay;
-
- warmup ();
- delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
- 100 * peers_total);
- test_task = GNUNET_SCHEDULER_add_delayed (delay, &start_test, NULL);
- return; /* start_test from incoming_channel */
- }
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Starting in a second...\n");
- test_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
- &start_test, NULL);
-}
-
-
-/**
- * test main: start test when all peers are connected
- *
- * @param cls Closure.
- * @param ctx Argument to give to GNUNET_CADET_TEST_cleanup on test end.
- * @param num_peers Number of peers that are running.
- * @param testbed_peers Array of peers.
- * @param cadetes Handle to each of the CADETs of the peers.
- */
-static void
-tmain (void *cls,
- struct GNUNET_CADET_TEST_Context *ctx,
- unsigned int num_peers,
- struct GNUNET_TESTBED_Peer **testbed_peers,
- struct GNUNET_CADET_Handle **cadetes)
-{
- unsigned long i;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "test main\n");
- test_ctx = ctx;
- GNUNET_assert (peers_total == num_peers);
- peers_running = num_peers;
- testbed_handles = testbed_peers;
- disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
- &disconnect_cadet_peers,
- (void *) __LINE__);
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
- for (i = 0; i < peers_total; i++)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "requesting id %ld\n",
- i);
- peers[i].up = GNUNET_YES;
- peers[i].cadet = cadetes[i];
- peers[i].op =
- GNUNET_TESTBED_peer_get_information (testbed_handles[i],
- GNUNET_TESTBED_PIT_IDENTITY,
- &peer_id_cb, (void *) i);
- }
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "requested peer ids\n");
- /* Continues from pi_cb -> do_test */
-}
-
-
-/**
- * Main: start profiler.
- */
-int
-main (int argc, char *argv[])
-{
- static const struct GNUNET_HashCode *ports[2];
- const char *config_file;
-
- config_file = ".profiler.conf";
-
- if (4 > argc)
- {
- fprintf (stderr,
- "usage: %s ROUND_TIME PEERS PINGS [DO_WARMUP]\n",
- argv[0]);
- fprintf (stderr,
- "example: %s 30s 16 1 Y\n",
- argv[0]);
- return 1;
- }
-
- if (GNUNET_OK !=
- GNUNET_STRINGS_fancy_time_to_relative (argv[1],
- &round_time))
- {
- fprintf (stderr,
- "%s is not a valid time\n",
- argv[1]);
- return 1;
- }
-
- peers_total = atoll (argv[2]);
- if (2 > peers_total)
- {
- fprintf (stderr,
- "%s peers is not valid (> 2)\n",
- argv[1]);
- return 1;
- }
- peers = GNUNET_new_array (peers_total,
- struct CadetPeer);
- peers_pinging = atoll (argv[3]);
-
- if (peers_total < 2 * peers_pinging)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "not enough peers, total should be > 2 * peers_pinging\n");
- return 1;
- }
-
- do_warmup = (5 > argc || argv[4][0] != 'N');
-
- ids = GNUNET_CONTAINER_multipeermap_create (2 * peers_total,
- GNUNET_YES);
- GNUNET_assert (NULL != ids);
- p_ids = 0;
- test_finished = GNUNET_NO;
- ports[0] = GC_u2h (1);
- ports[1] = 0;
- GNUNET_CADET_TEST_run ("cadet-profiler", config_file, peers_total,
- &tmain, NULL, /* tmain cls */
- &incoming_channel, &channel_cleaner,
- handlers, ports);
- GNUNET_free (peers);
-
- return 0;
-}
-
-
-/* end of gnunet-cadet-profiler.c */
diff --git a/src/cadet/meson.build b/src/cadet/meson.build
index 5684d06ea..a961c8e76 100644
--- a/src/cadet/meson.build
+++ b/src/cadet/meson.build
@@ -72,3 +72,16 @@ executable ('gnunet-service-cadet',
install: true,
install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+testcadetlocalmq = executable ('test_cadet_local_mq',
+ ['test_cadet_local_mq.c'],
+ dependencies: [libgnunetcadet_dep,
+ libgnunettesting_dep,
+ libgnunetutil_dep],
+ include_directories: [incdir, configuration_inc],
+ install: false)
+configure_file(input : 'test_cadet.conf',
+ output : 'test_cadet.conf',
+ configuration : cdata,
+ install: false)
+test('test_cadet_local_mq', testcadetlocalmq, workdir:
meson.current_build_dir(), suite: 'cadet')
+
diff --git a/src/cadet/test_cadet.c b/src/cadet/test_cadet.c
deleted file mode 100644
index 61c09f389..000000000
--- a/src/cadet/test_cadet.c
+++ /dev/null
@@ -1,1605 +0,0 @@
-/*
- This file is part of GNUnet.
- Copyright (C) 2011, 2017 GNUnet e.V.
-
- GNUnet is free software: you can redistribute it and/or modify it
- under the terms of the GNU Affero General Public License as published
- by the Free Software Foundation, either version 3 of the License,
- or (at your option) any later version.
-
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Affero General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-
- SPDX-License-Identifier: AGPL3.0-or-later
- */
-/**
- * @file cadet/test_cadet.c
- * @author Bart Polot
- * @author Christian Grothoff
- * @brief Test for the cadet service using mq API.
- */
-#include "platform.h"
-#include <stdio.h>
-#include "cadet.h"
-#include "cadet_test_lib.h"
-#include "gnunet_cadet_service.h"
-#include "gnunet_statistics_service.h"
-#include <gauger.h>
-
-
-/**
- * Ugly workaround to unify data handlers on incoming and outgoing channels.
- */
-struct CadetTestChannelWrapper
-{
- /**
- * Channel pointer.
- */
- struct GNUNET_CADET_Channel *ch;
-};
-
-/**
- * How many messages to send by default.
- */
-#define TOTAL_PACKETS 500 /* Cannot exceed 64k! */
-
-/**
- * How long until we give up on connecting the peers?
- */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
-
-/**
- * Time to wait by default for stuff that should be rather fast.
- */
-#define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20)
-
-/**
- * How fast do we send messages?
- */
-#define SEND_INTERVAL GNUNET_TIME_relative_multiply ( \
- GNUNET_TIME_UNIT_MILLISECONDS, 10)
-
-/**
- * DIFFERENT TESTS TO RUN
- */
-#define SETUP 0
-#define FORWARD 1
-#define KEEPALIVE 2
-#define SPEED 3
-#define SPEED_ACK 4
-#define SPEED_REL 8
-#define P2P_SIGNAL 10
-#define REOPEN 11
-#define DESTROY 12
-
-/**
- * Active peer listing operation.
- */
-static struct GNUNET_CADET_PeersLister *plo;
-
-/*
- * Task called to check for existing tunnel and depending on that reopen
channel
- */
-static struct GNUNET_SCHEDULER_Task *get_peers_task;
-
-/**
- * Which test are we running?
- */
-static int test;
-
-/**
- * String with test name
- */
-static char *test_name;
-
-/**
- * Flag to send traffic leaf->root in speed tests to test BCK_ACK logic.
- */
-static int test_backwards = GNUNET_NO;
-
-/**
- * How many packets to send.
- */
-static unsigned int total_packets;
-
-/**
- * Time to wait for fast operations.
- */
-static struct GNUNET_TIME_Relative short_time;
-
-/**
- * How many events have happened
- */
-static int ok;
-
-/**
- * Number of events expected to conclude the test successfully.
- */
-static int ok_goal;
-
-/**
- * Size of each test packet's payload
- */
-static size_t size_payload = sizeof(uint32_t);
-
-/**
- * Operation to get peer ids.
- */
-static struct GNUNET_TESTBED_Operation *t_op[2];
-
-/**
- * Peer ids.
- */
-static struct GNUNET_PeerIdentity *testpeer_id[2];
-
-/**
- * Peer ids.
- */
-static struct GNUNET_CONFIGURATION_Handle *p_cfg[2];
-
-/**
- * Port ID
- */
-static struct GNUNET_HashCode port;
-
-/**
- * Peer ids counter.
- */
-static unsigned int peerinfo_task_cnt;
-
-/**
- * Is the setup initialized?
- */
-static int initialized;
-
-/**
- * Number of payload packes sent.
- */
-static int data_sent;
-
-/**
- * Number of payload packets received.
- */
-static int data_received;
-
-/**
- * Number of payload packed acknowledgements sent.
- */
-static int ack_sent;
-
-/**
- * Number of payload packed explicitly (app level) acknowledged.
- */
-static int ack_received;
-
-/**
- * Total number of peers asked to run.
- */
-static unsigned long long peers_requested;
-
-/**
- * Number of currently running peers (should be same as @c peers_requested).
- */
-static unsigned long long peers_running;
-
-/**
- * Test context (to shut down).
- */
-struct GNUNET_CADET_TEST_Context *test_ctx;
-
-/**
- * Task called to disconnect peers.
- */
-static struct GNUNET_SCHEDULER_Task *disconnect_task;
-
-/**
- * Task called to reconnect peers.
- */
-static struct GNUNET_SCHEDULER_Task *reconnect_task;
-
-/**
- * Task To perform tests
- */
-static struct GNUNET_SCHEDULER_Task *test_task;
-
-/**
- * Task runnining #send_next_msg().
- */
-static struct GNUNET_SCHEDULER_Task *send_next_msg_task;
-
-/**
- * Channel handle for the root peer
- */
-static struct GNUNET_CADET_Channel *outgoing_ch;
-
-/**
- * Channel handle for the dest peer
- */
-static struct GNUNET_CADET_Channel *incoming_ch;
-
-/**
- * Time we started the data transmission (after channel has been established
- * and initialized).
- */
-static struct GNUNET_TIME_Absolute start_time;
-
-/**
- * Peers handle.
- */
-static struct GNUNET_TESTBED_Peer **testbed_peers;
-
-
-struct GNUNET_CADET_Handle **cadets_running;
-
-/**
- * Statistics operation handle.
- */
-static struct GNUNET_TESTBED_Operation *stats_op;
-
-/**
- * Keepalives sent.
- */
-static unsigned int ka_sent;
-
-/**
- * Keepalives received.
- */
-static unsigned int ka_received;
-
-/**
- * How many messages were dropped by CADET because of full buffers?
- */
-static unsigned int msg_dropped;
-
-/**
- * Drop the next cadet message of a given type..
- *
- * @param mq message queue
- * @param ccn client channel number.
- * @param type of cadet message to be dropped.
- */
-void
-GNUNET_CADET_drop_message (struct GNUNET_MQ_Handle *mq,
- struct GNUNET_CADET_ClientChannelNumber ccn,
- uint16_t type);
-
-/******************************************************************************/
-
-
-/******************************************************************************/
-
-
-/**
- * Get the channel considered as the "target" or "receiver", depending on
- * the test type and size.
- *
- * @return Channel handle of the target client, either 0 (for backward tests)
- * or the last peer in the line (for other tests).
- */
-static struct GNUNET_CADET_Channel *
-get_target_channel ()
-{
- if ((SPEED == test) && (GNUNET_YES == test_backwards))
- return outgoing_ch;
- else
- return incoming_ch;
-}
-
-
-/**
- * Show the results of the test (banwidth achieved) and log them to GAUGER
- */
-static void
-show_end_data (void)
-{
- static struct GNUNET_TIME_Absolute end_time;
- static struct GNUNET_TIME_Relative total_time;
-
- end_time = GNUNET_TIME_absolute_get ();
- total_time = GNUNET_TIME_absolute_get_difference (start_time, end_time);
- fprintf (stderr,
- "\nResults of test \"%s\"\n",
- test_name);
- fprintf (stderr,
- "Test time %s\n",
- GNUNET_STRINGS_relative_time_to_string (total_time, GNUNET_YES));
- fprintf (stderr,
- "Test bandwidth: %f kb/s\n",
- 4 * total_packets * 1.0 / (total_time.rel_value_us / 1000)); //
4bytes * ms
- fprintf (stderr,
- "Test throughput: %f packets/s\n\n",
- total_packets * 1000.0 / (total_time.rel_value_us / 1000)); //
packets * ms
- GAUGER ("CADET",
- test_name,
- total_packets * 1000.0 / (total_time.rel_value_us / 1000),
- "packets/s");
-}
-
-
-/**
- * Disconnect from cadet services af all peers, call shutdown.
- *
- * @param cls Closure (line number from which termination was requested).
- * @param tc Task Context.
- */
-static void
-disconnect_cadet_peers (void *cls)
-{
- long line = (long) cls;
-
- disconnect_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "disconnecting cadet service of peers, called from line %ld\n",
- line);
- for (unsigned int i = 0; i < 2; i++)
- {
- GNUNET_TESTBED_operation_done (t_op[i]);
- }
- if (NULL != outgoing_ch)
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- if (NULL != incoming_ch)
- {
- GNUNET_CADET_channel_destroy (incoming_ch);
- incoming_ch = NULL;
- }
- GNUNET_CADET_TEST_cleanup (test_ctx);
- GNUNET_SCHEDULER_shutdown ();
-}
-
-
-/**
- * Shut down peergroup, clean up.
- *
- * @param cls Closure (unused).
- * @param tc Task Context.
- */
-static void
-shutdown_task (void *cls)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Ending test.\n");
- if (NULL != send_next_msg_task)
- {
- GNUNET_SCHEDULER_cancel (send_next_msg_task);
- send_next_msg_task = NULL;
- }
- if (NULL != test_task)
- {
- GNUNET_SCHEDULER_cancel (test_task);
- test_task = NULL;
- }
- if (NULL != disconnect_task)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task =
- GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- (void *) __LINE__);
- }
-}
-
-
-/**
- * Stats callback. Finish the stats testbed operation and when all stats have
- * been iterated, shutdown the test.
- *
- * @param cls Closure (line number from which termination was requested).
- * @param op the operation that has been finished
- * @param emsg error message in case the operation has failed; will be NULL if
- * operation has executed successfully.
- */
-static void
-stats_cont (void *cls,
- struct GNUNET_TESTBED_Operation *op,
- const char *emsg)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "KA sent: %u, KA received: %u\n",
- ka_sent,
- ka_received);
- if (((KEEPALIVE == test) || (REOPEN == test)) &&
- ((ka_sent < 2) || (ka_sent > ka_received + 1)))
- {
- GNUNET_break (0);
- ok--;
- }
- GNUNET_TESTBED_operation_done (stats_op);
-
- if (NULL != disconnect_task)
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- cls);
-}
-
-
-/**
- * Process statistic values.
- *
- * @param cls closure (line number, unused)
- * @param peer the peer the statistic belong to
- * @param subsystem name of subsystem that created the statistic
- * @param name the name of the datum
- * @param value the current value
- * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if
not
- * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
- */
-static int
-stats_iterator (void *cls,
- const struct GNUNET_TESTBED_Peer *peer,
- const char *subsystem,
- const char *name,
- uint64_t value,
- int is_persistent)
-{
- static const char *s_sent = "# keepalives sent";
- static const char *s_recv = "# keepalives received";
- static const char *rdrops = "# messages dropped due to full buffer";
- static const char *cdrops = "# messages dropped due to slow client";
- uint32_t i;
-
- i = GNUNET_TESTBED_get_index (peer);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i,
- subsystem, name, (unsigned long long) value);
- if ((0 == strncmp (s_sent, name, strlen (s_sent))) && (0 == i))
- ka_sent = value;
- if ((0 == strncmp (s_recv, name, strlen (s_recv))) && (peers_requested - 1 ==
- i) )
- ka_received = value;
- if (0 == strncmp (rdrops, name, strlen (rdrops)))
- msg_dropped += value;
- if (0 == strncmp (cdrops, name, strlen (cdrops)))
- msg_dropped += value;
-
- return GNUNET_OK;
-}
-
-
-/**
- * Task to gather all statistics.
- *
- * @param cls Closure (line from which the task was scheduled).
- */
-static void
-gather_stats_and_exit (void *cls)
-{
- long l = (long) cls;
-
- disconnect_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "gathering statistics from line %ld\n",
- l);
- if (NULL != outgoing_ch)
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- stats_op = GNUNET_TESTBED_get_statistics (peers_running,
- testbed_peers,
- "cadet",
- NULL,
- &stats_iterator,
- stats_cont,
- cls);
-}
-
-
-/**
- * Send a message on the channel with the appropriate size and payload.
- *
- * Update the appropriate *_sent counter.
- *
- * @param channel Channel to send the message on.
- */
-static void
-send_test_message (struct GNUNET_CADET_Channel *channel);
-
-/**
- * Check if payload is sane (size contains payload).
- *
- * @param cls should match #ch
- * @param message The actual message.
- * @return #GNUNET_OK to keep the channel open,
- * #GNUNET_SYSERR to close it (signal serious error).
- */
-static int
-check_data (void *cls,
- const struct GNUNET_MessageHeader *message);
-
-/**
- * Function is called whenever a message is received.
- *
- * @param cls closure (set from GNUNET_CADET_connect(), peer number)
- * @param message the actual message
- */
-static void
-handle_data (void *cls,
- const struct GNUNET_MessageHeader *message);
-
-/**
- * Function called whenever an MQ-channel is destroyed, unless the destruction
- * was requested by #GNUNET_CADET_channel_destroy.
- * It must NOT call #GNUNET_CADET_channel_destroy on the channel.
- *
- * It should clean up any associated state, including cancelling any pending
- * transmission on this channel.
- *
- * @param cls Channel closure (channel wrapper).
- * @param channel Connection to the other end (henceforth invalid).
- */
-static void
-disconnect_handler (void *cls,
- const struct GNUNET_CADET_Channel *channel);
-
-static struct GNUNET_PeerIdentity *
-get_from_p_ids ()
-{
- if (0 < GNUNET_memcmp (testpeer_id[0], testpeer_id[1]))
- {
- return testpeer_id[1];
- }
- else
- {
- return testpeer_id[0];
- }
-}
-
-
-static struct GNUNET_CADET_Handle *
-get_from_cadets ()
-{
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "1\n");
- if (0 < GNUNET_memcmp (testpeer_id[0], testpeer_id[1]))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "standard peer\n");
- return cadets_running[0];
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "the other peer\n");
- return cadets_running[peers_running - 1];
- }
-
-}
-
-
-static unsigned int
-get_peer_nr (int outgoing)
-{
- if (0 < GNUNET_memcmp (testpeer_id[0], testpeer_id[1]))
- {
- return GNUNET_YES == outgoing ? 0 : peers_running - 1;
- }
- else
- {
- return GNUNET_YES == outgoing ? peers_running - 1 : 0;
- }
-}
-
-
-/**
- * Task to reconnect to other peer.
- *
- * @param cls Closure (line from which the task was scheduled).
- */
-static void
-reconnect_op (void *cls)
-{
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (data,
- GNUNET_MESSAGE_TYPE_DUMMY,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
- };
- long l = (long) cls;
- struct CadetTestChannelWrapper *ch;
- static struct GNUNET_PeerIdentity *p_id;
- static struct GNUNET_CADET_Handle *h1;
-
- reconnect_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "reconnecting from line %ld\n",
- l);
- if (NULL != outgoing_ch)
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- ch = GNUNET_new (struct CadetTestChannelWrapper);
-
- p_id = get_from_p_ids ();
- h1 = get_from_cadets ();
-
- outgoing_ch = GNUNET_CADET_channel_create (h1,
- ch,
- p_id,
- &port,
- NULL,
- &disconnect_handler,
- handlers);
- ch->ch = outgoing_ch;
- send_test_message (outgoing_ch);
-}
-
-
-void
-reopen_channel ()
-{
- struct CadetTestChannelWrapper *ch;
- static struct GNUNET_CADET_Handle *h1;
- static struct GNUNET_PeerIdentity *p_id;
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (data,
- GNUNET_MESSAGE_TYPE_DUMMY,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
- };
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "creating channel again\n");
- p_id = get_from_p_ids ();
- h1 = get_from_cadets ();
-
- ch = GNUNET_new (struct CadetTestChannelWrapper);
- outgoing_ch = GNUNET_CADET_channel_create (h1,
- ch,
- p_id,
- &port,
- NULL,
- &disconnect_handler,
- handlers);
- ch->ch = outgoing_ch;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Sending second test data (after destroying the channel) on
channel %p...\n",
- outgoing_ch);
- send_test_message (outgoing_ch);
-}
-
-
-static void
-peers_callback (void *cls, const struct GNUNET_CADET_PeerListEntry *ple);
-
-/**
- * We ask the monitoring api for all the peers.
- */
-static void
-get_peers (void *cls)
-{
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "requesting peers info!\n");
- plo = GNUNET_CADET_list_peers (p_cfg[get_peer_nr (GNUNET_YES)],
- &peers_callback, NULL);
-
-}
-
-
-/**
- * Method called to retrieve information about all peers in CADET, called
- * once per peer.
- *
- * After last peer has been reported, an additional call with NULL is done.
- *
- * We check the peer we are interested in, if we have a tunnel. If not, we
- * reopen the channel
- *
- * @param cls Closure.
- * @param ple information about peer, or NULL on "EOF".
- */
-static void
-peers_callback (void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
-{
-
- const struct GNUNET_PeerIdentity *p_id;
- const struct GNUNET_PeerIdentity *peer;
-
-
- peer = &ple->peer;
-
- if (NULL == ple)
- {
- plo = NULL;
- return;
- }
- p_id = get_from_p_ids ();
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "ple->peer %s\n",
- GNUNET_i2s_full (&ple->peer));
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "p_id %s\n",
- GNUNET_i2s_full (p_id));
-
- if ((0 == GNUNET_memcmp (&ple->peer, p_id)) && ple->have_tunnel)
- {
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "schedule get_peers again?\n");
- get_peers_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
- &get_peers,
- NULL);
-
- }
- else if (0 == GNUNET_memcmp (&ple->peer, p_id) )
- {
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "reopen channel\n");
-
- reopen_channel ();
-
- }
-}
-
-
-/**
- * Function called whenever an MQ-channel is destroyed, unless the destruction
- * was requested by #GNUNET_CADET_channel_destroy.
- * It must NOT call #GNUNET_CADET_channel_destroy on the channel.
- *
- * It should clean up any associated state, including cancelling any pending
- * transmission on this channel.
- *
- * @param cls Channel closure (channel wrapper).
- * @param channel Connection to the other end (henceforth invalid).
- */
-static void
-disconnect_handler (void *cls,
- const struct GNUNET_CADET_Channel *channel)
-{
- struct CadetTestChannelWrapper *ch_w = cls;
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Channel disconnected at ok=%d\n",
- ok);
- GNUNET_assert (ch_w->ch == channel);
-
- if ((DESTROY == test) && (3 == ok))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Reopen channel task!\n");
- if (NULL == get_peers_task)
- {
- get_peers_task = GNUNET_SCHEDULER_add_now (&get_peers,
- NULL);
- }
- return;
- }
-
- if (channel == incoming_ch)
- {
- ok++;
- incoming_ch = NULL;
- }
- else if (outgoing_ch == channel)
- {
- if (P2P_SIGNAL == test)
- {
- ok++;
- }
- outgoing_ch = NULL;
- }
- else
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Unknown channel! %p\n",
- channel);
- if ((NULL != disconnect_task) && (REOPEN != test))
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task =
- GNUNET_SCHEDULER_add_now (&gather_stats_and_exit,
- (void *) __LINE__);
- }
- else if ((NULL != reconnect_task) && (REOPEN == test))
- {
- GNUNET_SCHEDULER_cancel (reconnect_task);
- reconnect_task =
- GNUNET_SCHEDULER_add_now (&reconnect_op,
- (void *) __LINE__);
- }
- GNUNET_free (ch_w);
-}
-
-
-/**
- * Abort test: schedule disconnect and shutdown immediately
- *
- * @param line Line in the code the abort is requested from (__LINE__).
- */
-static void
-abort_test (long line)
-{
- if (NULL != disconnect_task)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Aborting test from %ld\n",
- line);
- disconnect_task =
- GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- (void *) line);
- }
-}
-
-
-/**
- * Send a message on the channel with the appropriate size and payload.
- *
- * Update the appropriate *_sent counter.
- *
- * @param channel Channel to send the message on.
- */
-static void
-send_test_message (struct GNUNET_CADET_Channel *channel)
-{
- struct GNUNET_MQ_Envelope *env;
- struct GNUNET_MessageHeader *msg;
- uint32_t *data;
- int payload;
- int size;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending test message on channel %u\n",
- channel->ccn.channel_of_client);
- size = size_payload;
- if (GNUNET_NO == initialized)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n");
- size += 1000;
- payload = data_sent;
- if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer
- data_sent++;
- }
- else if ((SPEED == test) || (SPEED_ACK == test))
- {
- if (get_target_channel () == channel)
- {
- payload = ack_sent;
- size += ack_sent;
- ack_sent++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending ACK %u [%d bytes]\n",
- payload, size);
- }
- else
- {
- payload = data_sent;
- size += data_sent;
- data_sent++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending DATA %u [%d bytes]\n",
- data_sent, size);
- }
- }
- else if (FORWARD == test)
- {
- payload = ack_sent;
- }
- else if (P2P_SIGNAL == test)
- {
- payload = data_sent;
- }
- else if (REOPEN == test)
- {
- payload = data_sent;
- data_sent++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending DATA %u [%d bytes]\n",
- data_sent, size);
- }
- else if (DESTROY == test)
- {
- payload = data_sent;
- }
- else
- {
- GNUNET_assert (0);
- }
- env = GNUNET_MQ_msg_extra (msg, size, GNUNET_MESSAGE_TYPE_DUMMY);
-
- data = (uint32_t *) &msg[1];
- *data = htonl (payload);
- GNUNET_MQ_send (GNUNET_CADET_get_mq (channel), env);
-}
-
-
-/**
- * Task to request a new data transmission in a SPEED test, without waiting
- * for previous messages to be sent/arrrive.
- *
- * @param cls Closure (unused).
- */
-static void
-send_next_msg (void *cls)
-{
- struct GNUNET_CADET_Channel *channel;
-
- send_next_msg_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending next message: %d\n",
- data_sent);
-
- channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch;
- GNUNET_assert (NULL != channel);
- GNUNET_assert (SPEED == test);
- send_test_message (channel);
- if (data_sent < total_packets)
- {
- /* SPEED test: Send all messages as soon as possible */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Scheduling message %d\n",
- data_sent + 1);
- send_next_msg_task =
- GNUNET_SCHEDULER_add_delayed (SEND_INTERVAL,
- &send_next_msg,
- NULL);
- }
-}
-
-
-/**
- * Every few messages cancel the timeout task and re-schedule it again, to
- * avoid timing out when traffic keeps coming.
- *
- * @param line Code line number to log if a timeout occurs.
- */
-static void
-reschedule_timeout_task (long line)
-{
- if ((ok % 10) == 0)
- {
- if (NULL != disconnect_task)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "reschedule timeout every 10 messages\n");
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &gather_stats_and_exit,
- (void *) line);
- }
- }
-}
-
-
-/**
- * Check if payload is sane (size contains payload).
- *
- * @param cls should match #ch
- * @param message The actual message.
- * @return #GNUNET_OK to keep the channel open,
- * #GNUNET_SYSERR to close it (signal serious error).
- */
-static int
-check_data (void *cls,
- const struct GNUNET_MessageHeader *message)
-{
- return GNUNET_OK; /* all is well-formed */
-}
-
-
-/**
- * Function is called whenever a message is received.
- *
- * @param cls closure (set from GNUNET_CADET_connect(), peer number)
- * @param message the actual message
- */
-static void
-handle_data (void *cls,
- const struct GNUNET_MessageHeader *message)
-{
- struct CadetTestChannelWrapper *ch = cls;
- struct GNUNET_CADET_Channel *channel = ch->ch;
- uint32_t *data;
- uint32_t payload;
- int *counter;
-
- ok++;
- GNUNET_CADET_receive_done (channel);
- counter = get_target_channel () == channel ? &data_received : &ack_received;
-
- reschedule_timeout_task ((long) __LINE__);
-
- if (channel == outgoing_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Root client got a message.\n");
- }
- else if (channel == incoming_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Leaf client got a message.\n");
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Unknown channel %p.\n",
- channel);
- GNUNET_assert (0);
- }
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "handle_data ok: (%d/%d)\n",
- ok,
- ok_goal);
- data = (uint32_t *) &message[1];
- payload = ntohl (*data);
- if (payload == *counter)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- " payload as expected: %u\n",
- payload);
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- " payload %u, expected: %u\n",
- payload, *counter);
- }
-
- if (DESTROY == test)
- {
- if (2 == ok)
- {
- ok++;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "dropping message ok: (%d/%d)\n",
- ok,
- ok_goal);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "TEST ID 0: %s\n",
- GNUNET_i2s (testpeer_id[0]));
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "TEST ID 1: %s\n",
- GNUNET_i2s (testpeer_id[1]));
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "dropping message\n");
- GNUNET_CADET_drop_message (GNUNET_CADET_get_mq (outgoing_ch),
- outgoing_ch->ccn,
- GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY);
- if (NULL != outgoing_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Destroying channel %p...\n",
- outgoing_ch);
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- }
- else if (5 == ok)
- {
- ok++;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "destroy test finished ok: (%d/%d)\n",
- ok,
- ok_goal);
- disconnect_task =
- GNUNET_SCHEDULER_add_now (&gather_stats_and_exit,
- (void *) __LINE__);
- // End of DESTROY test.
- }
- }
-
- if (GNUNET_NO == initialized)
- {
- initialized = GNUNET_YES;
- start_time = GNUNET_TIME_absolute_get ();
- if (SPEED == test)
- {
- GNUNET_assert (incoming_ch == channel);
- send_next_msg_task = GNUNET_SCHEDULER_add_now (&send_next_msg,
- NULL);
- return;
- }
- }
-
- (*counter)++;
- if (get_target_channel () == channel) /* Got "data" */
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received data %u\n", data_received);
- if ((DESTROY != test) && ((SPEED != test) || ( (ok_goal - 2) == ok)) )
- {
- /* Send ACK */
- send_test_message (channel);
- return;
- }
- else
- {
- if (data_received < total_packets)
- return;
- }
- }
- else /* Got "ack" */
- {
- if ((SPEED_ACK == test) || (SPEED == test) )
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received);
- /* Send more data */
- send_test_message (channel);
- if ((ack_received < total_packets) && (SPEED != test) )
- return;
- if ((ok == 2) && (SPEED == test) )
- return;
- show_end_data ();
- }
- if (test == P2P_SIGNAL)
- {
- GNUNET_CADET_channel_destroy (incoming_ch);
- incoming_ch = NULL;
- }
- else
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- }
-}
-
-
-/**
- * Method called whenever a peer connects to a port in MQ-based CADET.
- *
- * @param cls Closure from #GNUNET_CADET_open_port (peer # as long).
- * @param channel New handle to the channel.
- * @param source Peer that started this channel.
- * @return Closure for the incoming @a channel. It's given to:
- * - The #GNUNET_CADET_DisconnectEventHandler (given to
- * #GNUNET_CADET_open_port) when the channel dies.
- * - Each the #GNUNET_MQ_MessageCallback handlers for each message
- * received on the @a channel.
- */
-static void *
-connect_handler (void *cls,
- struct GNUNET_CADET_Channel *channel,
- const struct GNUNET_PeerIdentity *source)
-{
- struct CadetTestChannelWrapper *ch;
- long peer = (long) cls;
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Incoming channel from %s to %ld: %p\n",
- GNUNET_i2s (source),
- peer,
- channel);
- ok++;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "connect_handler ok: (%d/%d)\n",
- ok,
- ok_goal);
-
- if (peer == get_peer_nr (GNUNET_NO))
- {
- if ((DESTROY != test) && (NULL != incoming_ch))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Duplicate incoming channel for client %lu\n",
- (long) cls);
- GNUNET_assert (0);
- }
- incoming_ch = channel;
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Incoming channel for unexpected peer #%lu\n",
- (long) cls);
- GNUNET_assert (0);
- }
- if ((NULL != disconnect_task) && (REOPEN != test) && (DESTROY != test))
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &gather_stats_and_exit,
- (void *) __LINE__);
- }
- else if ((NULL != disconnect_task) && (REOPEN == test))
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_delayed (
- GNUNET_TIME_relative_multiply (short_time, 2),
- &gather_stats_and_exit,
- (void *) __LINE__);
- }
-
- if ((NULL != reconnect_task) && (REOPEN == test))
- {
- GNUNET_SCHEDULER_cancel (reconnect_task);
- reconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &reconnect_op,
- (void *) __LINE__);
- }
-
-
- /* TODO: cannot return channel as-is, in order to unify the data handlers */
- ch = GNUNET_new (struct CadetTestChannelWrapper);
- ch->ch = channel;
-
- return ch;
-}
-
-
-/**
- * START THE TESTCASE ITSELF, AS WE ARE CONNECTED TO THE CADET SERVICES.
- *
- * Testcase continues when the root receives confirmation of connected peers,
- * on callback function ch.
- *
- * @param cls Closure (unused).
- */
-static void
-start_test (void *cls)
-{
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (data,
- GNUNET_MESSAGE_TYPE_DUMMY,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
- };
- struct CadetTestChannelWrapper *ch;
- static struct GNUNET_CADET_Handle *h1;
- static struct GNUNET_PeerIdentity *p_id;
-
- test_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "start_test: %s\n", test_name);
- if (NULL != disconnect_task)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = NULL;
- }
-
- if (SPEED_REL == test)
- {
- test = SPEED;
- }
-
- p_id = get_from_p_ids ();
- h1 = get_from_cadets ();
-
- ch = GNUNET_new (struct CadetTestChannelWrapper);
- outgoing_ch = GNUNET_CADET_channel_create (h1,
- ch,
- p_id,
- &port,
- NULL,
- &disconnect_handler,
- handlers);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "channel created\n");
-
- ch->ch = outgoing_ch;
-
- if (DESTROY != test)
- disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &gather_stats_and_exit,
- (void *) __LINE__);
- if (KEEPALIVE == test)
- return; /* Don't send any data. */
-
- data_received = 0;
- data_sent = 0;
- ack_received = 0;
- ack_sent = 0;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending data initializer on channel %p...\n",
- outgoing_ch);
- send_test_message (outgoing_ch);
- if (REOPEN == test)
- {
- reconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &reconnect_op,
- (void *) __LINE__);
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_delayed (
- GNUNET_TIME_relative_multiply (short_time, 2),
- &gather_stats_and_exit,
- (void *) __LINE__);
- }
-}
-
-
-/**
- * Callback to be called when the requested peer information is available
- *
- * @param cls the closure from GNUNET_TESTBED_peer_getinformation()
- * @param op the operation this callback corresponds to
- * @param pinfo the result; will be NULL if the operation has failed
- * @param emsg error message if the operation has failed;
- * NULL if the operation is successful
- */
-static void
-pi_cb (void *cls,
- struct GNUNET_TESTBED_Operation *op,
- const struct GNUNET_TESTBED_PeerInformation *pinfo,
- const char *emsg)
-{
- long i = (long) cls;
-
- if ((NULL == pinfo) ||
- (NULL != emsg))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "pi_cb: %s\n",
- emsg);
- abort_test (__LINE__);
- return;
- }
-
- if (GNUNET_TESTBED_PIT_IDENTITY == pinfo->pit)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ID callback for %ld\n",
- i);
- testpeer_id[i] = pinfo->result.id;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "id: %s\n",
- GNUNET_i2s (testpeer_id[i]));
- }
- else if (GNUNET_TESTBED_PIT_CONFIGURATION == pinfo->pit)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "CFG callback for %ld\n",
- i);
- p_cfg[i] = pinfo->result.cfg;
- }
- else
- {
- GNUNET_break (0);
- }
-
- peerinfo_task_cnt++;
- if (peerinfo_task_cnt < 4)
- return;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Got all peer information, starting test\n");
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "TEST ID 0: %s\n",
- GNUNET_i2s (testpeer_id[0]));
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "TEST ID 1: %s\n",
- GNUNET_i2s (testpeer_id[1]));
- test_task = GNUNET_SCHEDULER_add_now (&start_test, NULL);
-}
-
-
-/**
- * test main: start test when all peers are connected
- *
- * @param cls Closure.
- * @param ctx Argument to give to GNUNET_CADET_TEST_cleanup on test end.
- * @param num_peers Number of peers that are running.
- * @param peers Array of peers.
- * @param cadets Handle to each of the CADETs of the peers.
- */
-static void
-tmain (void *cls,
- struct GNUNET_CADET_TEST_Context *ctx,
- unsigned int num_peers,
- struct GNUNET_TESTBED_Peer **peers,
- struct GNUNET_CADET_Handle **cadets)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test main\n");
- ok = 0;
- test_ctx = ctx;
- peers_running = num_peers;
- GNUNET_assert (peers_running == peers_requested);
- testbed_peers = peers;
- cadets_running = cadets;
-
- disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &disconnect_cadet_peers,
- (void *) __LINE__);
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
- NULL);
- t_op[0] = GNUNET_TESTBED_peer_get_information (peers[0],
- GNUNET_TESTBED_PIT_IDENTITY,
- &pi_cb,
- (void *) 0L);
- t_op[1] = GNUNET_TESTBED_peer_get_information (peers[num_peers - 1],
- GNUNET_TESTBED_PIT_IDENTITY,
- &pi_cb,
- (void *) 1L);
- t_op[0] = GNUNET_TESTBED_peer_get_information (peers[0],
-
GNUNET_TESTBED_PIT_CONFIGURATION,
- &pi_cb,
- (void *) 0L);
- t_op[1] = GNUNET_TESTBED_peer_get_information (peers[num_peers - 1],
-
GNUNET_TESTBED_PIT_CONFIGURATION,
- &pi_cb,
- (void *) 1L);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "requested peer ids\n");
-}
-
-
-/**
- * Main: start test
- */
-int
-main (int argc, char *argv[])
-{
- static const struct GNUNET_HashCode *ports[2];
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (data,
- GNUNET_MESSAGE_TYPE_DUMMY,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
- };
- const char *config_file;
- char port_id[] = "test port";
- struct GNUNET_GETOPT_CommandLineOption options[] = {
- GNUNET_GETOPT_option_relative_time ('t',
- "time",
- "short_time",
- gettext_noop ("set short timeout"),
- &short_time),
- GNUNET_GETOPT_option_uint ('m',
- "messages",
- "NUM_MESSAGES",
- gettext_noop ("set number of messages to send"),
- &total_packets),
-
- GNUNET_GETOPT_OPTION_END
- };
-
-
- initialized = GNUNET_NO;
- GNUNET_log_setup ("test", "DEBUG", NULL);
-
- total_packets = TOTAL_PACKETS;
- short_time = SHORT_TIME;
- if (-1 == GNUNET_GETOPT_run (argv[0], options, argc, argv))
- {
- fprintf (stderr, "test failed: problem with CLI parameters\n");
- exit (1);
- }
-
- config_file = "test_cadet.conf";
- GNUNET_CRYPTO_hash (port_id, sizeof(port_id), &port);
-
- /* Find out requested size */
- if (strstr (argv[0], "_2_") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DIRECT CONNECTIONs\n");
- peers_requested = 2;
- }
- else if (strstr (argv[0], "_5_") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "5 PEER LINE\n");
- peers_requested = 5;
- }
- else if (strstr (argv[0], "_6_") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "6 PEER LINE\n");
- peers_requested = 6;
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "SIZE UNKNOWN, USING 2\n");
- peers_requested = 2;
- }
-
- /* Find out requested test */
- if (strstr (argv[0], "_forward") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FORWARD\n");
- test = FORWARD;
- test_name = "unicast";
- ok_goal = 4;
- }
- else if (strstr (argv[0], "_signal") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SIGNAL\n");
- test = P2P_SIGNAL;
- test_name = "signal";
- ok_goal = 4;
- }
- else if (strstr (argv[0], "_speed_ack") != NULL)
- {
- /* Test is supposed to generate the following callbacks:
- * 1 incoming channel (@dest)
- * total_packets received data packet (@dest)
- * total_packets received data packet (@orig)
- * 1 received channel destroy (@dest) FIXME #5818
- */ok_goal = total_packets * 2 + 2;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED_ACK\n");
- test = SPEED_ACK;
- test_name = "speed ack";
- }
- else if (strstr (argv[0], "_speed") != NULL)
- {
- /* Test is supposed to generate the following callbacks:
- * 1 incoming channel (@dest)
- * 1 initial packet (@dest)
- * total_packets received data packet (@dest)
- * 1 received data packet (@orig)
- * 1 received channel destroy (@dest) FIXME #5818
- */ok_goal = total_packets + 4;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED\n");
- if (strstr (argv[0], "_reliable") != NULL)
- {
- test = SPEED_REL;
- test_name = "speed reliable";
- config_file = "test_cadet_drop.conf";
- }
- else
- {
- test = SPEED;
- test_name = "speed";
- }
- }
- else if (strstr (argv[0], "_keepalive") != NULL)
- {
- test = KEEPALIVE;
- test_name = "keepalive";
- /* Test is supposed to generate the following callbacks:
- * 1 incoming channel (@dest)
- * [wait]
- * 1 received channel destroy (@dest) FIXME #5818
- */ok_goal = 1;
- }
- else if (strstr (argv[0], "_reopen") != NULL)
- {
- test = REOPEN;
- test_name = "reopen";
- ///* Test is supposed to generate the following callbacks:
- // * 1 incoming channel (@dest)
- // * [wait]
- // * 1 received channel destroy (@dest) FIXME #5818
- // */
- ok_goal = 6;
- }
- else if (strstr (argv[0], "_destroy") != NULL)
- {
- test = DESTROY;
- test_name = "destroy";
- ok_goal = 6;
- short_time = GNUNET_TIME_relative_multiply (short_time, 5);
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "UNKNOWN\n");
- test = SETUP;
- ok_goal = 0;
- }
-
- if (strstr (argv[0], "backwards") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "BACKWARDS (LEAF TO ROOT)\n");
- test_backwards = GNUNET_YES;
- GNUNET_asprintf (&test_name, "backwards %s", test_name);
- }
-
- peerinfo_task_cnt = 0;
- ports[0] = &port;
- ports[1] = NULL;
- GNUNET_CADET_TEST_ruN ("test_cadet_small",
- config_file,
- peers_requested,
- &tmain,
- NULL, /* tmain cls */
- &connect_handler,
- NULL,
- &disconnect_handler,
- handlers,
- ports);
- if (NULL != strstr (argv[0], "_reliable"))
- msg_dropped = 0; /* dropped should be retransmitted */
-
- if (ok_goal > ok - msg_dropped)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "FAILED! (%d/%d)\n", ok, ok_goal);
- return 1;
- }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "success\n");
- return 0;
-}
-
-
-/* end of test_cadet.c */
diff --git a/src/cadet/test_cadet_drop.conf b/src/cadet/test_cadet_drop.conf
deleted file mode 100644
index c9bcf603b..000000000
--- a/src/cadet/test_cadet_drop.conf
+++ /dev/null
@@ -1,4 +0,0 @@
-@INLINE@ test_cadet.conf
-
-[cadet]
-DROP_PERCENT = 1
diff --git a/src/cadet/test_cadet_flow.c b/src/cadet/test_cadet_flow.c
deleted file mode 100644
index 441599973..000000000
--- a/src/cadet/test_cadet_flow.c
+++ /dev/null
@@ -1,891 +0,0 @@
-/*
- This file is part of GNUnet.
- Copyright (C) 2011, 2017 GNUnet e.V.
-
- GNUnet is free software: you can redistribute it and/or modify it
- under the terms of the GNU Affero General Public License as published
- by the Free Software Foundation, either version 3 of the License,
- or (at your option) any later version.
-
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Affero General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-
- SPDX-License-Identifier: AGPL3.0-or-later
- */
-/**
- * @file cadet/test_cadet_flow.c
- * @author Bart Polot
- * @author Christian Grothoff
- * @brief Test for flow control of CADET service
- */
-#include "platform.h"
-#include <stdio.h>
-#include "cadet_test_lib.h"
-#include "gnunet_cadet_service.h"
-#include "gnunet_statistics_service.h"
-#include <gauger.h>
-
-
-/**
- * Ugly workaround to unify data handlers on incoming and outgoing channels.
- */
-struct CadetTestChannelWrapper
-{
- /**
- * Channel pointer.
- */
- struct GNUNET_CADET_Channel *ch;
-};
-
-/**
- * How many messages to send by default.
- */
-#define TOTAL_PACKETS_DEFAULT 500
-
-/**
- * How long until we give up on connecting the peers?
- */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
-
-/**
- * Time to wait by default for stuff that should be rather fast.
- */
-#define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20)
-
-/**
- * How fast do we send messages?
- */
-#define SEND_INTERVAL GNUNET_TIME_relative_multiply ( \
- GNUNET_TIME_UNIT_MILLISECONDS, 10)
-
-
-/**
- * How many packets to send.
- */
-static unsigned int total_packets = TOTAL_PACKETS_DEFAULT;
-
-/**
- * Time to wait for fast operations.
- */
-static struct GNUNET_TIME_Relative short_time;
-
-/**
- * Size of each test packet's payload
- */
-static size_t size_payload = sizeof(uint32_t);
-
-/**
- * Operation to get peer ids.
- */
-static struct GNUNET_TESTBED_Operation *t_op[2];
-
-/**
- * Peer ids.
- */
-static struct GNUNET_PeerIdentity *p_id[2];
-
-/**
- * Port ID
- */
-static struct GNUNET_HashCode port;
-
-/**
- * Peer ids counter.
- */
-static unsigned int p_ids;
-
-/**
- * Is the setup initialized?
- */
-static int initialized;
-
-/**
- * Number of payload packes sent.
- */
-static int data_sent;
-
-/**
- * Number of payload packets received.
- */
-static int data_received;
-
-/**
- * Number of payload packed acknowledgements sent.
- */
-static int ack_sent;
-
-/**
- * Number of payload packed explicitly (app level) acknowledged.
- */
-static int ack_received;
-
-/**
- * Total number of peers asked to run.
- */
-static unsigned int peers_requested = 2;
-
-/**
- * Number of currently running peers (should be same as @c peers_requested).
- */
-static unsigned int peers_running;
-
-/**
- * Test context (to shut down).
- */
-struct GNUNET_CADET_TEST_Context *test_ctx;
-
-/**
- * Task called to disconnect peers.
- */
-static struct GNUNET_SCHEDULER_Task *disconnect_task;
-
-/**
- * Task To perform tests
- */
-static struct GNUNET_SCHEDULER_Task *test_task;
-
-/**
- * Task runnining #send_next_msg().
- */
-static struct GNUNET_SCHEDULER_Task *send_next_msg_task;
-
-/**
- * Cadet handle for the root peer
- */
-static struct GNUNET_CADET_Handle *h1;
-
-/**
- * Cadet handle for the first leaf peer
- */
-static struct GNUNET_CADET_Handle *h2;
-
-/**
- * Channel handle for the root peer
- */
-static struct GNUNET_CADET_Channel *outgoing_ch;
-
-/**
- * Channel handle for the dest peer
- */
-static struct GNUNET_CADET_Channel *incoming_ch;
-
-/**
- * Time we started the data transmission (after channel has been established
- * and initialized).
- */
-static struct GNUNET_TIME_Absolute start_time;
-
-/**
- * Peers handle.
- */
-static struct GNUNET_TESTBED_Peer **testbed_peers;
-
-/**
- * Statistics operation handle.
- */
-static struct GNUNET_TESTBED_Operation *stats_op;
-
-/**
- * Keepalives sent.
- */
-static unsigned int ka_sent;
-
-/**
- * Keepalives received.
- */
-static unsigned int ka_received;
-
-/**
- * How many messages were dropped by CADET because of full buffers?
- */
-static unsigned int msg_dropped;
-
-
-/**
- * Show the results of the test (banwidth achieved) and log them to GAUGER
- */
-static void
-show_end_data (void)
-{
- static struct GNUNET_TIME_Absolute end_time;
- static struct GNUNET_TIME_Relative total_time;
-
- end_time = GNUNET_TIME_absolute_get ();
- total_time = GNUNET_TIME_absolute_get_difference (start_time, end_time);
- fprintf (stderr,
- "\nResults of test \"%s\"\n",
- test_name);
- fprintf (stderr,
- "Test time %s\n",
- GNUNET_STRINGS_relative_time_to_string (total_time, GNUNET_YES));
- fprintf (stderr,
- "Test bandwidth: %f kb/s\n",
- 4 * total_packets * 1.0 / (total_time.rel_value_us / 1000)); //
4bytes * ms
- fprintf (stderr,
- "Test throughput: %f packets/s\n\n",
- total_packets * 1000.0 / (total_time.rel_value_us / 1000)); //
packets * ms
- GAUGER ("CADET",
- test_name,
- total_packets * 1000.0 / (total_time.rel_value_us / 1000),
- "packets/s");
-}
-
-
-/**
- * Shut down peergroup, clean up.
- *
- * @param cls Closure (unused).
- * @param tc Task Context.
- */
-static void
-shutdown_task (void *cls)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Ending test.\n");
- if (NULL != send_next_msg_task)
- {
- GNUNET_SCHEDULER_cancel (send_next_msg_task);
- send_next_msg_task = NULL;
- }
- if (NULL != test_task)
- {
- GNUNET_SCHEDULER_cancel (test_task);
- test_task = NULL;
- }
- for (unsigned int i = 0; i < 2; i++)
- GNUNET_TESTBED_operation_done (t_op[i]);
- if (NULL != outgoing_ch)
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- if (NULL != incoming_ch)
- {
- GNUNET_CADET_channel_destroy (incoming_ch);
- incoming_ch = NULL;
- }
- GNUNET_CADET_TEST_cleanup (test_ctx);
-}
-
-
-/**
- * Stats callback. Finish the stats testbed operation and when all stats have
- * been iterated, shutdown the test.
- *
- * @param cls Closure (line number from which termination was requested).
- * @param op the operation that has been finished
- * @param emsg error message in case the operation has failed; will be NULL if
- * operation has executed successfully.
- */
-static void
-stats_cont (void *cls,
- struct GNUNET_TESTBED_Operation *op,
- const char *emsg)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "KA sent: %u, KA received: %u\n",
- ka_sent,
- ka_received);
- if ((KEEPALIVE == test) && ((ka_sent < 2) || (ka_sent > ka_received + 1)))
- {
- GNUNET_break (0);
- ok--;
- }
- GNUNET_TESTBED_operation_done (stats_op);
-
- if (NULL != disconnect_task)
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- cls);
-}
-
-
-/**
- * Process statistic values.
- *
- * @param cls closure (line number, unused)
- * @param peer the peer the statistic belong to
- * @param subsystem name of subsystem that created the statistic
- * @param name the name of the datum
- * @param value the current value
- * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if
not
- * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
- */
-static int
-stats_iterator (void *cls,
- const struct GNUNET_TESTBED_Peer *peer,
- const char *subsystem,
- const char *name,
- uint64_t value,
- int is_persistent)
-{
- static const char *s_sent = "# keepalives sent";
- static const char *s_recv = "# keepalives received";
- static const char *rdrops = "# messages dropped due to full buffer";
- static const char *cdrops = "# messages dropped due to slow client";
- uint32_t i;
-
- i = GNUNET_TESTBED_get_index (peer);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i,
- subsystem, name, (unsigned long long) value);
- if ((0 == strncmp (s_sent, name, strlen (s_sent))) && (0 == i))
- ka_sent = value;
- if ((0 == strncmp (s_recv, name, strlen (s_recv))) && (peers_requested - 1 ==
- i) )
- ka_received = value;
- if (0 == strncmp (rdrops, name, strlen (rdrops)))
- msg_dropped += value;
- if (0 == strncmp (cdrops, name, strlen (cdrops)))
- msg_dropped += value;
-
- return GNUNET_OK;
-}
-
-
-/**
- * Task to gather all statistics.
- *
- * @param cls Closure (line from which the task was scheduled).
- */
-static void
-gather_stats_and_exit (void *cls)
-{
- long l = (long) cls;
-
- disconnect_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "gathering statistics from line %ld\n",
- l);
- if (NULL != outgoing_ch)
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- stats_op = GNUNET_TESTBED_get_statistics (peers_running,
- testbed_peers,
- "cadet",
- NULL,
- &stats_iterator,
- stats_cont,
- cls);
-}
-
-
-/**
- * Abort test: schedule disconnect and shutdown immediately
- *
- * @param line Line in the code the abort is requested from (__LINE__).
- */
-static void
-abort_test (long line)
-{
- if (NULL != disconnect_task)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Aborting test from %ld\n",
- line);
- disconnect_task =
- GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- (void *) line);
- }
-}
-
-
-/**
- * Send a message on the channel with the appropriate size and payload.
- *
- * Update the appropriate *_sent counter.
- *
- * @param channel Channel to send the message on.
- */
-static void
-send_test_message (struct GNUNET_CADET_Channel *channel)
-{
- struct GNUNET_MQ_Envelope *env;
- struct GNUNET_MessageHeader *msg;
- uint32_t *data;
- int payload;
- int size;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending test message on channel %p\n",
- channel);
- size = size_payload;
- if (GNUNET_NO == initialized)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n");
- size += 1000;
- payload = data_sent;
- if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer
- data_sent++;
- }
- else if ((SPEED == test) || (SPEED_ACK == test))
- {
- if (get_target_channel () == channel)
- {
- payload = ack_sent;
- size += ack_sent;
- ack_sent++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending ACK %u [%d bytes]\n",
- payload, size);
- }
- else
- {
- payload = data_sent;
- size += data_sent;
- data_sent++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending DATA %u [%d bytes]\n",
- data_sent, size);
- }
- }
- else if (FORWARD == test)
- {
- payload = ack_sent;
- }
- else if (P2P_SIGNAL == test)
- {
- payload = data_sent;
- }
- else
- {
- GNUNET_assert (0);
- }
- env = GNUNET_MQ_msg_extra (msg, size, GNUNET_MESSAGE_TYPE_DUMMY);
-
- data = (uint32_t *) &msg[1];
- *data = htonl (payload);
- GNUNET_MQ_send (GNUNET_CADET_get_mq (channel), env);
-}
-
-
-/**
- * Task to request a new data transmission in a SPEED test, without waiting
- * for previous messages to be sent/arrrive.
- *
- * @param cls Closure (unused).
- */
-static void
-send_next_msg (void *cls)
-{
- struct GNUNET_CADET_Channel *channel;
-
- send_next_msg_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending next message: %d\n",
- data_sent);
-
- channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch;
- GNUNET_assert (NULL != channel);
- GNUNET_assert (SPEED == test);
- send_test_message (channel);
- if (data_sent < total_packets)
- {
- /* SPEED test: Send all messages as soon as possible */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Scheduling message %d\n",
- data_sent + 1);
- send_next_msg_task =
- GNUNET_SCHEDULER_add_delayed (SEND_INTERVAL,
- &send_next_msg,
- NULL);
- }
-}
-
-
-/**
- * Check if payload is sane (size contains payload).
- *
- * @param cls should match #ch
- * @param message The actual message.
- * @return #GNUNET_OK to keep the channel open,
- * #GNUNET_SYSERR to close it (signal serious error).
- */
-static int
-check_data (void *cls,
- const struct GNUNET_MessageHeader *message)
-{
- return GNUNET_OK; /* all is well-formed */
-}
-
-
-/**
- * Function is called whenever a message is received.
- *
- * @param cls closure (set from GNUNET_CADET_connect(), peer number)
- * @param message the actual message
- */
-static void
-handle_data (void *cls,
- const struct GNUNET_MessageHeader *message)
-{
- struct CadetTestChannelWrapper *ch = cls;
- struct GNUNET_CADET_Channel *channel = ch->ch;
- uint32_t *data;
- uint32_t payload;
- int *counter;
-
- GNUNET_CADET_receive_done (channel);
- counter = get_target_channel () == channel ? &data_received : &ack_received;
- if (channel == outgoing_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Root client got a message.\n");
- }
- else if (channel == incoming_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Leaf client got a message.\n");
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Unknown channel %p.\n",
- channel);
- GNUNET_assert (0);
- }
-
- data = (uint32_t *) &message[1];
- payload = ntohl (*data);
- if (payload == *counter)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Payload as expected: %u\n",
- payload);
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Received payload %u, expected: %u\n",
- payload, *counter);
- }
- (*counter)++;
- if (get_target_channel () == channel) /* Got "data" */
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- " received data %u\n",
- data_received);
- if (data_received < total_packets)
- return;
- }
- else /* Got "ack" */
- {
- if ((SPEED_ACK == test) || (SPEED == test) )
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received);
- /* Send more data */
- send_test_message (channel);
- if ((ack_received < total_packets) && (SPEED != test) )
- return;
- if ((ok == 2) && (SPEED == test) )
- return;
- show_end_data ();
- }
- if (test == P2P_SIGNAL)
- {
- GNUNET_CADET_channel_destroy (incoming_ch);
- incoming_ch = NULL;
- }
- else
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- }
-}
-
-
-/**
- * Method called whenever a peer connects to a port in MQ-based CADET.
- *
- * @param cls Closure from #GNUNET_CADET_open_port (peer # as long).
- * @param channel New handle to the channel.
- * @param source Peer that started this channel.
- * @return Closure for the incoming @a channel. It's given to:
- * - The #GNUNET_CADET_DisconnectEventHandler (given to
- * #GNUNET_CADET_open_port) when the channel dies.
- * - Each the #GNUNET_MQ_MessageCallback handlers for each message
- * received on the @a channel.
- */
-static void *
-connect_handler (void *cls,
- struct GNUNET_CADET_Channel *channel,
- const struct GNUNET_PeerIdentity *source)
-{
- struct CadetTestChannelWrapper *ch;
- long peer = (long) cls;
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Incoming channel from %s to %ld: %p\n",
- GNUNET_i2s (source),
- peer,
- channel);
- if (peer == peers_requested - 1)
- {
- if (NULL != incoming_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Duplicate incoming channel for client %lu\n",
- (long) cls);
- GNUNET_assert (0);
- }
- incoming_ch = channel;
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Incoming channel for unexpected peer #%lu\n",
- (long) cls);
- GNUNET_assert (0);
- }
- ch = GNUNET_new (struct CadetTestChannelWrapper);
- ch->ch = channel;
-
- return ch;
-}
-
-
-/**
- * Function called whenever an MQ-channel is destroyed, even if the destruction
- * was requested by #GNUNET_CADET_channel_destroy.
- * It must NOT call #GNUNET_CADET_channel_destroy on the channel.
- *
- * It should clean up any associated state, including cancelling any pending
- * transmission on this channel.
- *
- * @param cls Channel closure (channel wrapper).
- * @param channel Connection to the other end (henceforth invalid).
- */
-static void
-disconnect_handler (void *cls,
- const struct GNUNET_CADET_Channel *channel)
-{
- struct CadetTestChannelWrapper *ch_w = cls;
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Channel disconnected at %d\n",
- ok);
- GNUNET_assert (ch_w->ch == channel);
- if (channel == incoming_ch)
- incoming_ch = NULL;
- else if (outgoing_ch == channel)
- outgoing_ch = NULL;
- else
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Disconnect on unknown channel %p\n",
- channel);
- if (NULL != disconnect_task)
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_now (&gather_stats_and_exit,
- (void *) __LINE__);
- GNUNET_free (ch_w);
-}
-
-
-/**
- * Start the testcase, we know the peers and have handles to CADET.
- *
- * Testcase continues when the root receives confirmation of connected peers,
- * on callback function ch.
- *
- * @param cls Closure (unused).
- */
-static void
-start_test (void *cls)
-{
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (data,
- GNUNET_MESSAGE_TYPE_DUMMY,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
- };
- struct CadetTestChannelWrapper *ch;
- enum GNUNET_CADET_ChannelOption flags;
-
- test_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "In start_test\n");
- start_time = GNUNET_TIME_absolute_get ();
- ch = GNUNET_new (struct CadetTestChannelWrapper);
- outgoing_ch = GNUNET_CADET_channel_create (h1,
- ch,
- p_id[1],
- &port,
- flags,
- NULL,
- &disconnect_handler,
- handlers);
- ch->ch = outgoing_ch;
- GNUNET_assert (NULL == disconnect_task);
- disconnect_task
- = GNUNET_SCHEDULER_add_delayed (short_time,
- &gather_stats_and_exit,
- (void *) __LINE__);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending data initializer on channel %p...\n",
- outgoing_ch);
- send_test_message (outgoing_ch);
-}
-
-
-/**
- * Callback to be called when the requested peer information is available
- *
- * @param cls the closure from GNUNET_TESTBED_peer_get_information()
- * @param op the operation this callback corresponds to
- * @param pinfo the result; will be NULL if the operation has failed
- * @param emsg error message if the operation has failed;
- * NULL if the operation is successful
- */
-static void
-pi_cb (void *cls,
- struct GNUNET_TESTBED_Operation *op,
- const struct GNUNET_TESTBED_PeerInformation *pinfo,
- const char *emsg)
-{
- long i = (long) cls;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ID callback for %ld\n",
- i);
- if ((NULL == pinfo) ||
- (NULL != emsg))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "pi_cb: %s\n",
- emsg);
- abort_test (__LINE__);
- return;
- }
- p_id[i] = pinfo->result.id;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "id: %s\n",
- GNUNET_i2s (p_id[i]));
- p_ids++;
- if (p_ids < 2)
- return;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Got all IDs, starting test\n");
- test_task = GNUNET_SCHEDULER_add_now (&start_test,
- NULL);
-}
-
-
-/**
- * test main: start test when all peers are connected
- *
- * @param cls Closure.
- * @param ctx Argument to give to GNUNET_CADET_TEST_cleanup on test end.
- * @param num_peers Number of peers that are running.
- * @param peers Array of peers.
- * @param cadets Handle to each of the CADETs of the peers.
- */
-static void
-tmain (void *cls,
- struct GNUNET_CADET_TEST_Context *ctx,
- unsigned int num_peers,
- struct GNUNET_TESTBED_Peer **peers,
- struct GNUNET_CADET_Handle **cadets)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "test main\n");
- test_ctx = ctx;
- peers_running = num_peers;
- GNUNET_assert (peers_running == peers_requested);
- testbed_peers = peers;
- h1 = cadets[0];
- h2 = cadets[num_peers - 1];
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
- NULL);
- p_ids = 0;
- t_op[0] = GNUNET_TESTBED_peer_get_information (peers[0],
- GNUNET_TESTBED_PIT_IDENTITY,
- &pi_cb,
- (void *) 0L);
- t_op[1] = GNUNET_TESTBED_peer_get_information (peers[num_peers - 1],
- GNUNET_TESTBED_PIT_IDENTITY,
- &pi_cb,
- (void *) 1L);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "requested peer ids\n");
-}
-
-
-/**
- * Main: start test
- */
-int
-main (int argc,
- char *argv[])
-{
- static const struct GNUNET_HashCode *ports[2];
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (data,
- GNUNET_MESSAGE_TYPE_DUMMY,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
- };
- const char *config_file = "test_cadet.conf";
- char port_id[] = "test port";
- struct GNUNET_GETOPT_CommandLineOption options[] = {
- GNUNET_GETOPT_option_relative_time ('t',
- "time",
- "short_time",
- gettext_noop ("set short timeout"),
- &short_time),
- GNUNET_GETOPT_option_uint ('m',
- "messages",
- "NUM_MESSAGES",
- gettext_noop ("set number of messages to send"),
- &total_packets),
- GNUNET_GETOPT_option_uint ('p',
- "peers",
- "NUM_PEERS",
- gettext_noop ("number of peers to launch"),
- &peers_requested),
- GNUNET_GETOPT_OPTION_END
- };
-
- GNUNET_log_setup ("test-cadet-flow",
- "DEBUG",
- NULL);
- total_packets = TOTAL_PACKETS;
- short_time = SHORT_TIME;
- if (-1 == GNUNET_GETOPT_run (argv[0],
- options,
- argc,
- argv))
- {
- fprintf (stderr,
- "test failed: problem with CLI parameters\n");
- return 1;
- }
- GNUNET_CRYPTO_hash (port_id,
- sizeof(port_id),
- &port);
- ports[0] = &port;
- ports[1] = NULL;
- GNUNET_CADET_TEST_ruN ("test_cadet_flow",
- config_file,
- peers_requested,
- &tmain,
- NULL, /* tmain cls */
- &connect_handler,
- NULL,
- &disconnect_handler,
- handlers,
- ports);
- return 0;
-}
-
-
-/* end of test_cadet_flow.c */
--
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.