git.meshlink.io Git - meshlink/blob - test/channels-failure.c

   1 #ifdef NDEBUG
   2 #undef NDEBUG
   3 #endif
   4
   5 #include <stdio.h>
   6 #include <unistd.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/time.h>
  10 #include <assert.h>
  11
  12 #include "../src/meshlink.h"
  13 #include "utils.h"
  14
  15 static bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
  16         (void)mesh;
  17         (void)channel;
  18         (void)port;
  19         (void)data;
  20         (void)len;
  21
  22         return true;
  23 }
  24
  25 static struct sync_flag poll_flag;
  26 static size_t poll_len;
  27
  28 static void poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t len) {
  29         meshlink_set_channel_poll_cb(mesh, channel, NULL);
  30         poll_len = len;
  31         set_sync_flag(&poll_flag, true);
  32 }
  33
  34 static struct sync_flag receive_flag;
  35 static size_t receive_len;
  36
  37 static void receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
  38         (void)mesh;
  39         (void)channel;
  40         (void)data;
  41
  42         receive_len = len;
  43         set_sync_flag(&receive_flag, true);
  44 }
  45
  46 int main(void) {
  47         init_sync_flag(&poll_flag);
  48         init_sync_flag(&receive_flag);
  49
  50         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
  51
  52         // Open two meshlink instances.
  53
  54         meshlink_handle_t *mesh_a, *mesh_b;
  55         open_meshlink_pair(&mesh_a, &mesh_b, "channels_failure");
  56
  57         // Set the callbacks.
  58
  59         meshlink_set_channel_accept_cb(mesh_b, accept_cb);
  60
  61         // Open a channel from a to b
  62
  63         meshlink_node_t *b = meshlink_get_node(mesh_a, "b");
  64         assert(b);
  65
  66         meshlink_channel_t *channel = meshlink_channel_open(mesh_a, b, 7, receive_cb, NULL, 0);
  67         assert(channel);
  68
  69         meshlink_set_channel_poll_cb(mesh_a, channel, poll_cb);
  70
  71         // Start both instances
  72
  73         start_meshlink_pair(mesh_a, mesh_b);
  74
  75         // Wait for the channel to be established
  76
  77         assert(wait_sync_flag(&poll_flag, 10));
  78         assert(poll_len != 0);
  79
  80         sleep(1);
  81
  82         // Set a very small timeout for channels to b.
  83
  84         meshlink_set_node_channel_timeout(mesh_a, b, 1);
  85
  86         // Stop mesh_b. We should get a notification that the channel has closed after a while.
  87
  88         meshlink_stop(mesh_b);
  89
  90         assert(wait_sync_flag(&receive_flag, 5));
  91         assert(receive_len == 0);
  92
  93         meshlink_channel_close(mesh_a, channel);
  94
  95         // Try setting up a new channel while b is still down.
  96
  97         set_sync_flag(&poll_flag, false);
  98         set_sync_flag(&receive_flag, false);
  99
 100         channel = meshlink_channel_open(mesh_a, b, 7, NULL, NULL, 0);
 101         assert(channel);
 102
 103         meshlink_set_channel_poll_cb(mesh_a, channel, poll_cb);
 104
 105         assert(wait_sync_flag(&poll_flag, 5));
 106         assert(poll_len == 0);
 107
 108         meshlink_channel_close(mesh_a, channel);
 109
 110         // Restart b and create a new channel
 111
 112         set_sync_flag(&poll_flag, false);
 113         set_sync_flag(&receive_flag, false);
 114
 115         meshlink_set_node_channel_timeout(mesh_a, b, 60);
 116
 117         assert(meshlink_start(mesh_b));
 118
 119         channel = meshlink_channel_open(mesh_a, b, 7, receive_cb, NULL, 0);
 120         meshlink_set_channel_poll_cb(mesh_a, channel, poll_cb);
 121         assert(channel);
 122         assert(wait_sync_flag(&poll_flag, 10));
 123         assert(poll_len != 0);
 124
 125         // Close and reopen b, we should get a fast notification that the channel has been closed.
 126
 127         meshlink_close(mesh_b);
 128         mesh_b = meshlink_open("channels_failure_conf.2", "b", "channels_failure", DEV_CLASS_BACKBONE);
 129         assert(mesh_b);
 130         assert(meshlink_start(mesh_b));
 131
 132         assert(wait_sync_flag(&receive_flag, 10));
 133         assert(receive_len == 0);
 134
 135         // Clean up.
 136
 137         close_meshlink_pair(mesh_a, mesh_b);
 138 }