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 =
 136       GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
 137                                "gnunet-service-arm",
 138 #if VERBOSE
 139                                "-L", "DEBUG",
 140 #endif
 141                                "-c", cfgname, NULL);
 142 #endif
 143   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 144 }
 145
 146
 147 static void
 148 stop_arm (struct PeerContext *p)
 149 {
 150 #if START_ARM
 151   if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
 152     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
 153   if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
 154     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
 155   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM process %u stopped\n",
 156               GNUNET_OS_process_get_pid (p->arm_proc));
 157   GNUNET_OS_process_close (p->arm_proc);
 158   p->arm_proc = NULL;
 159 #endif
 160   GNUNET_CONFIGURATION_destroy (p->cfg);
 161 }
 162
 163
 164 static void
 165 abort_test (void *cls, 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, const struct GNUNET_SCHEDULER_TaskContext *tc)
 188 {
 189 #if VERBOSE
 190   printf ("Timed out, stopping the test.\n");
 191 #endif
 192   kill_task = GNUNET_SCHEDULER_NO_TASK;
 193   if (wait_task != GNUNET_SCHEDULER_NO_TASK)
 194   {
 195     GNUNET_SCHEDULER_cancel (wait_task);
 196     wait_task = GNUNET_SCHEDULER_NO_TASK;
 197   }
 198   GNUNET_SCHEDULER_add_continuation (&abort_test, NULL,
 199                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 200 }
 201
 202
 203 static int
 204 join_cb (void *cls)
 205 {
 206   struct Wanted *want = cls;
 207
 208 #if VERBOSE
 209   printf ("%s has joined\n", want->me);
 210 #endif
 211   if (NULL != want->next_task)
 212     GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls);
 213   return GNUNET_OK;
 214 }
 215
 216
 217 static int
 218 member_list_cb (void *cls, const struct GNUNET_CONTAINER_MetaData *member_info,
 219                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *member_id,
 220                 enum GNUNET_CHAT_MsgOptions options)
 221 {
 222   struct Wanted *want = cls;
 223   GNUNET_HashCode sender;
 224
 225 #if VERBOSE
 226   printf ("%s - told that %s has %s\n", want->me,
 227           member_info ==
 228           NULL ? NULL : GNUNET_CONTAINER_meta_data_get_by_type (member_info,
 229                                                                 EXTRACTOR_METATYPE_TITLE),
 230           member_info == NULL ? "left" : "joined");
 231 #endif
 232   GNUNET_CRYPTO_hash (member_id,
 233                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
 234                       &sender);
 235   /* entertain both primary and an alternative sender/meta */
 236   if (((0 == memcmp (&sender, want->sender, sizeof (GNUNET_HashCode))) ||
 237        ((want->sender2 != NULL) &&
 238         (0 == memcmp (&sender, want->sender2, sizeof (GNUNET_HashCode))))) &&
 239       (((member_info == NULL) && (want->meta == NULL)) ||
 240        ((member_info != NULL) &&
 241         (((want->meta != NULL) &&
 242           GNUNET_CONTAINER_meta_data_test_equal (member_info, want->meta)) ||
 243          ((want->meta2 != NULL) &&
 244           GNUNET_CONTAINER_meta_data_test_equal (member_info, want->meta2)))))
 245       && (options == want->opt))
 246   {
 247     /* remember Bob's public key, we need it to send private message */
 248     if (NULL == bob_public_key &&
 249         (0 == memcmp (&bob, want->sender, sizeof (GNUNET_HashCode))))
 250       bob_public_key =
 251           GNUNET_memdup (member_id,
 252                          sizeof (struct
 253                                  GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
 254     if (want->sender2 != NULL)
 255     {
 256       /* flush alternative sender */
 257       if (0 == memcmp (&sender, want->sender, sizeof (GNUNET_HashCode)))
 258       {
 259         want->sender = want->sender2;
 260         want->meta = want->meta2;
 261       }
 262       want->sender2 = NULL;
 263       want->meta2 = NULL;
 264     }
 265     else if (NULL != want->next_task)
 266       GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls);
 267   }
 268   else
 269   {
 270     GNUNET_SCHEDULER_cancel (kill_task);
 271     kill_task = GNUNET_SCHEDULER_NO_TASK;
 272     GNUNET_SCHEDULER_add_now (&abort_test, NULL);
 273   }
 274   return GNUNET_OK;
 275 }
 276
 277
 278 static int
 279 receive_cb (void *cls, struct GNUNET_CHAT_Room *room,
 280             const GNUNET_HashCode * sender,
 281             const struct GNUNET_CONTAINER_MetaData *meta, const char *message,
 282             struct GNUNET_TIME_Absolute timestamp,
 283             enum GNUNET_CHAT_MsgOptions options)
 284 {
 285   struct Wanted *want = cls;
 286
 287 #if VERBOSE
 288   printf ("%s - told that %s said '%s'\n", want->me,
 289           meta == NULL ? NULL : GNUNET_CONTAINER_meta_data_get_by_type (meta,
 290                                                                         EXTRACTOR_METATYPE_TITLE),
 291           message);
 292 #endif
 293
 294   if ((want->msg != NULL) && (0 == strcmp (message, want->msg)) &&
 295       (((sender == NULL) && (want->sender == NULL)) ||
 296        ((sender != NULL) && (want->sender != NULL) &&
 297         (0 == memcmp (sender, want->sender, sizeof (GNUNET_HashCode))))) &&
 298       (GNUNET_CONTAINER_meta_data_test_equal (meta, want->meta)) &&
 299       (options == want->opt) &&
 300       /* Not == since the library sets the actual timestamp, so it may be
 301        * slightly greater
 302        */
 303       (timestamp.abs_value >= want->timestamp.abs_value))
 304   {
 305     if (NULL != want->next_task)
 306       GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls);
 307   }
 308   else
 309   {
 310     GNUNET_SCHEDULER_cancel (kill_task);
 311     kill_task = GNUNET_SCHEDULER_NO_TASK;
 312     GNUNET_SCHEDULER_cancel (finish_task);
 313     finish_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_all_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 322 {
 323   GNUNET_SCHEDULER_Task task = cls;
 324
 325 #if VERBOSE
 326   printf ("Waiting...\n");
 327 #endif
 328   if (alice_ready && bob_ready)
 329   {
 330     wait_task = GNUNET_SCHEDULER_NO_TASK;
 331     GNUNET_SCHEDULER_add_now (task, NULL);
 332   }
 333   else
 334     wait_task =
 335         GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 336                                       (GNUNET_TIME_UNIT_MILLISECONDS, 5000),
 337                                       &wait_until_all_ready, task);
 338 }
 339
 340
 341 static void
 342 set_alice_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 343 {
 344   alice_ready = GNUNET_YES;
 345 }
 346
 347
 348 static void
 349 set_bob_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 350 {
 351   bob_ready = GNUNET_YES;
 352 }
 353
 354
 355 static void
 356 disconnect_alice (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 357 {
 358 #if VERBOSE
 359   printf ("Alice is leaving.\n");
 360 #endif
 361   if (is_p2p)
 362     stop_arm (&p2);
 363   GNUNET_CHAT_leave_room (alice_room);
 364   alice_room = NULL;
 365   GNUNET_SCHEDULER_cancel (kill_task);
 366   kill_task = GNUNET_SCHEDULER_NO_TASK;
 367 }
 368
 369
 370 static void
 371 disconnect_bob (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 372 {
 373 #if VERBOSE
 374   printf ("Bod is leaving.\n");
 375 #endif
 376   if (is_p2p)
 377     stop_arm (&p3);
 378   alice_wanted.meta = NULL;
 379   alice_wanted.sender = &bob;
 380   alice_wanted.msg = NULL;
 381   alice_wanted.opt = 0;
 382   alice_wanted.next_task = &disconnect_alice;
 383   alice_wanted.next_task_cls = NULL;
 384   GNUNET_CHAT_leave_room (bob_room);
 385   bob_room = NULL;
 386 }
 387
 388
 389 static void
 390 disconnect_carol (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 391 {
 392 #if VERBOSE
 393   printf ("Carol is leaving.\n");
 394 #endif
 395   alice_wanted.meta = NULL;
 396   alice_wanted.sender = &carol;
 397   alice_wanted.msg = NULL;
 398   alice_wanted.opt = 0;
 399   alice_wanted.next_task = &set_alice_ready;
 400   alice_wanted.next_task_cls = NULL;
 401   alice_ready = GNUNET_NO;
 402   bob_wanted.meta = NULL;
 403   bob_wanted.sender = &carol;
 404   bob_wanted.msg = NULL;
 405   bob_wanted.opt = 0;
 406   bob_wanted.next_task = &wait_until_all_ready;
 407   bob_wanted.next_task_cls = &disconnect_bob;
 408   bob_ready = GNUNET_YES;
 409   GNUNET_CHAT_leave_room (carol_room);
 410   carol_room = NULL;
 411 }
 412
 413
 414 static void
 415 send_from_alice_to_bob (void *cls,
 416                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 417 {
 418   uint32_t seq;
 419
 420 #if VERBOSE
 421   printf ("Alice says 'Hi!' to Bob\n");
 422 #endif
 423   alice_ready = GNUNET_YES;
 424   bob_ready = GNUNET_NO;
 425   bob_wanted.meta = alice_meta;
 426   bob_wanted.sender = &alice;
 427   bob_wanted.msg = "Hi Bob!";
 428   bob_wanted.opt = GNUNET_CHAT_MSG_PRIVATE;
 429   bob_wanted.next_task = &set_bob_ready;
 430   bob_wanted.next_task_cls = NULL;
 431   /* Carol should not receive this message */
 432   carol_wanted.meta = NULL;
 433   carol_wanted.sender = NULL;
 434   carol_wanted.msg = NULL;
 435   carol_wanted.opt = 0;
 436   carol_wanted.next_task = NULL;
 437   carol_wanted.next_task_cls = NULL;
 438   GNUNET_CHAT_send_message (alice_room, "Hi Bob!", GNUNET_CHAT_MSG_PRIVATE,
 439                             bob_public_key, &seq);
 440   finish_task =
 441       GNUNET_SCHEDULER_add_delayed (PM_TIMEOUT, &wait_until_all_ready,
 442                                     &disconnect_carol);
 443 }
 444
 445
 446 static void
 447 prepare_bob_for_alice_task (void *cls,
 448                             const struct GNUNET_SCHEDULER_TaskContext *tc)
 449 {
 450   bob_wanted.meta = alice_meta;
 451   bob_wanted.sender = &alice;
 452   bob_wanted.msg = NULL;
 453   bob_wanted.opt = -1;
 454   bob_wanted.next_task = &set_bob_ready;
 455   bob_wanted.next_task_cls = NULL;
 456 }
 457
 458
 459 static void
 460 prepare_carol_for_alice_and_bob_task (void *cls,
 461                                       const struct GNUNET_SCHEDULER_TaskContext
 462                                       *tc)
 463 {
 464   carol_wanted.meta = alice_meta;
 465   carol_wanted.sender = &alice;
 466   /* set alternative meta/sender since we don't know from which peer
 467    * notification will come first */
 468   carol_wanted.meta2 = bob_meta;
 469   carol_wanted.sender2 = &bob;
 470   carol_wanted.msg = NULL;
 471   carol_wanted.opt = -1;
 472   carol_wanted.next_task = &wait_until_all_ready;
 473   carol_wanted.next_task_cls = &send_from_alice_to_bob;
 474 }
 475
 476
 477 static void
 478 join_carol_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 479 {
 480 #if VERBOSE
 481   printf ("Carol joining\n");
 482 #endif
 483   alice_wanted.meta = carol_meta;
 484   alice_wanted.sender = &carol;
 485   alice_wanted.msg = NULL;
 486   alice_wanted.opt = -1;
 487   alice_wanted.next_task = &set_alice_ready;
 488   alice_wanted.next_task_cls = NULL;
 489   alice_ready = GNUNET_NO;
 490   bob_wanted.meta = carol_meta;
 491   bob_wanted.sender = &carol;
 492   bob_wanted.msg = NULL;
 493   bob_wanted.opt = -1;
 494   bob_wanted.next_task = &set_bob_ready;
 495   bob_wanted.next_task_cls = NULL;
 496   bob_ready = GNUNET_NO;
 497   carol_wanted.next_task = &prepare_carol_for_alice_and_bob_task;
 498   carol_wanted.next_task_cls = NULL;
 499   carol_room =
 500       GNUNET_CHAT_join_room (is_p2p ? p3.cfg : p1.cfg, "carol", carol_meta,
 501                              "test", -1, &join_cb, &carol_wanted, &receive_cb,
 502                              &carol_wanted, &member_list_cb, &carol_wanted,
 503                              NULL, NULL, &carol);
 504   if (NULL == carol_room)
 505   {
 506     GNUNET_SCHEDULER_cancel (kill_task);
 507     kill_task = GNUNET_SCHEDULER_NO_TASK;
 508     GNUNET_CHAT_leave_room (alice_room);
 509     alice_room = NULL;
 510     GNUNET_CHAT_leave_room (bob_room);
 511     bob_room = NULL;
 512     err = 1;
 513   }
 514 }
 515
 516
 517 static void
 518 join_bob_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 519 {
 520 #if VERBOSE
 521   printf ("Bob joining\n");
 522 #endif
 523   alice_wanted.meta = bob_meta;
 524   alice_wanted.sender = &bob;
 525   alice_wanted.msg = NULL;
 526   alice_wanted.opt = -1;
 527   alice_wanted.next_task = &wait_until_all_ready;
 528   alice_wanted.next_task_cls = &join_carol_task;
 529   alice_ready = GNUNET_YES;
 530   bob_wanted.next_task = &prepare_bob_for_alice_task;
 531   bob_wanted.next_task_cls = NULL;
 532   bob_ready = GNUNET_NO;
 533   bob_room =
 534       GNUNET_CHAT_join_room (is_p2p ? p2.cfg : p1.cfg, "bob", bob_meta, "test",
 535                              -1, &join_cb, &bob_wanted, &receive_cb,
 536                              &bob_wanted, &member_list_cb, &bob_wanted, NULL,
 537                              NULL, &bob);
 538   if (NULL == bob_room)
 539   {
 540     GNUNET_SCHEDULER_cancel (kill_task);
 541     kill_task = GNUNET_SCHEDULER_NO_TASK;
 542     GNUNET_CHAT_leave_room (alice_room);
 543     alice_room = NULL;
 544     err = 1;
 545   }
 546 }
 547
 548
 549 static void
 550 join_alice_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 551 {
 552 #if VERBOSE
 553   printf ("Alice joining\n");
 554 #endif
 555   alice_wanted.next_task = &join_bob_task;
 556   alice_wanted.next_task_cls = NULL;
 557   alice_room =
 558       GNUNET_CHAT_join_room (p1.cfg, "alice", alice_meta, "test", -1, &join_cb,
 559                              &alice_wanted, &receive_cb, &alice_wanted,
 560                              &member_list_cb, &alice_wanted, NULL, NULL,
 561                              &alice);
 562   if (NULL == alice_room)
 563   {
 564     GNUNET_SCHEDULER_cancel (kill_task);
 565     kill_task = GNUNET_SCHEDULER_NO_TASK;
 566     err = 1;
 567   }
 568 }
 569
 570
 571 static void
 572 run (void *cls, char *const *args, const char *cfgfile,
 573      const struct GNUNET_CONFIGURATION_Handle *cfg)
 574 {
 575   if (is_p2p)
 576   {
 577     setup_peer (&p1, "test_chat_peer1.conf");
 578     setup_peer (&p2, "test_chat_peer2.conf");
 579     setup_peer (&p3, "test_chat_peer3.conf");
 580   }
 581   else
 582     setup_peer (&p1, "test_chat_data.conf");
 583
 584   memset (&alice_wanted, 0, sizeof (struct Wanted));
 585   memset (&bob_wanted, 0, sizeof (struct Wanted));
 586   memset (&carol_wanted, 0, sizeof (struct Wanted));
 587   alice_wanted.me = "Alice";
 588   bob_wanted.me = "Bob";
 589   carol_wanted.me = "Carol";
 590   alice_meta = GNUNET_CONTAINER_meta_data_create ();
 591   GNUNET_CONTAINER_meta_data_insert (alice_meta, "<gnunet>",
 592                                      EXTRACTOR_METATYPE_TITLE,
 593                                      EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 594                                      "Alice", strlen ("Alice") + 1);
 595   bob_meta = GNUNET_CONTAINER_meta_data_create ();
 596   GNUNET_CONTAINER_meta_data_insert (bob_meta, "<gnunet>",
 597                                      EXTRACTOR_METATYPE_TITLE,
 598                                      EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 599                                      "Bob", strlen ("Bob") + 1);
 600   carol_meta = GNUNET_CONTAINER_meta_data_create ();
 601   GNUNET_CONTAINER_meta_data_insert (carol_meta, "<gnunet>",
 602                                      EXTRACTOR_METATYPE_TITLE,
 603                                      EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 604                                      "Carol", strlen ("Carol") + 1);
 605   kill_task = GNUNET_SCHEDULER_add_delayed (KILL_TIMEOUT, &timeout_kill, NULL);
 606   GNUNET_SCHEDULER_add_now (&join_alice_task, NULL);
 607 }
 608
 609
 610 int
 611 main (int argc, char *argv[])
 612 {
 613   char *const argvx[] = {
 614     "test-chat",
 615     "-c",
 616     "test_chat_data.conf",
 617 #if VERBOSE
 618     "-L", "DEBUG",
 619 #endif
 620     NULL
 621   };
 622   struct GNUNET_GETOPT_CommandLineOption options[] = {
 623     GNUNET_GETOPT_OPTION_END
 624   };
 625
 626   GNUNET_log_setup ("test_chat",
 627 #if VERBOSE
 628                     "DEBUG",
 629 #else
 630                     "WARNING",
 631 #endif
 632                     NULL);
 633   if (strstr (argv[0], "p2p") != NULL)
 634   {
 635     is_p2p = GNUNET_YES;
 636   }
 637   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx,
 638                       "test-chat", "nohelp", options, &run, NULL);
 639   stop_arm (&p1);
 640   GNUNET_CONTAINER_meta_data_destroy (alice_meta);
 641   GNUNET_CONTAINER_meta_data_destroy (bob_meta);
 642   GNUNET_CONTAINER_meta_data_destroy (carol_meta);
 643   if (is_p2p)
 644   {
 645     GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-1/");
 646     GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-2/");
 647     GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-3/");
 648   }
 649   else
 650     GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat/");
 651   return err;
 652 }
 653
 654 /* end of test_chat_private.c */