/**
* @file mesh/test_mesh_local.c
- * @brief test mesh local: test of mesh tunnels with just one peer
+ * @brief test mesh local: test of mesh channels with just one peer
* @author Bartlomiej Polot
*/
static struct GNUNET_MESH_Handle *mesh_peer_2;
-static struct GNUNET_MESH_Tunnel *t;
+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 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
{
GNUNET_SCHEDULER_cancel (abort_task);
}
- if (NULL != t)
+ if (NULL != ch)
{
- GNUNET_MESH_tunnel_destroy (t);
+ GNUNET_MESH_channel_destroy (ch);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect client 1\n");
if (NULL != mesh_peer_1)
* 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 channel connection to the other end
+ * @param channel_ctx place to store local state associated with the channel
* @param message the actual message
- *
+ *
* @return GNUNET_OK to keep the connection open,
* GNUNET_SYSERR to close it (signal serious error)
*/
static int
-data_callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
+data_callback (void *cls, struct GNUNET_MESH_Channel *channel,
+ void **channel_ctx,
const struct GNUNET_MessageHeader *message)
{
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 (tunnel);
+ 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 channel new handle to the channel
+ * @param initiator peer that started the channel
* @param port port number
- * @return initial tunnel context for the tunnel (can be NULL -- that's not an error)
+ * @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,
- uint32_t port)
+ uint32_t port, enum GNUNET_MESH_ChannelOption options)
{
long id = (long) cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "received incoming tunnel on peer %d, port %u\n",
+ "received incoming channel on peer %d, port %u\n",
id, port);
if (id != 2L)
{
/**
- * Function called whenever an inbound tunnel is destroyed. Should clean up
+ * Function called whenever an channel is destroyed. Should clean up
* any associated state.
*
* @param cls closure (set from GNUNET_MESH_connect)
- * @param tunnel connection to the other end (henceforth invalid)
- * @param tunnel_ctx place where local state associated
- * with the tunnel is stored
+ * @param channel connection to the other end (henceforth invalid)
+ * @param channel_ctx place where local state associated
+ * with the channel is stored
*/
static void
-inbound_end (void *cls, const struct GNUNET_MESH_Tunnel *tunnel,
- void *tunnel_ctx)
+channel_end (void *cls, const struct GNUNET_MESH_Channel *channel,
+ void *channel_ctx)
{
long id = (long) cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "incoming tunnel closed at peer %ld\n",
+ "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);
+ }
}
/**
* 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
{
struct GNUNET_MessageHeader *m = buf;
+ mth = NULL;
if (NULL == buf)
{
GNUNET_break (0);
/**
* Connect to other client and send data
- *
+ *
* @param cls Closue (unused).
* @param tc TaskContext.
*/
GNUNET_TESTING_peer_get_identity (me, &id);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CONNECT BY PORT\n");
- t = GNUNET_MESH_tunnel_create (mesh_peer_1, NULL, &id, 1, GNUNET_YES, GNUNET_NO);
- GNUNET_MESH_notify_transmit_ready (t, GNUNET_NO,
- GNUNET_TIME_UNIT_FOREVER_REL,
- sizeof (struct GNUNET_MessageHeader),
- &do_send, NULL);
+ 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
-run (void *cls,
+run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
(GNUNET_TIME_UNIT_SECONDS, 15), &do_abort,
NULL);
mesh_peer_1 = GNUNET_MESH_connect (cfg, /* configuration */
- (void *) 1L, /* cls */
- &inbound_tunnel, /* inbound new hndlr */
- &inbound_end, /* inbound end hndlr */
+ (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_tunnel, /* inbound new hndlr */
- &inbound_end, /* inbound end hndlr */
+ &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_DEBUG, "YAY! CONNECTED TO MESH :D\n");
}
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &do_connect, NULL);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
+ GNUNET_TIME_UNIT_SECONDS,
+ 2),
+ &do_connect, NULL);
}
projects / oweals / gnunet.git / blobdiff