X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=test%2Fchannels-failure.c;h=1ac50d315852bfbfa665922e2454eae08cd7ec88;hb=HEAD;hp=db8889615aa3eab91fb7a7f892d48b228da51754;hpb=269c5eaed0f3333f014e04835a304bdfa9275e53;p=meshlink diff --git a/test/channels-failure.c b/test/channels-failure.c index db888961..1ac50d31 100644 --- a/test/channels-failure.c +++ b/test/channels-failure.c @@ -1,3 +1,7 @@ +#ifdef NDEBUG +#undef NDEBUG +#endif + #include #include #include @@ -8,22 +12,11 @@ #include "../src/meshlink.h" #include "utils.h" -static void log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) { - static struct timeval tv0; - struct timeval tv; - - if(tv0.tv_sec == 0) { - gettimeofday(&tv0, NULL); - } - - gettimeofday(&tv, NULL); - fprintf(stderr, "%u.%.03u ", (unsigned int)(tv.tv_sec - tv0.tv_sec), (unsigned int)tv.tv_usec / 1000); - - if(mesh) { - fprintf(stderr, "(%s) ", mesh->name); - } +static bool listen_cb(meshlink_handle_t *mesh, meshlink_node_t *node, uint16_t port) { + (void)mesh; + (void)node; - fprintf(stderr, "[%d] %s\n", level, text); + return port == 7; } static bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) { @@ -57,58 +50,35 @@ static void receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, con set_sync_flag(&receive_flag, true); } -int main() { - meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb); - - // Open three meshlink instances. - - meshlink_handle_t *mesh1 = meshlink_open("channels_failure_conf.1", "foo", "channels", DEV_CLASS_BACKBONE); - meshlink_handle_t *mesh2 = meshlink_open("channels_failure_conf.2", "bar", "channels", DEV_CLASS_BACKBONE); - - assert(mesh1); - assert(mesh2); +int main(void) { + init_sync_flag(&poll_flag); + init_sync_flag(&receive_flag); - meshlink_enable_discovery(mesh1, false); - meshlink_enable_discovery(mesh2, false); - - meshlink_set_log_cb(mesh1, MESHLINK_DEBUG, log_cb); - meshlink_set_log_cb(mesh2, MESHLINK_DEBUG, log_cb); - - // Import and export both side's data - - meshlink_add_address(mesh1, "localhost"); - meshlink_add_address(mesh2, "localhost"); - - char *data1 = meshlink_export(mesh1); - char *data2 = meshlink_export(mesh2); - - assert(data1); - assert(data2); + meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb); - assert(meshlink_import(mesh1, data2)); - assert(meshlink_import(mesh2, data1)); + // Open two meshlink instances. - free(data1); - free(data2); + meshlink_handle_t *mesh_a, *mesh_b; + open_meshlink_pair(&mesh_a, &mesh_b, "channels_failure"); // Set the callbacks. - meshlink_set_channel_accept_cb(mesh2, accept_cb); + meshlink_set_channel_listen_cb(mesh_b, listen_cb); + meshlink_set_channel_accept_cb(mesh_b, accept_cb); - // Open a channel from foo to bar + // Open a channel from a to b - meshlink_node_t *bar = meshlink_get_node(mesh1, "bar"); - assert(bar); + meshlink_node_t *b = meshlink_get_node(mesh_a, "b"); + assert(b); - meshlink_channel_t *channel = meshlink_channel_open(mesh1, bar, 7, receive_cb, NULL, 0); + meshlink_channel_t *channel = meshlink_channel_open(mesh_a, b, 7, receive_cb, NULL, 0); assert(channel); - meshlink_set_channel_poll_cb(mesh1, channel, poll_cb); + meshlink_set_channel_poll_cb(mesh_a, channel, poll_cb); // Start both instances - assert(meshlink_start(mesh1)); - assert(meshlink_start(mesh2)); + start_meshlink_pair(mesh_a, mesh_b); // Wait for the channel to be established @@ -117,36 +87,71 @@ int main() { sleep(1); - // Stop mesh2, then try to send data to it. We should get a notification that the channel has closed after a while. + // Set a very small timeout for channels to b. - assert(!check_sync_flag(&receive_flag)); + meshlink_set_node_channel_timeout(mesh_a, b, 1); - meshlink_stop(mesh2); + // Stop mesh_b. We should get a notification that the channel has closed after a while. - assert(meshlink_channel_send(mesh1, channel, "hello", 5) == 5); + meshlink_stop(mesh_b); - assert(wait_sync_flag(&receive_flag, 70)); + assert(wait_sync_flag(&receive_flag, 5)); assert(receive_len == 0); - meshlink_channel_close(mesh1, channel); + meshlink_channel_close(mesh_a, channel); - // Try setting up a new channel while bar is still down. + // Try setting up a new channel while b is still down. - poll_flag.flag = false; - receive_flag.flag = false; + reset_sync_flag(&poll_flag); + reset_sync_flag(&receive_flag); - channel = meshlink_channel_open(mesh1, bar, 7, NULL, NULL, 0); + channel = meshlink_channel_open(mesh_a, b, 7, NULL, NULL, 0); assert(channel); - meshlink_set_channel_poll_cb(mesh1, channel, poll_cb); + meshlink_set_channel_poll_cb(mesh_a, channel, poll_cb); - assert(wait_sync_flag(&poll_flag, 70)); + assert(wait_sync_flag(&poll_flag, 5)); assert(poll_len == 0); - // Clean up. + meshlink_channel_close(mesh_a, channel); + + // Restart b and create a new channel to the wrong port + + reset_sync_flag(&poll_flag); + reset_sync_flag(&receive_flag); - meshlink_close(mesh1); - meshlink_close(mesh2); + meshlink_set_node_channel_timeout(mesh_a, b, 60); + + assert(meshlink_start(mesh_b)); + + channel = meshlink_channel_open(mesh_a, b, 42, receive_cb, NULL, 0); + meshlink_set_channel_poll_cb(mesh_a, channel, poll_cb); + assert(channel); + assert(wait_sync_flag(&poll_flag, 10)); + assert(poll_len == 0); + meshlink_channel_close(mesh_a, channel); + + // Create a channel that will be accepted + + reset_sync_flag(&poll_flag); + + channel = meshlink_channel_open(mesh_a, b, 7, receive_cb, NULL, 0); + meshlink_set_channel_poll_cb(mesh_a, channel, poll_cb); + assert(channel); + assert(wait_sync_flag(&poll_flag, 10)); + assert(poll_len != 0); + + // Close and reopen b, we should get a fast notification that the channel has been closed. + + meshlink_close(mesh_b); + mesh_b = meshlink_open("channels_failure_conf.2", "b", "channels_failure", DEV_CLASS_BACKBONE); + assert(mesh_b); + assert(meshlink_start(mesh_b)); + + assert(wait_sync_flag(&receive_flag, 10)); + assert(receive_len == 0); + + // Clean up. - return 0; + close_meshlink_pair(mesh_a, mesh_b); }