#define VERBOSE GNUNET_NO
-#define START_ARM GNUNET_YES
-
/**
* How long until we give up on passing the test?
*/
struct PeerContext
{
struct GNUNET_CONFIGURATION_Handle *cfg;
-#if START_ARM
struct GNUNET_OS_Process *arm_proc;
-#endif
};
struct Wanted
{
struct GNUNET_CONTAINER_MetaData *meta;
- GNUNET_HashCode *sender;
+ struct GNUNET_HashCode *sender;
/**
* Alternative meta/sender is used when we expect join/leave notification
*/
struct GNUNET_CONTAINER_MetaData *meta2;
- GNUNET_HashCode *sender2;
+ struct GNUNET_HashCode *sender2;
char *msg;
static struct PeerContext p3;
-static GNUNET_HashCode alice;
+static struct GNUNET_HashCode alice;
-static GNUNET_HashCode bob;
+static struct GNUNET_HashCode bob;
-static GNUNET_HashCode carol;
+static struct GNUNET_HashCode carol;
static struct GNUNET_CHAT_Room *alice_room;
static int is_p2p;
-struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *bob_public_key = NULL;
+static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *bob_public_key;
static void
setup_peer (struct PeerContext *p, const char *cfgname)
{
+ char *binary;
+
+ binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
p->cfg = GNUNET_CONFIGURATION_create ();
-#if START_ARM
- p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
- "gnunet-service-arm",
-#if VERBOSE
- "-L", "DEBUG",
-#endif
- "-c", cfgname, NULL);
-#endif
+ p->arm_proc =
+ GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, binary,
+ "gnunet-service-arm",
+ "-c", cfgname, NULL);
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
+ GNUNET_free (binary);
}
static void
stop_arm (struct PeerContext *p)
{
-#if START_ARM
if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
- if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
+ if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
- GNUNET_OS_process_close (p->arm_proc);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM process %u stopped\n",
+ GNUNET_OS_process_get_pid (p->arm_proc));
+ GNUNET_OS_process_destroy (p->arm_proc);
p->arm_proc = NULL;
-#endif
GNUNET_CONFIGURATION_destroy (p->cfg);
}
static void
-abort_test (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (alice_room != NULL)
- {
- GNUNET_CHAT_leave_room (alice_room);
- alice_room = NULL;
- }
+ {
+ GNUNET_CHAT_leave_room (alice_room);
+ alice_room = NULL;
+ }
if (bob_room != NULL)
- {
- GNUNET_CHAT_leave_room (bob_room);
- bob_room = NULL;
- }
+ {
+ GNUNET_CHAT_leave_room (bob_room);
+ bob_room = NULL;
+ }
if (carol_room != NULL)
- {
- GNUNET_CHAT_leave_room (carol_room);
- carol_room = NULL;
- }
+ {
+ GNUNET_CHAT_leave_room (carol_room);
+ carol_room = NULL;
+ }
err = 1;
}
static void
-timeout_kill (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_kill (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
#if VERBOSE
printf ("Timed out, stopping the test.\n");
#endif
kill_task = GNUNET_SCHEDULER_NO_TASK;
if (wait_task != GNUNET_SCHEDULER_NO_TASK)
- {
- GNUNET_SCHEDULER_cancel (wait_task);
- wait_task = GNUNET_SCHEDULER_NO_TASK;
- }
+ {
+ GNUNET_SCHEDULER_cancel (wait_task);
+ wait_task = GNUNET_SCHEDULER_NO_TASK;
+ }
GNUNET_SCHEDULER_add_continuation (&abort_test, NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
static int
-member_list_cb (void *cls,
- const struct GNUNET_CONTAINER_MetaData *member_info,
+member_list_cb (void *cls, const struct GNUNET_CONTAINER_MetaData *member_info,
const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *member_id,
enum GNUNET_CHAT_MsgOptions options)
{
struct Wanted *want = cls;
- GNUNET_HashCode sender;
+ struct GNUNET_HashCode sender;
#if VERBOSE
- printf ("%s - told that %s has %s\n",
- want->me,
- member_info == NULL ? NULL
- : GNUNET_CONTAINER_meta_data_get_by_type (member_info,
- EXTRACTOR_METATYPE_TITLE),
- member_info == NULL ? "left" : "joined");
+ printf ("%s - told that %s has %s\n", want->me,
+ member_info ==
+ NULL ? NULL : GNUNET_CONTAINER_meta_data_get_by_type (member_info,
+ EXTRACTOR_METATYPE_TITLE),
+ member_info == NULL ? "left" : "joined");
#endif
GNUNET_CRYPTO_hash (member_id,
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
&sender);
/* entertain both primary and an alternative sender/meta */
- if (((0 == memcmp (&sender, want->sender, sizeof (GNUNET_HashCode))) ||
+ if (((0 == memcmp (&sender, want->sender, sizeof (struct GNUNET_HashCode))) ||
((want->sender2 != NULL) &&
- (0 == memcmp (&sender, want->sender2, sizeof (GNUNET_HashCode))))) &&
+ (0 == memcmp (&sender, want->sender2, sizeof (struct GNUNET_HashCode))))) &&
(((member_info == NULL) && (want->meta == NULL)) ||
((member_info != NULL) &&
(((want->meta != NULL) &&
- GNUNET_CONTAINER_meta_data_test_equal (member_info,
- want->meta)) ||
+ GNUNET_CONTAINER_meta_data_test_equal (member_info, want->meta)) ||
((want->meta2 != NULL) &&
- GNUNET_CONTAINER_meta_data_test_equal (member_info,
- want->meta2))))) &&
- (options == want->opt))
- {
- /* remember Bob's public key, we need it to send private message */
- if (NULL == bob_public_key &&
- (0 == memcmp (&bob, want->sender, sizeof (GNUNET_HashCode))))
- bob_public_key =
+ GNUNET_CONTAINER_meta_data_test_equal (member_info, want->meta2)))))
+ && (options == want->opt))
+ {
+ /* remember Bob's public key, we need it to send private message */
+ if (NULL == bob_public_key &&
+ (0 == memcmp (&bob, want->sender, sizeof (struct GNUNET_HashCode))))
+ bob_public_key =
GNUNET_memdup (member_id,
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
- if (want->sender2 != NULL)
- {
- /* flush alternative sender */
- if (0 == memcmp (&sender, want->sender, sizeof (GNUNET_HashCode)))
- {
- want->sender = want->sender2;
- want->meta = want->meta2;
- }
- want->sender2 = NULL;
- want->meta2 = NULL;
- }
- else
- if (NULL != want->next_task)
- GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls);
- }
- else
+ sizeof (struct
+ GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+ if (want->sender2 != NULL)
{
- GNUNET_SCHEDULER_cancel (kill_task);
- kill_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_add_now (&abort_test, NULL);
+ /* flush alternative sender */
+ if (0 == memcmp (&sender, want->sender, sizeof (struct GNUNET_HashCode)))
+ {
+ want->sender = want->sender2;
+ want->meta = want->meta2;
+ }
+ want->sender2 = NULL;
+ want->meta2 = NULL;
}
+ else if (NULL != want->next_task)
+ GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls);
+ }
+ else
+ {
+ GNUNET_SCHEDULER_cancel (kill_task);
+ kill_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_SCHEDULER_add_now (&abort_test, NULL);
+ }
return GNUNET_OK;
}
static int
-receive_cb (void *cls,
- struct GNUNET_CHAT_Room *room,
- const GNUNET_HashCode *sender,
- const struct GNUNET_CONTAINER_MetaData *meta,
- const char *message,
+receive_cb (void *cls, struct GNUNET_CHAT_Room *room,
+ const struct GNUNET_HashCode * sender,
+ const struct GNUNET_CONTAINER_MetaData *meta, const char *message,
struct GNUNET_TIME_Absolute timestamp,
enum GNUNET_CHAT_MsgOptions options)
{
struct Wanted *want = cls;
#if VERBOSE
- printf ("%s - told that %s said '%s'\n",
- want->me,
- meta == NULL ? NULL
- : GNUNET_CONTAINER_meta_data_get_by_type (meta,
- EXTRACTOR_METATYPE_TITLE),
+ printf ("%s - told that %s said '%s'\n", want->me,
+ meta == NULL ? NULL : GNUNET_CONTAINER_meta_data_get_by_type (meta,
+ EXTRACTOR_METATYPE_TITLE),
message);
#endif
if ((want->msg != NULL) && (0 == strcmp (message, want->msg)) &&
(((sender == NULL) && (want->sender == NULL)) ||
((sender != NULL) && (want->sender != NULL) &&
- (0 == memcmp (sender, want->sender,
- sizeof (GNUNET_HashCode))))) &&
+ (0 == memcmp (sender, want->sender, sizeof (struct GNUNET_HashCode))))) &&
(GNUNET_CONTAINER_meta_data_test_equal (meta, want->meta)) &&
(options == want->opt) &&
/* Not == since the library sets the actual timestamp, so it may be
* slightly greater
*/
(timestamp.abs_value >= want->timestamp.abs_value))
- {
- if (NULL != want->next_task)
- GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls);
- }
+ {
+ if (NULL != want->next_task)
+ GNUNET_SCHEDULER_add_now (want->next_task, want->next_task_cls);
+ }
else
- {
- GNUNET_SCHEDULER_cancel (kill_task);
- kill_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_cancel (finish_task);
- finish_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_add_now (&abort_test, NULL);
- }
+ {
+ GNUNET_SCHEDULER_cancel (kill_task);
+ kill_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_SCHEDULER_cancel (finish_task);
+ finish_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_SCHEDULER_add_now (&abort_test, NULL);
+ }
return GNUNET_OK;
}
static void
-wait_until_all_ready (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+wait_until_all_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_SCHEDULER_Task task = cls;
printf ("Waiting...\n");
#endif
if (alice_ready && bob_ready)
- {
- wait_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_add_now (task, NULL);
- }
+ {
+ wait_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_SCHEDULER_add_now (task, NULL);
+ }
else
wait_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
- 5000),
- &wait_until_all_ready,
- task);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_MILLISECONDS, 5000),
+ &wait_until_all_ready, task);
}
static void
-set_alice_ready (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+set_alice_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
alice_ready = GNUNET_YES;
}
static void
-set_bob_ready (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+set_bob_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
bob_ready = GNUNET_YES;
}
static void
-disconnect_alice (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+disconnect_alice (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
#if VERBOSE
printf ("Alice is leaving.\n");
static void
-disconnect_bob (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+disconnect_bob (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
#if VERBOSE
printf ("Bod is leaving.\n");
static void
-disconnect_carol (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+disconnect_carol (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
#if VERBOSE
printf ("Carol is leaving.\n");
carol_wanted.opt = 0;
carol_wanted.next_task = NULL;
carol_wanted.next_task_cls = NULL;
- GNUNET_CHAT_send_message (alice_room,
- "Hi Bob!",
- GNUNET_CHAT_MSG_PRIVATE,
+ GNUNET_CHAT_send_message (alice_room, "Hi Bob!", GNUNET_CHAT_MSG_PRIVATE,
bob_public_key, &seq);
- finish_task = GNUNET_SCHEDULER_add_delayed (PM_TIMEOUT,
- &wait_until_all_ready,
- &disconnect_carol);
+ finish_task =
+ GNUNET_SCHEDULER_add_delayed (PM_TIMEOUT, &wait_until_all_ready,
+ &disconnect_carol);
}
static void
prepare_carol_for_alice_and_bob_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+ const struct GNUNET_SCHEDULER_TaskContext
+ *tc)
{
carol_wanted.meta = alice_meta;
carol_wanted.sender = &alice;
/* set alternative meta/sender since we don't know from which peer
- notification will come first */
+ * notification will come first */
carol_wanted.meta2 = bob_meta;
carol_wanted.sender2 = &bob;
carol_wanted.msg = NULL;
static void
-join_carol_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+join_carol_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
#if VERBOSE
printf ("Carol joining\n");
carol_wanted.next_task = &prepare_carol_for_alice_and_bob_task;
carol_wanted.next_task_cls = NULL;
carol_room =
- GNUNET_CHAT_join_room (is_p2p ? p3.cfg : p1.cfg, "carol", carol_meta,
- "test", -1,
- &join_cb, &carol_wanted,
- &receive_cb, &carol_wanted,
- &member_list_cb, &carol_wanted,
- NULL, NULL, &carol);
+ GNUNET_CHAT_join_room (is_p2p ? p3.cfg : p1.cfg, "carol", carol_meta,
+ "test", -1, &join_cb, &carol_wanted, &receive_cb,
+ &carol_wanted, &member_list_cb, &carol_wanted,
+ NULL, NULL, &carol);
if (NULL == carol_room)
- {
- GNUNET_SCHEDULER_cancel (kill_task);
- kill_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_CHAT_leave_room (alice_room);
- alice_room = NULL;
- GNUNET_CHAT_leave_room (bob_room);
- bob_room = NULL;
- err = 1;
- }
+ {
+ GNUNET_SCHEDULER_cancel (kill_task);
+ kill_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_CHAT_leave_room (alice_room);
+ alice_room = NULL;
+ GNUNET_CHAT_leave_room (bob_room);
+ bob_room = NULL;
+ err = 1;
+ }
}
static void
-join_bob_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+join_bob_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
#if VERBOSE
printf ("Bob joining\n");
bob_wanted.next_task_cls = NULL;
bob_ready = GNUNET_NO;
bob_room =
- GNUNET_CHAT_join_room (is_p2p ? p2.cfg : p1.cfg, "bob", bob_meta,
- "test", -1,
- &join_cb, &bob_wanted,
- &receive_cb, &bob_wanted,
- &member_list_cb, &bob_wanted,
- NULL, NULL, &bob);
+ GNUNET_CHAT_join_room (is_p2p ? p2.cfg : p1.cfg, "bob", bob_meta, "test",
+ -1, &join_cb, &bob_wanted, &receive_cb,
+ &bob_wanted, &member_list_cb, &bob_wanted, NULL,
+ NULL, &bob);
if (NULL == bob_room)
- {
- GNUNET_SCHEDULER_cancel (kill_task);
- kill_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_CHAT_leave_room (alice_room);
- alice_room = NULL;
- err = 1;
- }
+ {
+ GNUNET_SCHEDULER_cancel (kill_task);
+ kill_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_CHAT_leave_room (alice_room);
+ alice_room = NULL;
+ err = 1;
+ }
}
static void
-join_alice_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+join_alice_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
#if VERBOSE
printf ("Alice joining\n");
alice_wanted.next_task = &join_bob_task;
alice_wanted.next_task_cls = NULL;
alice_room =
- GNUNET_CHAT_join_room (p1.cfg, "alice", alice_meta,
- "test", -1,
- &join_cb, &alice_wanted,
- &receive_cb, &alice_wanted,
- &member_list_cb, &alice_wanted,
- NULL, NULL, &alice);
+ GNUNET_CHAT_join_room (p1.cfg, "alice", alice_meta, "test", -1, &join_cb,
+ &alice_wanted, &receive_cb, &alice_wanted,
+ &member_list_cb, &alice_wanted, NULL, NULL,
+ &alice);
if (NULL == alice_room)
- {
- GNUNET_SCHEDULER_cancel (kill_task);
- kill_task = GNUNET_SCHEDULER_NO_TASK;
- err = 1;
- }
+ {
+ GNUNET_SCHEDULER_cancel (kill_task);
+ kill_task = GNUNET_SCHEDULER_NO_TASK;
+ err = 1;
+ }
}
static void
-run (void *cls,
- char *const *args,
- const char *cfgfile,
+run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
if (is_p2p)
- {
- setup_peer (&p1, "test_chat_peer1.conf");
- setup_peer (&p2, "test_chat_peer2.conf");
- setup_peer (&p3, "test_chat_peer3.conf");
- }
+ {
+ setup_peer (&p1, "test_chat_peer1.conf");
+ setup_peer (&p2, "test_chat_peer2.conf");
+ setup_peer (&p3, "test_chat_peer3.conf");
+ }
else
setup_peer (&p1, "test_chat_data.conf");
bob_wanted.me = "Bob";
carol_wanted.me = "Carol";
alice_meta = GNUNET_CONTAINER_meta_data_create ();
- GNUNET_CONTAINER_meta_data_insert (alice_meta,
- "<gnunet>",
+ GNUNET_CONTAINER_meta_data_insert (alice_meta, "<gnunet>",
EXTRACTOR_METATYPE_TITLE,
- EXTRACTOR_METAFORMAT_UTF8,
- "text/plain",
- "Alice",
- strlen("Alice")+1);
+ EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+ "Alice", strlen ("Alice") + 1);
bob_meta = GNUNET_CONTAINER_meta_data_create ();
- GNUNET_CONTAINER_meta_data_insert (bob_meta,
- "<gnunet>",
+ GNUNET_CONTAINER_meta_data_insert (bob_meta, "<gnunet>",
EXTRACTOR_METATYPE_TITLE,
- EXTRACTOR_METAFORMAT_UTF8,
- "text/plain",
- "Bob",
- strlen("Bob")+1);
+ EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+ "Bob", strlen ("Bob") + 1);
carol_meta = GNUNET_CONTAINER_meta_data_create ();
- GNUNET_CONTAINER_meta_data_insert (carol_meta,
- "<gnunet>",
+ GNUNET_CONTAINER_meta_data_insert (carol_meta, "<gnunet>",
EXTRACTOR_METATYPE_TITLE,
- EXTRACTOR_METAFORMAT_UTF8,
- "text/plain",
- "Carol",
- strlen("Carol")+1);
+ EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+ "Carol", strlen ("Carol") + 1);
kill_task = GNUNET_SCHEDULER_add_delayed (KILL_TIMEOUT, &timeout_kill, NULL);
GNUNET_SCHEDULER_add_now (&join_alice_task, NULL);
}
int
main (int argc, char *argv[])
{
- char *const argvx[] = {
+ char *const argvx[] = {
"test-chat",
"-c",
"test_chat_data.conf",
-#if VERBOSE
- "-L", "DEBUG",
-#endif
NULL
};
struct GNUNET_GETOPT_CommandLineOption options[] = {
GNUNET_GETOPT_OPTION_END
};
- GNUNET_log_setup ("test_chat",
-#if VERBOSE
- "DEBUG",
-#else
+ GNUNET_log_setup ("test_chat",
"WARNING",
-#endif
NULL);
- if (strstr(argv[0], "p2p") != NULL)
- {
- is_p2p = GNUNET_YES;
- }
- GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
- argvx, "test-chat",
- "nohelp", options, &run, NULL);
+ if (strstr (argv[0], "p2p") != NULL)
+ {
+ is_p2p = GNUNET_YES;
+ }
+ GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx,
+ "test-chat", "nohelp", options, &run, NULL);
stop_arm (&p1);
GNUNET_CONTAINER_meta_data_destroy (alice_meta);
GNUNET_CONTAINER_meta_data_destroy (bob_meta);
GNUNET_CONTAINER_meta_data_destroy (carol_meta);
if (is_p2p)
- {
- GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-1/");
- GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-2/");
- GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-3/");
- }
+ {
+ GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-1/");
+ GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-2/");
+ GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat-peer-3/");
+ }
else
GNUNET_DISK_directory_remove ("/tmp/gnunet-test-chat/");
return err;
projects / oweals / gnunet.git / blobdiff