aboutsummaryrefslogtreecommitdiff
path: root/src/fragmentation/test_fragmentation.c
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2009-05-29 00:46:26 +0000
committerChristian Grothoff <christian@grothoff.org>2009-05-29 00:46:26 +0000
commit0a217a8df1657b4334b55b0e4a6c7837a8dbcfd9 (patch)
tree6b552f40eb089db96409a312a98d9b12bd669102 /src/fragmentation/test_fragmentation.c
downloadgnunet-0a217a8df1657b4334b55b0e4a6c7837a8dbcfd9.tar.gz
gnunet-0a217a8df1657b4334b55b0e4a6c7837a8dbcfd9.zip
ng
Diffstat (limited to 'src/fragmentation/test_fragmentation.c')
-rw-r--r--src/fragmentation/test_fragmentation.c439
1 files changed, 439 insertions, 0 deletions
diff --git a/src/fragmentation/test_fragmentation.c b/src/fragmentation/test_fragmentation.c
new file mode 100644
index 000000000..e6e3e5d22
--- /dev/null
+++ b/src/fragmentation/test_fragmentation.c
@@ -0,0 +1,439 @@
1/*
2 This file is part of GNUnet
3 (C) 2004, 2009 Christian Grothoff (and other contributing authors)
4
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 2, or (at your
8 option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
19*/
20/**
21 * @file fragmentation/test_fragmentation.c
22 * @brief test for fragmentation.c
23 * @author Christian Grothoff
24 */
25
26/**
27 * Testcase for defragmentation code.
28 * We have testcases for:
29 * - 2 fragments, aligned, [0,16),[16,32)
30 * - n (50) fragments, [i*16,(i+1)*16)
31 * - n (50) fragments, [0,i*16) + [50*16,51*16)
32 * - n (100) fragments, inserted in interleaved order (holes in sequence)
33 * - holes in sequence
34 * - other overlaps
35 * - timeouts
36 * - multiple entries in GNUNET_hash-list
37 * - id collisions in GNUNET_hash-list
38 */
39
40#include "platform.h"
41#include "gnunet_fragmentation_lib.h"
42
43#if 0
44
45/* -- to speed up the testcases -- */
46#define DEFRAGMENTATION_TIMEOUT (1 * GNUNET_CRON_SECONDS)
47
48
49static GNUNET_PeerIdentity mySender;
50static char *myMsg;
51static unsigned short myMsgLen;
52
53/* static buffers to avoid lots of malloc/free */
54static char masterBuffer[65536];
55static char resultBuffer[65536];
56
57static void
58handleHelper (const GNUNET_PeerIdentity * sender,
59 const char *msg,
60 const unsigned int len, int wasEncrypted, GNUNET_TSession * ts)
61{
62 GNUNET_GE_ASSERT (NULL,
63 0 == memcmp (sender, &mySender,
64 sizeof (GNUNET_PeerIdentity)));
65 myMsg = resultBuffer;
66 memcpy (resultBuffer, msg, len);
67 myMsgLen = len;
68}
69
70/**
71 * Wait long enough to force all fragments to timeout.
72 */
73static void
74makeTimeout ()
75{
76 GNUNET_thread_sleep (DEFRAGMENTATION_TIMEOUT * 2);
77 defragmentationPurgeCron (NULL);
78}
79
80/**
81 * Create a fragment. The data-portion will be filled
82 * with a sequence of numbers from start+id to start+len-1+id.
83 *
84 * @param pep pointer to the ethernet frame/buffer
85 * @param ip pointer to the ip-header
86 * @param start starting-offset
87 * @param length of the data portion
88 * @param id the identity of the fragment
89 */
90static GNUNET_MessageHeader *
91makeFragment (unsigned short start,
92 unsigned short size, unsigned short tot, int id)
93{
94 P2P_fragmentation_MESSAGE *frag;
95 int i;
96
97 frag = (P2P_fragmentation_MESSAGE *) masterBuffer;
98 frag->id = htonl (id);
99 frag->off = htons (start);
100 frag->len = htons (tot);
101 frag->header.size = htons (sizeof (P2P_fragmentation_MESSAGE) + size);
102
103 for (i = 0; i < size; i++)
104 ((char *) &frag[1])[i] = (char) i + id + start;
105 return &frag->header;
106}
107
108/**
109 * Check that the packet received is what we expected to
110 * get.
111 * @param id the expected id
112 * @param len the expected length
113 */
114static void
115checkPacket (int id, unsigned int len)
116{
117 int i;
118
119 GNUNET_GE_ASSERT (NULL, myMsg != NULL);
120 GNUNET_GE_ASSERT (NULL, myMsgLen == len);
121 for (i = 0; i < len; i++)
122 GNUNET_GE_ASSERT (NULL, myMsg[i] == (char) (i + id));
123 myMsgLen = 0;
124 myMsg = NULL;
125}
126
127
128/* **************** actual testcases ***************** */
129
130static void
131testSimpleFragment ()
132{
133 GNUNET_MessageHeader *pep;
134
135 pep = makeFragment (0, 16, 32, 42);
136 processFragment (&mySender, pep);
137 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
138 pep = makeFragment (16, 16, 32, 42);
139 processFragment (&mySender, pep);
140 checkPacket (42, 32);
141}
142
143static void
144testSimpleFragmentTimeout ()
145{
146 GNUNET_MessageHeader *pep;
147
148 pep = makeFragment (0, 16, 32, 42);
149 processFragment (&mySender, pep);
150 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
151 makeTimeout ();
152 pep = makeFragment (16, 16, 32, 42);
153 processFragment (&mySender, pep);
154 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
155 pep = makeFragment (0, 16, 32, 42);
156 processFragment (&mySender, pep);
157 checkPacket (42, 32);
158}
159
160static void
161testSimpleFragmentReverse ()
162{
163 GNUNET_MessageHeader *pep;
164
165 pep = makeFragment (16, 16, 32, 42);
166 processFragment (&mySender, pep);
167 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
168 pep = makeFragment (0, 16, 32, 42);
169 processFragment (&mySender, pep);
170 checkPacket (42, 32);
171}
172
173static void
174testManyFragments ()
175{
176 GNUNET_MessageHeader *pep;
177 int i;
178
179 for (i = 0; i < 50; i++)
180 {
181 pep = makeFragment (i * 16, 16, 51 * 16, 42);
182 processFragment (&mySender, pep);
183 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
184 }
185 pep = makeFragment (50 * 16, 16, 51 * 16, 42);
186 processFragment (&mySender, pep);
187 checkPacket (42, 51 * 16);
188}
189
190static void
191testManyFragmentsMegaLarge ()
192{
193 GNUNET_MessageHeader *pep;
194 int i;
195
196 for (i = 0; i < 4000; i++)
197 {
198 pep = makeFragment (i * 16, 16, 4001 * 16, 42);
199 processFragment (&mySender, pep);
200 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
201 }
202 pep = makeFragment (4000 * 16, 16, 4001 * 16, 42);
203 processFragment (&mySender, pep);
204 checkPacket (42, 4001 * 16);
205}
206
207static void
208testLastFragmentEarly ()
209{
210 GNUNET_MessageHeader *pep;
211 int i;
212
213 for (i = 0; i < 5; i++)
214 {
215 pep = makeFragment (i * 16, 8, 6 * 16 + 8, 42);
216 processFragment (&mySender, pep);
217 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
218 }
219 pep = makeFragment (5 * 16, 24, 6 * 16 + 8, 42);
220 processFragment (&mySender, pep);
221 for (i = 0; i < 5; i++)
222 {
223 pep = makeFragment (i * 16 + 8, 8, 6 * 16 + 8, 42);
224 processFragment (&mySender, pep);
225 }
226 checkPacket (42, 6 * 16 + 8);
227}
228
229static void
230testManyInterleavedFragments ()
231{
232 GNUNET_MessageHeader *pep;
233 int i;
234
235 for (i = 0; i < 50; i++)
236 {
237 pep = makeFragment (i * 16, 8, 51 * 16 + 8, 42);
238 processFragment (&mySender, pep);
239 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
240 }
241 for (i = 0; i < 50; i++)
242 {
243 pep = makeFragment (i * 16 + 8, 8, 51 * 16 + 8, 42);
244 processFragment (&mySender, pep);
245 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
246 }
247 pep = makeFragment (50 * 16, 24, 51 * 16 + 8, 42);
248 processFragment (&mySender, pep);
249 checkPacket (42, 51 * 16 + 8);
250}
251
252static void
253testManyInterleavedOverlappingFragments ()
254{
255 GNUNET_MessageHeader *pep;
256 int i;
257
258 for (i = 0; i < 50; i++)
259 {
260 pep = makeFragment (i * 32, 16, 51 * 32, 42);
261 processFragment (&mySender, pep);
262 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
263 }
264 for (i = 0; i < 50; i++)
265 {
266 pep = makeFragment (i * 32 + 8, 24, 51 * 32, 42);
267 processFragment (&mySender, pep);
268 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
269 }
270 pep = makeFragment (50 * 32, 32, 51 * 32, 42);
271 processFragment (&mySender, pep);
272 checkPacket (42, 51 * 32);
273}
274
275static void
276testManyOverlappingFragments ()
277{
278 GNUNET_MessageHeader *pep;
279 int i;
280
281 for (i = 0; i < 50; i++)
282 {
283 pep = makeFragment (0, i * 16 + 16, 51 * 16, 42);
284 processFragment (&mySender, pep);
285 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
286 }
287 pep = makeFragment (50 * 16, 16, 51 * 16, 42);
288 processFragment (&mySender, pep);
289 checkPacket (42, 51 * 16);
290}
291
292static void
293testManyOverlappingFragmentsTimeout ()
294{
295 GNUNET_MessageHeader *pep;
296 int i;
297
298 for (i = 0; i < 50; i++)
299 {
300 pep = makeFragment (0, i * 16 + 16, 51 * 16 + 8, 42);
301 processFragment (&mySender, pep);
302 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
303 }
304 makeTimeout ();
305 pep = makeFragment (50 * 16, 24, 51 * 16 + 8, 42);
306 processFragment (&mySender, pep);
307 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
308 for (i = 0; i < 50; i++)
309 {
310 pep = makeFragment (0, i * 16 + 16, 51 * 16 + 8, 42);
311 processFragment (&mySender, pep);
312 }
313 checkPacket (42, 51 * 16 + 8);
314}
315
316static void
317testManyFragmentsMultiId ()
318{
319 GNUNET_MessageHeader *pep;
320 int i;
321 int id;
322
323 for (i = 0; i < 50; i++)
324 {
325 for (id = 0; id < DEFRAG_BUCKET_COUNT; id++)
326 {
327 pep = makeFragment (i * 16, 16, 51 * 16, id + 5);
328 mySender.hashPubKey.bits[0] = id;
329 processFragment (&mySender, pep);
330 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
331 }
332 }
333 for (id = 0; id < DEFRAG_BUCKET_COUNT; id++)
334 {
335 pep = makeFragment (50 * 16, 16, 51 * 16, id + 5);
336 mySender.hashPubKey.bits[0] = id;
337 processFragment (&mySender, pep);
338 checkPacket (id + 5, 51 * 16);
339 }
340}
341
342static void
343testManyFragmentsMultiIdCollisions ()
344{
345 GNUNET_MessageHeader *pep;
346 int i;
347 int id;
348
349 for (i = 0; i < 5; i++)
350 {
351 for (id = 0; id < DEFRAG_BUCKET_COUNT * 4; id++)
352 {
353 pep = makeFragment (i * 16, 16, 6 * 16, id + 5);
354 mySender.hashPubKey.bits[0] = id;
355 processFragment (&mySender, pep);
356 GNUNET_GE_ASSERT (NULL, myMsg == NULL);
357 }
358 }
359 for (id = 0; id < DEFRAG_BUCKET_COUNT * 4; id++)
360 {
361 pep = makeFragment (5 * 16, 16, 6 * 16, id + 5);
362 mySender.hashPubKey.bits[0] = id;
363 processFragment (&mySender, pep);
364 checkPacket (id + 5, 6 * 16);
365 }
366}
367
368/* ************* driver ****************** */
369
370static int
371p2p_register_handler (const unsigned short type,
372 GNUNET_P2PRequestHandler callback)
373{
374 return GNUNET_OK;
375}
376
377static int
378p2p_unregister_handler (const unsigned short type,
379 GNUNET_P2PRequestHandler callback)
380{
381 return GNUNET_OK;
382}
383
384
385static void *
386request_service (const char *name)
387{
388 return NULL;
389}
390
391#endif
392
393int
394main (int argc, char *argv[])
395{
396 fprintf (stderr, "WARNING: testcase not yet ported to new API.\n");
397#if 0
398 GNUNET_CoreAPIForPlugins capi;
399
400 memset (&capi, 0, sizeof (GNUNET_CoreAPIForPlugins));
401 capi.cron = GNUNET_cron_create (NULL);
402 capi.loopback_send = &handleHelper;
403 capi.service_request = &request_service;
404 capi.p2p_ciphertext_handler_register = &p2p_register_handler;
405 capi.p2p_ciphertext_handler_unregister = &p2p_unregister_handler;
406 provide_module_fragmentation (&capi);
407
408 fprintf (stderr, ".");
409 testSimpleFragment ();
410 fprintf (stderr, ".");
411 testSimpleFragmentTimeout ();
412 fprintf (stderr, ".");
413 testSimpleFragmentReverse ();
414 fprintf (stderr, ".");
415 testManyFragments ();
416 fprintf (stderr, ".");
417 testManyFragmentsMegaLarge ();
418 fprintf (stderr, ".");
419 testManyFragmentsMultiId ();
420 fprintf (stderr, ".");
421
422 testManyInterleavedFragments ();
423 fprintf (stderr, ".");
424 testManyInterleavedOverlappingFragments ();
425 fprintf (stderr, ".");
426 testManyOverlappingFragments ();
427 fprintf (stderr, ".");
428 testManyOverlappingFragmentsTimeout ();
429 fprintf (stderr, ".");
430 testLastFragmentEarly ();
431 fprintf (stderr, ".");
432 testManyFragmentsMultiIdCollisions ();
433 fprintf (stderr, ".");
434 release_module_fragmentation ();
435 fprintf (stderr, "\n");
436 GNUNET_cron_destroy (capi.cron);
437#endif
438 return 0; /* testcase passed */
439}