diff options
Diffstat (limited to 'src/chat/test_chat.c')
-rw-r--r-- | src/chat/test_chat.c | 630 |
1 files changed, 630 insertions, 0 deletions
diff --git a/src/chat/test_chat.c b/src/chat/test_chat.c new file mode 100644 index 000000000..8b96e6a58 --- /dev/null +++ b/src/chat/test_chat.c | |||
@@ -0,0 +1,630 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | (C) 2005, 2006, 2007, 2008, 2011 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 3, 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 | /** | ||
22 | * @file chat/test_chat.c | ||
23 | * @brief base test case for the chat library | ||
24 | * @author Christian Grothoff | ||
25 | * @author Nathan Evans | ||
26 | * @author Vitaly Minko | ||
27 | * | ||
28 | * This test case serves as a base for simple chatting, anonymous chatting, | ||
29 | * authenticated chatting and acknowledgements test cases. Based on the | ||
30 | * executable being run the correct test case will be performed. Private | ||
31 | * chatting is covered by a separate test case since it requires 3 users. | ||
32 | */ | ||
33 | |||
34 | #include "platform.h" | ||
35 | #include "gnunet_crypto_lib.h" | ||
36 | #include "gnunet_util_lib.h" | ||
37 | #include "gnunet_arm_service.h" | ||
38 | #include "gnunet_chat_service.h" | ||
39 | |||
40 | #define VERBOSE GNUNET_NO | ||
41 | |||
42 | #define START_ARM GNUNET_YES | ||
43 | |||
44 | /** | ||
45 | * How long until we give up on passing the test? | ||
46 | */ | ||
47 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60) | ||
48 | |||
49 | struct PeerContext | ||
50 | { | ||
51 | struct GNUNET_CONFIGURATION_Handle *cfg; | ||
52 | #if START_ARM | ||
53 | struct GNUNET_OS_Process *arm_proc; | ||
54 | #endif | ||
55 | }; | ||
56 | |||
57 | struct Wanted | ||
58 | { | ||
59 | struct GNUNET_CONTAINER_MetaData *meta; | ||
60 | |||
61 | GNUNET_HashCode *sender; | ||
62 | |||
63 | char *msg; | ||
64 | |||
65 | const char *me; | ||
66 | |||
67 | enum GNUNET_CHAT_MsgOptions opt; | ||
68 | |||
69 | uint32_t sequence_number; | ||
70 | |||
71 | struct GNUNET_TIME_Absolute timestamp; | ||
72 | |||
73 | GNUNET_SCHEDULER_Task next_task; | ||
74 | |||
75 | void *next_task_cls; | ||
76 | |||
77 | }; | ||
78 | |||
79 | static struct PeerContext p1; | ||
80 | |||
81 | static struct PeerContext p2; | ||
82 | |||
83 | static GNUNET_HashCode alice; | ||
84 | |||
85 | static GNUNET_HashCode bob; | ||
86 | |||
87 | static struct GNUNET_CHAT_Room *alice_room; | ||
88 | |||
89 | static struct GNUNET_CHAT_Room *bob_room; | ||
90 | |||
91 | static struct GNUNET_CONTAINER_MetaData *alice_meta; | ||
92 | |||
93 | static struct GNUNET_CONTAINER_MetaData *bob_meta; | ||
94 | |||
95 | static struct Wanted alice_wanted; | ||
96 | |||
97 | static struct Wanted bob_wanted; | ||
98 | |||
99 | static GNUNET_SCHEDULER_TaskIdentifier kill_task; | ||
100 | |||
101 | static GNUNET_SCHEDULER_TaskIdentifier wait_task; | ||
102 | |||
103 | static int err; | ||
104 | |||
105 | static int is_ready; | ||
106 | |||
107 | static int is_p2p; | ||
108 | |||
109 | static int is_ackn; | ||
110 | |||
111 | static int is_anon; | ||
112 | |||
113 | static int is_auth; | ||
114 | |||
115 | |||
116 | static void | ||
117 | setup_peer (struct PeerContext *p, const char *cfgname) | ||
118 | { | ||
119 | p->cfg = GNUNET_CONFIGURATION_create (); | ||
120 | #if START_ARM | ||
121 | p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm", | ||
122 | "gnunet-service-arm", | ||
123 | #if VERBOSE | ||
124 | "-L", "DEBUG", | ||
125 | #endif | ||
126 | "-c", cfgname, NULL); | ||
127 | #endif | ||
128 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); | ||
129 | } | ||
130 | |||
131 | |||
132 | static void | ||
133 | stop_arm (struct PeerContext *p) | ||
134 | { | ||
135 | #if START_ARM | ||
136 | if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM)) | ||
137 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | ||
138 | if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK) | ||
139 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); | ||
140 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
141 | "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc)); | ||
142 | GNUNET_OS_process_close (p->arm_proc); | ||
143 | p->arm_proc = NULL; | ||
144 | #endif | ||
145 | GNUNET_CONFIGURATION_destroy (p->cfg); | ||
146 | } | ||
147 | |||
148 | |||
149 | static void | ||
150 | abort_test (void *cls, | ||
151 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
152 | { | ||
153 | if (alice_room != NULL) | ||
154 | { | ||
155 | GNUNET_CHAT_leave_room (alice_room); | ||
156 | alice_room = NULL; | ||
157 | } | ||
158 | if (bob_room != NULL) | ||
159 | { | ||
160 | GNUNET_CHAT_leave_room (bob_room); | ||
161 | bob_room = NULL; | ||
162 | } | ||
163 | err = 1; | ||
164 | } | ||
165 | |||
166 | |||
167 | static void | ||
168 | timeout_kill (void *cls, | ||
169 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
170 | { | ||
171 | #if VERBOSE | ||
172 | printf ("Timed out, stopping the test.\n"); | ||
173 | #endif | ||
174 | kill_task = GNUNET_SCHEDULER_NO_TASK; | ||
175 | if (wait_task != GNUNET_SCHEDULER_NO_TASK) | ||
176 | { | ||
177 | GNUNET_SCHEDULER_cancel (wait_task); | ||
178 | wait_task = GNUNET_SCHEDULER_NO_TASK; | ||
179 | } | ||
180 | GNUNET_SCHEDULER_add_continuation (&abort_test, NULL, | ||
181 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
182 | } | ||
183 | |||
184 | |||
185 | static int | ||
186 | join_cb (void *cls) | ||
187 | { | ||
188 | struct Wanted *want = cls; | ||
189 | |||
190 | #if VERBOSE | ||
191 | printf ("%s has joined\n", want->me); | ||
192 | #endif | ||
193 | if (NULL != want->next_task) | ||
194 | GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls); | ||
195 | return GNUNET_OK; | ||
196 | } | ||
197 | |||
198 | |||
199 | static int | ||
200 | member_list_cb (void *cls, | ||
201 | const struct GNUNET_CONTAINER_MetaData *member_info, | ||
202 | const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *member_id, | ||
203 | enum GNUNET_CHAT_MsgOptions options) | ||
204 | { | ||
205 | struct Wanted *want = cls; | ||
206 | GNUNET_HashCode sender; | ||
207 | |||
208 | #if VERBOSE | ||
209 | printf ("%s - told that %s has %s\n", | ||
210 | want->me, | ||
211 | member_info == NULL ? NULL | ||
212 | : GNUNET_CONTAINER_meta_data_get_by_type (member_info, | ||
213 | EXTRACTOR_METATYPE_TITLE), | ||
214 | member_info == NULL ? "left" : "joined"); | ||
215 | #endif | ||
216 | GNUNET_CRYPTO_hash (member_id, | ||
217 | sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), | ||
218 | &sender); | ||
219 | if ((0 == memcmp (&sender, want->sender, | ||
220 | sizeof (GNUNET_HashCode))) && | ||
221 | (((member_info == NULL) && | ||
222 | (want->meta == NULL)) || | ||
223 | ((member_info != NULL) && | ||
224 | (want->meta != NULL) && | ||
225 | (GNUNET_CONTAINER_meta_data_test_equal (member_info, | ||
226 | want->meta)))) && | ||
227 | (options == want->opt)) | ||
228 | { | ||
229 | if (NULL != want->next_task) | ||
230 | GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls); | ||
231 | } | ||
232 | else | ||
233 | { | ||
234 | GNUNET_SCHEDULER_cancel (kill_task); | ||
235 | kill_task = GNUNET_SCHEDULER_NO_TASK; | ||
236 | GNUNET_SCHEDULER_add_now (&abort_test, NULL); | ||
237 | } | ||
238 | return GNUNET_OK; | ||
239 | } | ||
240 | |||
241 | |||
242 | static int | ||
243 | receive_cb (void *cls, | ||
244 | struct GNUNET_CHAT_Room *room, | ||
245 | const GNUNET_HashCode *sender, | ||
246 | const struct GNUNET_CONTAINER_MetaData *meta, | ||
247 | const char *message, | ||
248 | struct GNUNET_TIME_Absolute timestamp, | ||
249 | enum GNUNET_CHAT_MsgOptions options) | ||
250 | { | ||
251 | struct Wanted *want = cls; | ||
252 | |||
253 | #if VERBOSE | ||
254 | printf ("%s - told that %s said %s\n", | ||
255 | want->me, | ||
256 | meta == NULL ? NULL | ||
257 | : GNUNET_CONTAINER_meta_data_get_by_type (meta, | ||
258 | EXTRACTOR_METATYPE_TITLE), | ||
259 | message); | ||
260 | #endif | ||
261 | if ((0 == strcmp (message, want->msg)) && | ||
262 | (((sender == NULL) && (want->sender == NULL)) || | ||
263 | ((sender != NULL) && (want->sender != NULL) && | ||
264 | (0 == memcmp (sender, want->sender, | ||
265 | sizeof (GNUNET_HashCode))))) && | ||
266 | (GNUNET_CONTAINER_meta_data_test_equal (meta, want->meta)) && | ||
267 | (options == want->opt) && | ||
268 | /* Not == since the library sets the actual timestamp, so it may be | ||
269 | * slightly greater | ||
270 | */ | ||
271 | (timestamp.abs_value >= want->timestamp.abs_value)) | ||
272 | { | ||
273 | if (NULL != want->next_task) | ||
274 | GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls); | ||
275 | } | ||
276 | else | ||
277 | { | ||
278 | GNUNET_SCHEDULER_cancel (kill_task); | ||
279 | kill_task = GNUNET_SCHEDULER_NO_TASK; | ||
280 | GNUNET_SCHEDULER_add_now (&abort_test, NULL); | ||
281 | } | ||
282 | return GNUNET_OK; | ||
283 | } | ||
284 | |||
285 | |||
286 | static int | ||
287 | confirmation_cb (void *cls, | ||
288 | struct GNUNET_CHAT_Room *room, | ||
289 | uint32_t orig_seq_number, | ||
290 | struct GNUNET_TIME_Absolute timestamp, | ||
291 | const GNUNET_HashCode *receiver) | ||
292 | { | ||
293 | struct Wanted *want = cls; | ||
294 | |||
295 | #if VERBOSE | ||
296 | printf ("%s - told that %s acknowledged message #%d\n", | ||
297 | want->me, | ||
298 | GNUNET_CONTAINER_meta_data_get_by_type (want->meta, | ||
299 | EXTRACTOR_METATYPE_TITLE), | ||
300 | orig_seq_number); | ||
301 | #endif | ||
302 | if ((0 == memcmp (receiver, want->sender, | ||
303 | sizeof (GNUNET_HashCode))) && | ||
304 | (orig_seq_number == want->sequence_number) && | ||
305 | (timestamp.abs_value >= want->timestamp.abs_value)) | ||
306 | { | ||
307 | if (NULL != want->next_task) | ||
308 | GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls); | ||
309 | } | ||
310 | else | ||
311 | { | ||
312 | GNUNET_SCHEDULER_cancel (kill_task); | ||
313 | kill_task = GNUNET_SCHEDULER_NO_TASK; | ||
314 | GNUNET_SCHEDULER_add_now (&abort_test, NULL); | ||
315 | } | ||
316 | return GNUNET_OK; | ||
317 | } | ||
318 | |||
319 | |||
320 | static void | ||
321 | wait_until_ready (void *cls, | ||
322 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
323 | { | ||
324 | GNUNET_SCHEDULER_Task task = cls; | ||
325 | |||
326 | #if VERBOSE | ||
327 | printf ("Waiting...\n"); | ||
328 | #endif | ||
329 | if (is_ready) | ||
330 | { | ||
331 | wait_task = GNUNET_SCHEDULER_NO_TASK; | ||
332 | GNUNET_SCHEDULER_add_now (task, NULL); | ||
333 | } | ||
334 | else | ||
335 | wait_task = | ||
336 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, | ||
337 | 50), | ||
338 | &wait_until_ready, | ||
339 | task); | ||
340 | } | ||
341 | |||
342 | |||
343 | static void | ||
344 | disconnect_alice (void *cls, | ||
345 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
346 | { | ||
347 | #if VERBOSE | ||
348 | printf ("Alice is leaving.\n"); | ||
349 | #endif | ||
350 | if (is_p2p) | ||
351 | stop_arm (&p2); | ||
352 | GNUNET_CHAT_leave_room (alice_room); | ||
353 | alice_room = NULL; | ||
354 | GNUNET_SCHEDULER_cancel (kill_task); | ||
355 | kill_task = GNUNET_SCHEDULER_NO_TASK; | ||
356 | } | ||
357 | |||
358 | |||
359 | static void | ||
360 | disconnect_bob (void *cls, | ||
361 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
362 | { | ||
363 | #if VERBOSE | ||
364 | printf ("Bod is leaving.\n"); | ||
365 | #endif | ||
366 | alice_wanted.meta = NULL; | ||
367 | alice_wanted.sender = &bob; | ||
368 | alice_wanted.msg = NULL; | ||
369 | alice_wanted.opt = 0; | ||
370 | alice_wanted.next_task = &disconnect_alice; | ||
371 | alice_wanted.next_task_cls = NULL; | ||
372 | GNUNET_CHAT_leave_room (bob_room); | ||
373 | bob_room = NULL; | ||
374 | } | ||
375 | |||
376 | |||
377 | static void | ||
378 | set_ready (void *cls, | ||
379 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
380 | { | ||
381 | is_ready = GNUNET_YES; | ||
382 | } | ||
383 | |||
384 | |||
385 | static void | ||
386 | send_to_alice (void *cls, | ||
387 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
388 | { | ||
389 | #if VERBOSE | ||
390 | printf ("Bob says 'Hi!'\n"); | ||
391 | #endif | ||
392 | |||
393 | alice_wanted.meta = bob_meta; | ||
394 | alice_wanted.sender = &bob; | ||
395 | alice_wanted.msg = "Hi Alice!"; | ||
396 | alice_wanted.opt = GNUNET_CHAT_MSG_OPTION_NONE; | ||
397 | alice_wanted.timestamp = GNUNET_TIME_absolute_get (); | ||
398 | alice_wanted.next_task = &disconnect_bob; | ||
399 | alice_wanted.next_task_cls = NULL; | ||
400 | GNUNET_CHAT_send_message (bob_room, | ||
401 | "Hi Alice!", | ||
402 | GNUNET_CHAT_MSG_OPTION_NONE, | ||
403 | NULL, | ||
404 | NULL); | ||
405 | } | ||
406 | |||
407 | |||
408 | static void | ||
409 | send_to_bob (void *cls, | ||
410 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
411 | { | ||
412 | enum GNUNET_CHAT_MsgOptions options; | ||
413 | uint32_t *seq = NULL; | ||
414 | |||
415 | #if VERBOSE | ||
416 | printf ("Alice says 'Hi!'\n"); | ||
417 | #endif | ||
418 | if (is_ackn) | ||
419 | { | ||
420 | options = GNUNET_CHAT_MSG_ACKNOWLEDGED; | ||
421 | alice_wanted.meta = bob_meta; | ||
422 | alice_wanted.sender = &bob; | ||
423 | alice_wanted.timestamp = GNUNET_TIME_absolute_get (); | ||
424 | alice_wanted.next_task = &disconnect_bob; | ||
425 | alice_wanted.next_task_cls = NULL; | ||
426 | bob_wanted.meta = alice_meta; | ||
427 | bob_wanted.sender = &alice; | ||
428 | bob_wanted.next_task = NULL; | ||
429 | seq = &(alice_wanted.sequence_number); | ||
430 | } | ||
431 | else if (is_anon) | ||
432 | { | ||
433 | options = GNUNET_CHAT_MSG_ANONYMOUS; | ||
434 | bob_wanted.meta = NULL; | ||
435 | bob_wanted.sender = NULL; | ||
436 | bob_wanted.next_task = &disconnect_bob; | ||
437 | } | ||
438 | else if (is_auth) | ||
439 | { | ||
440 | options = GNUNET_CHAT_MSG_AUTHENTICATED; | ||
441 | bob_wanted.meta = alice_meta; | ||
442 | bob_wanted.sender = &alice; | ||
443 | bob_wanted.next_task = &disconnect_bob; | ||
444 | } | ||
445 | else | ||
446 | { | ||
447 | options = GNUNET_CHAT_MSG_OPTION_NONE; | ||
448 | bob_wanted.meta = alice_meta; | ||
449 | bob_wanted.sender = &alice; | ||
450 | bob_wanted.next_task = &send_to_alice; | ||
451 | } | ||
452 | bob_wanted.msg = "Hi Bob!"; | ||
453 | bob_wanted.opt = options; | ||
454 | bob_wanted.timestamp = GNUNET_TIME_absolute_get (); | ||
455 | bob_wanted.next_task_cls = NULL; | ||
456 | GNUNET_CHAT_send_message (alice_room, "Hi Bob!", options, NULL, seq); | ||
457 | } | ||
458 | |||
459 | |||
460 | static void | ||
461 | prepare_for_alice_task (void *cls, | ||
462 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
463 | { | ||
464 | bob_wanted.meta = alice_meta; | ||
465 | bob_wanted.sender = &alice; | ||
466 | bob_wanted.msg = NULL; | ||
467 | bob_wanted.opt = -1; | ||
468 | bob_wanted.next_task = &set_ready; | ||
469 | bob_wanted.next_task_cls = NULL; | ||
470 | } | ||
471 | |||
472 | |||
473 | static void | ||
474 | join_bob_task (void *cls, | ||
475 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
476 | { | ||
477 | #if VERBOSE | ||
478 | printf ("Bob joining\n"); | ||
479 | #endif | ||
480 | alice_wanted.meta = bob_meta; | ||
481 | alice_wanted.sender = &bob; | ||
482 | alice_wanted.msg = NULL; | ||
483 | alice_wanted.opt = -1; | ||
484 | alice_wanted.next_task = &wait_until_ready; | ||
485 | alice_wanted.next_task_cls = &send_to_bob; | ||
486 | bob_wanted.next_task = &prepare_for_alice_task; | ||
487 | bob_wanted.next_task_cls = NULL; | ||
488 | is_ready = GNUNET_NO; | ||
489 | bob_room = | ||
490 | GNUNET_CHAT_join_room (is_p2p ? p2.cfg : p1.cfg, "bob", bob_meta, | ||
491 | "test", -1, | ||
492 | &join_cb, &bob_wanted, | ||
493 | &receive_cb, &bob_wanted, | ||
494 | &member_list_cb, &bob_wanted, | ||
495 | &confirmation_cb, &bob_wanted, | ||
496 | &bob); | ||
497 | if (NULL == bob_room) | ||
498 | { | ||
499 | GNUNET_SCHEDULER_cancel (kill_task); | ||
500 | kill_task = GNUNET_SCHEDULER_NO_TASK; | ||
501 | GNUNET_CHAT_leave_room (alice_room); | ||
502 | alice_room = NULL; | ||
503 | err = 1; | ||
504 | } | ||
505 | } | ||
506 | |||
507 | |||
508 | static void | ||
509 | join_alice_task (void *cls, | ||
510 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
511 | { | ||
512 | #if VERBOSE | ||
513 | printf ("Alice joining\n"); | ||
514 | #endif | ||
515 | alice_wanted.next_task = &join_bob_task; | ||
516 | alice_wanted.next_task_cls = NULL; | ||
517 | alice_room = | ||
518 | GNUNET_CHAT_join_room (p1.cfg, "alice", alice_meta, | ||
519 | "test", -1, | ||
520 | &join_cb, &alice_wanted, | ||
521 | &receive_cb, &alice_wanted, | ||
522 | &member_list_cb, &alice_wanted, | ||
523 | &confirmation_cb, &alice_wanted, | ||
524 | &alice); | ||
525 | if (NULL == alice_room) | ||
526 | { | ||
527 | GNUNET_SCHEDULER_cancel (kill_task); | ||
528 | kill_task = GNUNET_SCHEDULER_NO_TASK; | ||
529 | err = 1; | ||
530 | } | ||
531 | } | ||
532 | |||
533 | |||
534 | static void | ||
535 | run (void *cls, | ||
536 | char *const *args, | ||
537 | const char *cfgfile, | ||
538 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
539 | { | ||
540 | if (is_p2p) | ||
541 | { | ||
542 | setup_peer (&p1, "test_chat_peer1.conf"); | ||
543 | setup_peer (&p2, "test_chat_peer2.conf"); | ||
544 | } | ||
545 | else | ||
546 | setup_peer (&p1, "test_chat_data.conf"); | ||
547 | |||
548 | memset (&alice_wanted, 0, sizeof (struct Wanted)); | ||
549 | memset (&bob_wanted, 0, sizeof (struct Wanted)); | ||
550 | alice_wanted.me = "Alice"; | ||
551 | bob_wanted.me = "Bob"; | ||
552 | alice_meta = GNUNET_CONTAINER_meta_data_create (); | ||
553 | GNUNET_CONTAINER_meta_data_insert (alice_meta, | ||
554 | "<gnunet>", | ||
555 | EXTRACTOR_METATYPE_TITLE, | ||
556 | EXTRACTOR_METAFORMAT_UTF8, | ||
557 | "text/plain", | ||
558 | "Alice", | ||
559 | strlen("Alice")+1); | ||
560 | bob_meta = GNUNET_CONTAINER_meta_data_create (); | ||
561 | GNUNET_CONTAINER_meta_data_insert (bob_meta, | ||
562 | "<gnunet>", | ||
563 | EXTRACTOR_METATYPE_TITLE, | ||
564 | EXTRACTOR_METAFORMAT_UTF8, | ||
565 | "text/plain", | ||
566 | "Bob", | ||
567 | strlen("Bob")+1); | ||
568 | kill_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, | ||
569 | &timeout_kill, | ||
570 | NULL); | ||
571 | GNUNET_SCHEDULER_add_now (&join_alice_task, NULL); | ||
572 | } | ||
573 | |||
574 | |||
575 | int | ||
576 | main (int argc, char *argv[]) | ||
577 | { | ||
578 | char *const argvx[] = { | ||
579 | "test-chat", | ||
580 | "-c", | ||
581 | "test_chat_data.conf", | ||
582 | #if VERBOSE | ||
583 | "-L", "DEBUG", | ||
584 | #endif | ||
585 | NULL | ||
586 | }; | ||
587 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
588 | GNUNET_GETOPT_OPTION_END | ||
589 | }; | ||
590 | |||
591 | GNUNET_log_setup ("test_chat", | ||
592 | #if VERBOSE | ||
593 | "DEBUG", | ||
594 | #else | ||
595 | "WARNING", | ||
596 | #endif | ||
597 | NULL); | ||
598 | if (strstr(argv[0], "p2p") != NULL) | ||
599 | { | ||
600 | is_p2p = GNUNET_YES; | ||
601 | } | ||
602 | if (strstr(argv[0], "acknowledgment") != NULL) | ||
603 | { | ||
604 | is_ackn = GNUNET_YES; | ||
605 | } | ||
606 | else if (strstr(argv[0], "anonymous") != NULL) | ||
607 | { | ||
608 | is_anon = GNUNET_YES; | ||
609 | } | ||
610 | else if (strstr(argv[0], "authentication") != NULL) | ||
611 | { | ||
612 | is_auth = GNUNET_YES; | ||
613 | } | ||
614 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, | ||
615 | argvx, "test-chat", | ||
616 | "nohelp", options, &run, NULL); | ||
617 | stop_arm (&p1); | ||
618 | GNUNET_CONTAINER_meta_data_destroy (alice_meta); | ||
619 | GNUNET_CONTAINER_meta_data_destroy (bob_meta); | ||
620 | if (is_p2p) | ||
621 | { | ||
622 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-1/"); | ||
623 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-2/"); | ||
624 | } | ||
625 | else | ||
626 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat/"); | ||
627 | return err; | ||
628 | } | ||
629 | |||
630 | /* end of test_chat.c */ | ||