/*
This file is part of GNUnet.
- Copyright (C) 2011 GNUnet e.V.
+ 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 General Public License as published
/**
* How many messages to send
*/
-#define TOTAL_PACKETS 5000 /* Cannot exceed 64k! */
+#define TOTAL_PACKETS 500 /* Cannot exceed 64k! */
/**
* How long until we give up on connecting the peers?
/**
* String with test name
*/
-char *test_name;
+static char *test_name;
/**
* Flag to send traffic leaf->root in speed tests to test BCK_ACK logic.
/**
* Number of events expected to conclude the test successfully.
*/
-int ok_goal;
+static int ok_goal;
/**
* Size of each test packet
*/
-size_t size_payload = sizeof (struct GNUNET_MessageHeader) + sizeof (uint32_t);
+static size_t size_payload = sizeof (struct GNUNET_MessageHeader) + sizeof (uint32_t);
/**
* Operation to get peer ids.
*/
-struct GNUNET_TESTBED_Operation *t_op[2];
+static struct GNUNET_TESTBED_Operation *t_op[2];
/**
* Peer ids.
*/
-struct GNUNET_PeerIdentity *p_id[2];
+static struct GNUNET_PeerIdentity *p_id[2];
/**
* Port ID
*/
-struct GNUNET_HashCode port;
+static struct GNUNET_HashCode port;
/**
* Peer ids counter.
*/
-unsigned int p_ids;
+static unsigned int p_ids;
/**
* Is the setup initialized?
* operation has executed successfully.
*/
static void
-stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
+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_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)
static void
abort_test (long line)
{
- if (disconnect_task != NULL)
+ if (NULL != disconnect_task)
{
GNUNET_SCHEDULER_cancel (disconnect_task);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Aborting test from %ld\n", line);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Aborting test from %ld\n", line);
disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
(void *) line);
}
* @param size Size of the buffer we have.
* @param buf Buffer to copy data to.
*/
-size_t
+static size_t
tmt_rdy (void *cls, size_t size, void *buf)
{
struct GNUNET_MessageHeader *msg = buf;
long id = (long) cls;
unsigned int counter;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "tmt_rdy on %ld, filling buffer\n", id);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "tmt_rdy on %ld, filling buffer\n",
+ id);
if (0 == id)
th = NULL;
else if ((peers_requested - 1) == id)
GNUNET_assert (0);
counter = get_expected_target () == id ? ack_sent : data_sent;
msg_size = size_payload + counter;
- if (size < msg_size || NULL == buf)
+ GNUNET_assert (msg_size > sizeof (struct GNUNET_MessageHeader));
+ if ( (size < msg_size) ||
+ (NULL == buf) )
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"size %u, buf %p, data_sent %u, ack_received %u\n",
return 0;
}
msg->size = htons (msg_size);
- msg->type = htons (1);
+ msg->type = htons (GNUNET_MESSAGE_TYPE_DUMMY);
data = (uint32_t *) &msg[1];
*data = htonl (counter);
if (GNUNET_NO == initialized)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "sending initializer\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "sending initializer\n");
msg_size = size_payload + 1000;
- if (SPEED_ACK == test)
+ msg->size = htons (msg_size);
+ if (SPEED_ACK == test)
data_sent++;
}
- else if (SPEED == test || SPEED_ACK == test)
+ else if ( (SPEED == test) ||
+ (SPEED_ACK == test) )
{
if (get_expected_target() == id)
ack_sent++;
" Sent message %u size %u\n",
counter,
(unsigned int) msg_size);
- if (data_sent < TOTAL_PACKETS && SPEED == test)
+ if ( (data_sent < TOTAL_PACKETS) &&
+ (SPEED == test) )
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " Scheduling message %d\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ " Scheduling message %d\n",
counter + 1);
data_job = GNUNET_SCHEDULER_add_now (&data_task, NULL);
}
/**
* Function is called whenever a message is received.
*
- * @param cls closure (set from GNUNET_CADET_connect, peer number)
+ * @param cls closure (set from GNUNET_CADET_connect(), peer number)
* @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)
+ * @return #GNUNET_OK to keep the connection open,
+ * #GNUNET_SYSERR to close it (signal serious error)
*/
-int
-data_callback (void *cls, struct GNUNET_CADET_Channel *channel,
+static int
+data_callback (void *cls,
+ struct GNUNET_CADET_Channel *channel,
void **channel_ctx,
const struct GNUNET_MessageHeader *message)
{
{
if (NULL != disconnect_task)
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, " reschedule timeout\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ " reschedule timeout\n");
GNUNET_SCHEDULER_cancel (disconnect_task);
disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
&gather_stats_and_exit,
* {callback_function, message_type, size_expected}
*/
static struct GNUNET_CADET_MessageHandler handlers[] = {
- {&data_callback, 1, sizeof (struct GNUNET_MessageHeader)},
+ {&data_callback,
+ GNUNET_MESSAGE_TYPE_DUMMY,
+ sizeof (struct GNUNET_MessageHeader)},
{NULL, 0, 0}
};
* (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)
+incoming_channel (void *cls,
+ struct GNUNET_CADET_Channel *channel,
+ const struct GNUNET_PeerIdentity *initiator,
+ const struct GNUNET_HashCode *port,
+ enum GNUNET_CADET_ChannelOption options)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Incoming channel from %s to peer %d:%s\n",
ok++;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, " ok: %d\n", ok);
if ((long) cls == peers_requested - 1)
+ {
+ if (NULL != incoming_ch)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Duplicate incoming channel for client %lu\n",
+ (long) cls);
+ GNUNET_break(0);
+ }
incoming_ch = channel;
+ }
else
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
return NULL;
}
+
/**
* Function called whenever an inbound channel is destroyed. Should clean up
* any associated state.
* with the channel is stored
*/
static void
-channel_cleaner (void *cls, const struct GNUNET_CADET_Channel *channel,
+channel_cleaner (void *cls,
+ const struct GNUNET_CADET_Channel *channel,
void *channel_ctx)
{
long i = (long) cls;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Incoming channel disconnected at peer %ld\n", i);
+ "Incoming channel disconnected at peer %ld\n",
+ i);
if (peers_running - 1 == i)
{
ok++;
{
if (P2P_SIGNAL == test)
{
- ok ++;
+ ok++;
}
GNUNET_break (channel == ch);
ch = NULL;
disconnect_task = GNUNET_SCHEDULER_add_now (&gather_stats_and_exit,
(void *) __LINE__);
}
-
- return;
}
enum GNUNET_CADET_ChannelOption flags;
test_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "do_test\n");
-
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "do_test\n");
if (NULL != disconnect_task)
{
GNUNET_SCHEDULER_cancel (disconnect_task);
flags |= GNUNET_CADET_OPTION_RELIABLE;
}
- ch = GNUNET_CADET_channel_create (h1, NULL, p_id[1], &port, flags);
+ ch = GNUNET_CADET_channel_create (h1,
+ NULL,
+ p_id[1],
+ &port,
+ flags);
- disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
- &gather_stats_and_exit,
- (void *) __LINE__);
+ disconnect_task
+ = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
+ &gather_stats_and_exit,
+ (void *) __LINE__);
if (KEEPALIVE == test)
return; /* Don't send any data. */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending data initializer...\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Sending data initializer...\n");
data_received = 0;
data_sent = 0;
ack_received = 0;
ack_sent = 0;
- th = GNUNET_CADET_notify_transmit_ready (ch, GNUNET_NO,
+ th = GNUNET_CADET_notify_transmit_ready (ch,
+ GNUNET_NO,
GNUNET_TIME_UNIT_FOREVER_REL,
size_payload + 1000,
&tmt_rdy, (void *) 0L);
{
long i = (long) cls;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "id callback for %ld\n", i);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "id callback for %ld\n", i);
- if (NULL == pinfo || NULL != emsg)
+ if ( (NULL == pinfo) ||
+ (NULL != emsg) )
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "pi_cb: %s\n", 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]));
+ 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");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Got all IDs, starting test\n");
test_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
- &do_test, NULL);
+ &do_test,
+ NULL);
}
+
/**
* test main: start test when all peers are connected
*
projects / oweals / gnunet.git / blobdiff