/*
This file is part of GNUnet
- (C) 2004, 2009 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2004, 2009 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
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
* @file fragmentation/test_fragmentation.c
* @brief test for fragmentation.c
* @author Christian Grothoff
*/
-
-/**
- * Testcase for defragmentation code.
- * We have testcases for:
- * - 2 fragments, aligned, [0,16),[16,32)
- * - n (50) fragments, [i*16,(i+1)*16)
- * - n (50) fragments, [0,i*16) + [50*16,51*16)
- * - n (100) fragments, inserted in interleaved order (holes in sequence)
- * - holes in sequence
- * - other overlaps
- * - timeouts
- * - multiple entries in GNUNET_hash-list
- * - id collisions in GNUNET_hash-list
- */
-
#include "platform.h"
#include "gnunet_fragmentation_lib.h"
-#if 0
-
-/* -- to speed up the testcases -- */
-#define DEFRAGMENTATION_TIMEOUT (1 * GNUNET_CRON_SECONDS)
-
-
-static GNUNET_PeerIdentity mySender;
-static char *myMsg;
-static unsigned short myMsgLen;
-
-/* static buffers to avoid lots of malloc/free */
-static char masterBuffer[65536];
-static char resultBuffer[65536];
-
-static void
-handleHelper (const GNUNET_PeerIdentity * sender,
- const char *msg,
- const unsigned int len, int wasEncrypted, GNUNET_TSession * ts)
-{
- GNUNET_GE_ASSERT (NULL,
- 0 == memcmp (sender, &mySender,
- sizeof (GNUNET_PeerIdentity)));
- myMsg = resultBuffer;
- memcpy (resultBuffer, msg, len);
- myMsgLen = len;
-}
+#define DETAILS GNUNET_NO
/**
- * Wait long enough to force all fragments to timeout.
+ * Number of messages to transmit (note: each uses ~32k memory!)
*/
-static void
-makeTimeout ()
-{
- GNUNET_thread_sleep (DEFRAGMENTATION_TIMEOUT * 2);
- defragmentationPurgeCron (NULL);
-}
+#define NUM_MSGS 1000
/**
- * Create a fragment. The data-portion will be filled
- * with a sequence of numbers from start+id to start+len-1+id.
- *
- * @param pep pointer to the ethernet frame/buffer
- * @param ip pointer to the ip-header
- * @param start starting-offset
- * @param length of the data portion
- * @param id the identity of the fragment
+ * MTU to force on fragmentation (must be > 1k + 12)
*/
-static GNUNET_MessageHeader *
-makeFragment (unsigned short start,
- unsigned short size, unsigned short tot, int id)
-{
- P2P_fragmentation_MESSAGE *frag;
- int i;
-
- frag = (P2P_fragmentation_MESSAGE *) masterBuffer;
- frag->id = htonl (id);
- frag->off = htons (start);
- frag->len = htons (tot);
- frag->header.size = htons (sizeof (P2P_fragmentation_MESSAGE) + size);
-
- for (i = 0; i < size; i++)
- ((char *) &frag[1])[i] = (char) i + id + start;
- return &frag->header;
-}
+#define MTU 1111
/**
- * Check that the packet received is what we expected to
- * get.
- * @param id the expected id
- * @param len the expected length
+ * Simulate dropping of 1 out of how many messages? (must be > 1)
*/
-static void
-checkPacket (int id, unsigned int len)
-{
- int i;
-
- GNUNET_GE_ASSERT (NULL, myMsg != NULL);
- GNUNET_GE_ASSERT (NULL, myMsgLen == len);
- for (i = 0; i < len; i++)
- GNUNET_GE_ASSERT (NULL, myMsg[i] == (char) (i + id));
- myMsgLen = 0;
- myMsg = NULL;
-}
+#define DROPRATE 15
+static int ret = 1;
-/* **************** actual testcases ***************** */
+static unsigned int dups;
-static void
-testSimpleFragment ()
-{
- GNUNET_MessageHeader *pep;
-
- pep = makeFragment (0, 16, 32, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- pep = makeFragment (16, 16, 32, 42);
- processFragment (&mySender, pep);
- checkPacket (42, 32);
-}
+static unsigned int fragc;
-static void
-testSimpleFragmentTimeout ()
-{
- GNUNET_MessageHeader *pep;
-
- pep = makeFragment (0, 16, 32, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- makeTimeout ();
- pep = makeFragment (16, 16, 32, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- pep = makeFragment (0, 16, 32, 42);
- processFragment (&mySender, pep);
- checkPacket (42, 32);
-}
+static unsigned int frag_drops;
-static void
-testSimpleFragmentReverse ()
-{
- GNUNET_MessageHeader *pep;
-
- pep = makeFragment (16, 16, 32, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- pep = makeFragment (0, 16, 32, 42);
- processFragment (&mySender, pep);
- checkPacket (42, 32);
-}
+static unsigned int acks;
-static void
-testManyFragments ()
-{
- GNUNET_MessageHeader *pep;
- int i;
+static unsigned int ack_drops;
- for (i = 0; i < 50; i++)
- {
- pep = makeFragment (i * 16, 16, 51 * 16, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- pep = makeFragment (50 * 16, 16, 51 * 16, 42);
- processFragment (&mySender, pep);
- checkPacket (42, 51 * 16);
-}
+static struct GNUNET_DEFRAGMENT_Context *defrag;
-static void
-testManyFragmentsMegaLarge ()
-{
- GNUNET_MessageHeader *pep;
- int i;
+static struct GNUNET_BANDWIDTH_Tracker trackers[NUM_MSGS];
- for (i = 0; i < 4000; i++)
- {
- pep = makeFragment (i * 16, 16, 4001 * 16, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- pep = makeFragment (4000 * 16, 16, 4001 * 16, 42);
- processFragment (&mySender, pep);
- checkPacket (42, 4001 * 16);
-}
+static struct GNUNET_FRAGMENT_Context *frag;
-static void
-testLastFragmentEarly ()
-{
- GNUNET_MessageHeader *pep;
- int i;
+static struct GNUNET_SCHEDULER_Task * shutdown_task;
- for (i = 0; i < 5; i++)
- {
- pep = makeFragment (i * 16, 8, 6 * 16 + 8, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- pep = makeFragment (5 * 16, 24, 6 * 16 + 8, 42);
- processFragment (&mySender, pep);
- for (i = 0; i < 5; i++)
- {
- pep = makeFragment (i * 16 + 8, 8, 6 * 16 + 8, 42);
- processFragment (&mySender, pep);
- }
- checkPacket (42, 6 * 16 + 8);
-}
+static struct GNUNET_TIME_Relative msg_delay;
-static void
-testManyInterleavedFragments ()
-{
- GNUNET_MessageHeader *pep;
- int i;
+static struct GNUNET_TIME_Relative ack_delay;
- for (i = 0; i < 50; i++)
- {
- pep = makeFragment (i * 16, 8, 51 * 16 + 8, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- for (i = 0; i < 50; i++)
- {
- pep = makeFragment (i * 16 + 8, 8, 51 * 16 + 8, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- pep = makeFragment (50 * 16, 24, 51 * 16 + 8, 42);
- processFragment (&mySender, pep);
- checkPacket (42, 51 * 16 + 8);
-}
static void
-testManyInterleavedOverlappingFragments ()
+do_shutdown (void *cls)
{
- GNUNET_MessageHeader *pep;
- int i;
-
- for (i = 0; i < 50; i++)
- {
- pep = makeFragment (i * 32, 16, 51 * 32, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- for (i = 0; i < 50; i++)
- {
- pep = makeFragment (i * 32 + 8, 24, 51 * 32, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- pep = makeFragment (50 * 32, 32, 51 * 32, 42);
- processFragment (&mySender, pep);
- checkPacket (42, 51 * 32);
+ ret = 0;
+ shutdown_task = NULL;
+ GNUNET_DEFRAGMENT_context_destroy (defrag);
+ defrag = NULL;
+ if (NULL != frag)
+ {
+ GNUNET_FRAGMENT_context_destroy (frag, &msg_delay, &ack_delay);
+ frag = NULL;
+ }
+ fprintf (stderr,
+ "\nFinal message-delay: %s\n",
+ GNUNET_STRINGS_relative_time_to_string (msg_delay,
+ GNUNET_YES));
+ fprintf (stderr,
+ "Final ack-delay: %s\n",
+ GNUNET_STRINGS_relative_time_to_string (ack_delay,
+ GNUNET_YES));
}
+
static void
-testManyOverlappingFragments ()
+proc_msgs (void *cls, const struct GNUNET_MessageHeader *hdr)
{
- GNUNET_MessageHeader *pep;
- int i;
+ static unsigned int total;
+ unsigned int i;
+ const char *buf;
- for (i = 0; i < 50; i++)
- {
- pep = makeFragment (0, i * 16 + 16, 51 * 16, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- pep = makeFragment (50 * 16, 16, 51 * 16, 42);
- processFragment (&mySender, pep);
- checkPacket (42, 51 * 16);
+#if DETAILS
+ FPRINTF (stderr, "%s", "M! "); /* message complete, good! */
+#endif
+ buf = (const char *) hdr;
+ for (i = sizeof (struct GNUNET_MessageHeader); i < ntohs (hdr->size); i++)
+ GNUNET_assert (buf[i] == (char) i);
+ total++;
+#if ! DETAILS
+ if (0 == (total % (NUM_MSGS / 100)))
+ FPRINTF (stderr, "%s", ".");
+#endif
+ /* tolerate 10% loss, i.e. due to duplicate fragment IDs */
+ if ((total >= NUM_MSGS - (NUM_MSGS / 10)) && (ret != 0))
+ {
+ if (NULL == shutdown_task)
+ shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+ }
}
+
+/**
+ * Process fragment (by passing to defrag).
+ */
static void
-testManyOverlappingFragmentsTimeout ()
+proc_frac (void *cls, const struct GNUNET_MessageHeader *hdr)
{
- GNUNET_MessageHeader *pep;
- int i;
-
- for (i = 0; i < 50; i++)
- {
- pep = makeFragment (0, i * 16 + 16, 51 * 16 + 8, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- makeTimeout ();
- pep = makeFragment (50 * 16, 24, 51 * 16 + 8, 42);
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- for (i = 0; i < 50; i++)
- {
- pep = makeFragment (0, i * 16 + 16, 51 * 16 + 8, 42);
- processFragment (&mySender, pep);
- }
- checkPacket (42, 51 * 16 + 8);
+ struct GNUNET_FRAGMENT_Context **fc = cls;
+ int ret;
+
+ GNUNET_FRAGMENT_context_transmission_done (*fc);
+ if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
+ {
+ frag_drops++;
+#if DETAILS
+ FPRINTF (stderr, "%s", "DF "); /* dropped Frag */
+#endif
+ return; /* random drop */
+ }
+ if (NULL == defrag)
+ {
+ FPRINTF (stderr, "%s", "?E "); /* Error: frag after shutdown!? */
+ return;
+ }
+ ret = GNUNET_DEFRAGMENT_process_fragment (defrag, hdr);
+ if (ret == GNUNET_NO)
+ {
+#if DETAILS
+ FPRINTF (stderr, "%s", "FF "); /* duplicate fragment */
+#endif
+ dups++;
+ }
+ else if (ret == GNUNET_OK)
+ {
+#if DETAILS
+ FPRINTF (stderr, "%s", "F! "); /* good fragment */
+#endif
+ fragc++;
+ }
}
+
static void
-testManyFragmentsMultiId ()
+next_transmission ()
{
- GNUNET_MessageHeader *pep;
- int i;
- int id;
-
- for (i = 0; i < 50; i++)
- {
- for (id = 0; id < DEFRAG_BUCKET_COUNT; id++)
- {
- pep = makeFragment (i * 16, 16, 51 * 16, id + 5);
- mySender.hashPubKey.bits[0] = id;
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
- }
- for (id = 0; id < DEFRAG_BUCKET_COUNT; id++)
- {
- pep = makeFragment (50 * 16, 16, 51 * 16, id + 5);
- mySender.hashPubKey.bits[0] = id;
- processFragment (&mySender, pep);
- checkPacket (id + 5, 51 * 16);
- }
+ static unsigned int i;
+ struct GNUNET_MessageHeader *msg;
+ static char buf[MTU + 32 * 1024];
+ unsigned int j;
+
+ if (0 == i)
+ {
+ for (j = 0; j < sizeof (buf); j++)
+ buf[j] = (char) j;
+ }
+ else
+ {
+ GNUNET_FRAGMENT_context_destroy (frag,
+ &msg_delay,
+ &ack_delay);
+ frag = NULL;
+ }
+ if (i == NUM_MSGS)
+ return;
+#if DETAILS
+ FPRINTF (stderr, "%s", "T! "); /* sending message */
+#endif
+ msg = (struct GNUNET_MessageHeader *) buf;
+ msg->type = htons ((uint16_t) i);
+ msg->size =
+ htons (sizeof (struct GNUNET_MessageHeader) + (17 * i) % (32 * 1024));
+ frag = GNUNET_FRAGMENT_context_create (NULL /* no stats */ ,
+ MTU, &trackers[i],
+ msg_delay,
+ ack_delay,
+ msg,
+ &proc_frac, &frag);
+ i++;
}
+
+/**
+ * Process ACK (by passing to fragmenter)
+ */
static void
-testManyFragmentsMultiIdCollisions ()
+proc_acks (void *cls,
+ uint32_t msg_id,
+ const struct GNUNET_MessageHeader *hdr)
{
- GNUNET_MessageHeader *pep;
- int i;
- int id;
-
- for (i = 0; i < 5; i++)
+ unsigned int i;
+ int ret;
+
+ if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
+ {
+ ack_drops++;
+#if DETAILS
+ FPRINTF (stderr, "%s", "DA "); /* dropped ACK */
+#endif
+ return; /* random drop */
+ }
+ for (i = 0; i < NUM_MSGS; i++)
+ {
+ if (NULL == frag)
+ continue;
+ ret = GNUNET_FRAGMENT_process_ack (frag, hdr);
+ if (ret == GNUNET_OK)
{
- for (id = 0; id < DEFRAG_BUCKET_COUNT * 4; id++)
- {
- pep = makeFragment (i * 16, 16, 6 * 16, id + 5);
- mySender.hashPubKey.bits[0] = id;
- processFragment (&mySender, pep);
- GNUNET_GE_ASSERT (NULL, myMsg == NULL);
- }
+#if DETAILS
+ FPRINTF (stderr, "%s", "GA "); /* good ACK */
+#endif
+ next_transmission ();
+ acks++;
+ return;
}
- for (id = 0; id < DEFRAG_BUCKET_COUNT * 4; id++)
+ if (ret == GNUNET_NO)
{
- pep = makeFragment (5 * 16, 16, 6 * 16, id + 5);
- mySender.hashPubKey.bits[0] = id;
- processFragment (&mySender, pep);
- checkPacket (id + 5, 6 * 16);
+#if DETAILS
+ FPRINTF (stderr, "%s", "AA "); /* duplciate ACK */
+#endif
+ acks++;
+ return;
}
-}
-
-/* ************* driver ****************** */
-
-static int
-p2p_register_handler (const unsigned short type,
- GNUNET_P2PRequestHandler callback)
-{
- return GNUNET_OK;
-}
-
-static int
-p2p_unregister_handler (const unsigned short type,
- GNUNET_P2PRequestHandler callback)
-{
- return GNUNET_OK;
+ }
+#if DETAILS
+ FPRINTF (stderr, "%s", "?A "); /* BAD: ack that nobody feels responsible for... */
+#endif
}
-static void *
-request_service (const char *name)
+/**
+ * Main function run with scheduler.
+ */
+static void
+run (void *cls,
+ char *const *args,
+ const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- return NULL;
+ defrag = GNUNET_DEFRAGMENT_context_create (NULL, MTU,
+ 3,
+ NULL,
+ &proc_msgs,
+ &proc_acks);
+ next_transmission ();
}
-#endif
int
main (int argc, char *argv[])
{
- fprintf (stderr, "WARNING: testcase not yet ported to new API.\n");
-#if 0
- GNUNET_CoreAPIForPlugins capi;
-
- memset (&capi, 0, sizeof (GNUNET_CoreAPIForPlugins));
- capi.cron = GNUNET_cron_create (NULL);
- capi.loopback_send = &handleHelper;
- capi.service_request = &request_service;
- capi.p2p_ciphertext_handler_register = &p2p_register_handler;
- capi.p2p_ciphertext_handler_unregister = &p2p_unregister_handler;
- provide_module_fragmentation (&capi);
-
- fprintf (stderr, ".");
- testSimpleFragment ();
- fprintf (stderr, ".");
- testSimpleFragmentTimeout ();
- fprintf (stderr, ".");
- testSimpleFragmentReverse ();
- fprintf (stderr, ".");
- testManyFragments ();
- fprintf (stderr, ".");
- testManyFragmentsMegaLarge ();
- fprintf (stderr, ".");
- testManyFragmentsMultiId ();
- fprintf (stderr, ".");
-
- testManyInterleavedFragments ();
- fprintf (stderr, ".");
- testManyInterleavedOverlappingFragments ();
- fprintf (stderr, ".");
- testManyOverlappingFragments ();
- fprintf (stderr, ".");
- testManyOverlappingFragmentsTimeout ();
- fprintf (stderr, ".");
- testLastFragmentEarly ();
- fprintf (stderr, ".");
- testManyFragmentsMultiIdCollisions ();
- fprintf (stderr, ".");
- release_module_fragmentation ();
- fprintf (stderr, "\n");
- GNUNET_cron_destroy (capi.cron);
-#endif
- return 0; /* testcase passed */
+ struct GNUNET_GETOPT_CommandLineOption options[] = {
+ GNUNET_GETOPT_OPTION_END
+ };
+ char *const argv_prog[] = {
+ "test-fragmentation",
+ "-c",
+ "test_fragmentation_data.conf",
+ "-L",
+ "WARNING",
+ NULL
+ };
+ unsigned int i;
+
+ msg_delay = GNUNET_TIME_UNIT_MILLISECONDS;
+ ack_delay = GNUNET_TIME_UNIT_SECONDS;
+ GNUNET_log_setup ("test-fragmentation",
+ "WARNING",
+ NULL);
+ for (i = 0; i < NUM_MSGS; i++)
+ GNUNET_BANDWIDTH_tracker_init (&trackers[i], NULL, NULL,
+ GNUNET_BANDWIDTH_value_init ((i + 1) * 1024),
+ 100);
+ GNUNET_PROGRAM_run (5,
+ argv_prog,
+ "test-fragmentation", "nohelp",
+ options,
+ &run, NULL);
+ FPRINTF (stderr,
+ "\nHad %u good fragments, %u duplicate fragments, %u acks and %u simulated drops of acks\n",
+ fragc,
+ dups,
+ acks,
+ ack_drops);
+ return ret;
}