src/chat/test_chat_private.c

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