/**
* @file mesh/test_mesh_local.c
- * @brief test mesh local: test of tunnels with just one peer
+ * @brief test mesh local: test of mesh channels with just one peer
* @author Bartlomiej Polot
*/
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_dht_service.h"
-#include "gnunet_mesh_service_new.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_mesh_service.h"
-#define VERBOSE 1
-#define VERBOSE_ARM 0
+struct GNUNET_TESTING_Peer *me;
-static struct GNUNET_OS_Process *arm_pid;
static struct GNUNET_MESH_Handle *mesh_peer_1;
+
static struct GNUNET_MESH_Handle *mesh_peer_2;
-static struct GNUNET_MESH_Tunnel *t_1;
-static struct GNUNET_MESH_Tunnel *t_2;
-static int result;
+
+static struct GNUNET_MESH_Channel *ch;
+
+static int result = GNUNET_OK;
+
+static int got_data = GNUNET_NO;
+
static GNUNET_SCHEDULER_TaskIdentifier abort_task;
-static GNUNET_SCHEDULER_TaskIdentifier test_task;
-static struct GNUNET_MESH_MessageHandler handlers1[] = {
- {&callback, 1, 0},
- {NULL, 0, 0}
-};
+static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
+
+static struct GNUNET_MESH_TransmitHandle *mth;
+
+
+/**
+ * Connect to other client and send data
+ *
+ * @param cls Closue (unused).
+ * @param tc TaskContext.
+ */
+static void
+do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+
+
+/**
+ * Shutdown nicely
+ */
+static void
+do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shutdown\n");
+ if (GNUNET_SCHEDULER_NO_TASK != abort_task)
+ {
+ GNUNET_SCHEDULER_cancel (abort_task);
+ }
+ if (NULL != ch)
+ {
+ GNUNET_MESH_channel_destroy (ch);
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect client 1\n");
+ if (NULL != mesh_peer_1)
+ {
+ GNUNET_MESH_disconnect (mesh_peer_1);
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect client 2\n");
+ if (NULL != mesh_peer_2)
+ {
+ GNUNET_MESH_disconnect (mesh_peer_2);
+ }
+}
-static struct GNUNET_MESH_MessageHandler handlers2[] = { {NULL, 0, 0} };
+/**
+ * Something went wrong and timed out. Kill everything and set error flag
+ */
+static void
+do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ABORT\n");
+ result = GNUNET_SYSERR;
+ abort_task = GNUNET_SCHEDULER_NO_TASK;
+ if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
+ {
+ GNUNET_SCHEDULER_cancel (shutdown_task);
+ shutdown_task = GNUNET_SCHEDULER_NO_TASK;
+ }
+ do_shutdown (cls, tc);
+}
/**
* Function is called whenever a message is received.
*
* @param cls closure (set from GNUNET_MESH_connect)
- * @param tunnel connection to the other end
- * @param tunnel_ctx place to store local state associated with the tunnel
- * @param sender who sent the message
+ * @param channel connection to the other end
+ * @param channel_ctx place to store local state associated with the channel
* @param message the actual message
- * @param atsi performance data for the connection
+ *
* @return GNUNET_OK to keep the connection open,
* GNUNET_SYSERR to close it (signal serious error)
*/
static int
-callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
- const struct GNUNET_PeerIdentity *sender,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+data_callback (void *cls, struct GNUNET_MESH_Channel *channel,
+ void **channel_ctx,
+ const struct GNUNET_MessageHeader *message)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Data callback\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Data callback! Shutting down.\n");
+ got_data = GNUNET_YES;
+ if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
+ GNUNET_SCHEDULER_cancel (shutdown_task);
+ shutdown_task =
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &do_shutdown,
+ NULL);
+ GNUNET_MESH_receive_done (channel);
return GNUNET_OK;
}
/**
- * Method called whenever another peer has added us to a tunnel
+ * Method called whenever another peer has added us to a channel
* the other peer initiated.
*
* @param cls closure
- * @param tunnel new handle to the tunnel
- * @param initiator peer that started the tunnel
- * @param atsi performance information for the tunnel
- * @return initial tunnel context for the tunnel (can be NULL -- that's not an error)
+ * @param channel new handle to the channel
+ * @param initiator peer that started the channel
+ * @param port port number
+ * @param options channel options
+ * @return initial channel context for the channel
+ * (can be NULL -- that's not an error)
*/
static void *
-inbound_tunnel (void *cls, struct GNUNET_MESH_Tunnel *tunnel,
+inbound_channel (void *cls, struct GNUNET_MESH_Channel *channel,
const struct GNUNET_PeerIdentity *initiator,
- const structGNUNET_TRANSPORT_ATS_Information * atsi)
+ uint32_t port, enum GNUNET_MESH_ChannelOption options)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: \n");
+ long id = (long) cls;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "received incoming channel on peer %d, port %u\n",
+ id, port);
+ if (id != 2L)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "wrong peer\n");
+ result = GNUNET_SYSERR;
+ }
return NULL;
}
+/**
+ * Function called whenever an channel is destroyed. Should clean up
+ * any associated state.
+ *
+ * @param cls closure (set from GNUNET_MESH_connect)
+ * @param channel connection to the other end (henceforth invalid)
+ * @param channel_ctx place where local state associated
+ * with the channel is stored
+ */
+static void
+channel_end (void *cls, const struct GNUNET_MESH_Channel *channel,
+ void *channel_ctx)
+{
+ long id = (long) cls;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "incoming channel closed at peer %ld\n",
+ id);
+ if (NULL != mth)
+ {
+ GNUNET_MESH_notify_transmit_ready_cancel (mth);
+ mth = NULL;
+ }
+ if (GNUNET_NO == got_data)
+ {
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
+ GNUNET_TIME_UNIT_SECONDS,
+ 2),
+ &do_connect, NULL);
+ }
+}
+/**
+ * Handler array for traffic received on peer1
+ */
+static struct GNUNET_MESH_MessageHandler handlers1[] = {
+ {&data_callback, 1, 0},
+ {NULL, 0, 0}
+};
+/**
+ * Handler array for traffic received on peer2 (none expected)
+ */
+static struct GNUNET_MESH_MessageHandler handlers2[] = {
+ {&data_callback, 1, 0},
+ {NULL, 0, 0}
+};
-
-static void
-do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+/**
+ * Data send callback: fillbuffer with test packet.
+ *
+ * @param cls Closure (unused).
+ * @param size Buffer size.
+ * @param buf Buffer to fill.
+ *
+ * @return size of test packet.
+ */
+static size_t
+do_send (void *cls, size_t size, void *buf)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: shutdown\n");
- if (0 != abort_task)
- {
- GNUNET_SCHEDULER_cancel (abort_task);
- }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: D1\n");
- if (NULL != mesh_peer_1)
- {
- GNUNET_MESH_disconnect (mesh_peer_1);
- }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: D2\n");
- if (NULL != mesh_peer_2)
- {
- GNUNET_MESH_disconnect (mesh_peer_2);
- }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: arm\n");
- if (0 != GNUNET_OS_process_kill (arm_pid, SIGTERM))
+ struct GNUNET_MessageHeader *m = buf;
+
+ mth = NULL;
+ if (NULL == buf)
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+ GNUNET_break (0);
+ result = GNUNET_SYSERR;
+ return 0;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Wait\n");
- GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (arm_pid));
- GNUNET_OS_process_close (arm_pid);
+ m->size = htons (sizeof (struct GNUNET_MessageHeader));
+ m->type = htons (1);
+ GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
+ return sizeof (struct GNUNET_MessageHeader);
}
+/**
+ * Connect to other client and send data
+ *
+ * @param cls Closue (unused).
+ * @param tc TaskContext.
+ */
static void
-do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- if (0 != test_task)
- {
- GNUNET_SCHEDULER_cancel (test_task);
- }
- result = GNUNET_SYSERR;
- abort_task = 0;
- do_shutdown (cls, tc);
+ struct GNUNET_PeerIdentity id;
+
+ GNUNET_TESTING_peer_get_identity (me, &id);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CONNECT BY PORT\n");
+ ch = GNUNET_MESH_channel_create (mesh_peer_1, NULL, &id, 1,
+ GNUNET_MESH_OPTION_DEFAULT);
+ mth = GNUNET_MESH_notify_transmit_ready (ch, GNUNET_NO,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ sizeof (struct GNUNET_MessageHeader),
+ &do_send, NULL);
}
+
+/**
+ * Initialize framework and start test
+ *
+ * @param cls Closure (unused).
+ * @param cfg Configuration handle.
+ * @param peer Testing peer handle.
+ */
static void
-test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+run (void *cls,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_TESTING_Peer *peer)
{
- struct GNUNET_CONFIGURATION_Handle *cfg = cls;
- static const GNUNET_MESH_ApplicationType app1[] =
- { 1, 2, 3, 4, 5, 6, 7, 8, 0 };
- static const GNUNET_MESH_ApplicationType app2[] = { 0 };
-
- test_task = (GNUNET_SCHEDULER_TaskIdentifier) 0;
- mesh_peer_1 = GNUNET_MESH_connect (cfg, 10, 1, NULL, NULL, handlers1, app1);
- mesh_peer_2 = GNUNET_MESH_connect (cfg, 10, 2, NULL, NULL, handlers2, app2);
+ static uint32_t ports[] = {1, 0};
+
+ me = peer;
+ abort_task =
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 15), &do_abort,
+ NULL);
+ mesh_peer_1 = GNUNET_MESH_connect (cfg, /* configuration */
+ (void *) 1L, /* cls */
+ NULL, /* inbound new hndlr */
+ &channel_end, /* channel end hndlr */
+ handlers1, /* traffic handlers */
+ NULL); /* ports offered */
+
+ mesh_peer_2 = GNUNET_MESH_connect (cfg, /* configuration */
+ (void *) 2L, /* cls */
+ &inbound_channel, /* inbound new hndlr */
+ &channel_end, /* channel end hndlr */
+ handlers2, /* traffic handlers */
+ ports); /* ports offered */
if (NULL == mesh_peer_1 || NULL == mesh_peer_2)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "test: Couldn't connect to mesh :(\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Couldn't connect to mesh :(\n");
+ result = GNUNET_SYSERR;
return;
}
else
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: YAY! CONNECTED TO MESH :D\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "YAY! CONNECTED TO MESH :D\n");
}
-
- t_1 = GNUNET_MESH_tunnel_create (mesh_peer_1, NULL, NULL, NULL, 1);
-// t_2 = GNUNET_MESH_tunnel_create (mesh_peer_2, NULL, NULL, NULL, 2);
-
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 2), &do_shutdown,
- NULL);
-}
-
-
-static void
-run (void *cls, char *const *args, const char *cfgfile,
- const struct GNUNET_CONFIGURATION_Handle *cfg)
-{
- GNUNET_log_setup ("test_mesh_local",
-#if VERBOSE
- "DEBUG",
-#else
- "WARNING",
-#endif
- NULL);
- arm_pid =
- GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
- "gnunet-service-arm",
-#if VERBOSE_ARM
- "-L", "DEBUG",
-#endif
- "-c", "test_mesh.conf", NULL);
-
- abort_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 20), &do_abort,
- NULL);
-
- test_task = GNUNET_SCHEDULER_add_now (&test, (void *) cfg);
-
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
+ GNUNET_TIME_UNIT_SECONDS,
+ 2),
+ &do_connect, NULL);
}
+/**
+ * Main
+ */
int
main (int argc, char *argv[])
{
- int ret;
-
- char *const argv2[] = { "test-mesh-local",
- "-c", "test_mesh.conf",
-#if VERBOSE
- "-L", "DEBUG",
-#endif
- NULL
- };
- struct GNUNET_GETOPT_CommandLineOption options[] = {
- GNUNET_GETOPT_OPTION_END
- };
-
- ret =
- GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,
- "test-mesh-local", "nohelp", options, &run, NULL);
-
- if (GNUNET_OK != ret)
+ if (0 != GNUNET_TESTING_peer_run ("test-mesh-local",
+ "test_mesh.conf",
+ &run, NULL))
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "run failed with error code %d\n",
- ret);
- return 1;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "run failed\n");
+ return 2;
}
- if (GNUNET_SYSERR == result)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test failed\n");
- return 1;
- }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test ok\n");
- return 0;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Final result: %d\n", result);
+ return (result == GNUNET_OK) ? 0 : 1;
}
+
+/* end of test_mesh_local_1.c */
projects / oweals / gnunet.git / blobdiff