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

   1 #define _GNU_SOURCE
   2 #include <stdio.h>
   3 #include <unistd.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include "../src/meshlink.h"
   8
   9 volatile bool bar_reachable = false;
  10 volatile bool bar_responded = false;
  11
  12 void log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) {
  13         if(mesh) {
  14                 fprintf(stderr, "(%s) ", mesh->name);
  15         }
  16
  17         fprintf(stderr, "[%d] %s\n", level, text);
  18 }
  19
  20 void status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
  21         if(!strcmp(node->name, "bar")) {
  22                 bar_reachable = reachable;
  23         }
  24 }
  25
  26 void foo_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
  27         if(len == 5 && !memcmp(data, "Hello", 5)) {
  28                 bar_responded = true;
  29         }
  30 }
  31
  32 void bar_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
  33         // Echo the data back.
  34         meshlink_channel_send(mesh, channel, data, len);
  35 }
  36
  37 bool reject_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
  38         return false;
  39 }
  40
  41 bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
  42         if(port != 7) {
  43                 return false;
  44         }
  45
  46         meshlink_set_channel_receive_cb(mesh, channel, bar_receive_cb);
  47
  48         if(data) {
  49                 bar_receive_cb(mesh, channel, data, len);
  50         }
  51
  52         return true;
  53 }
  54
  55 void poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t len) {
  56         meshlink_set_channel_poll_cb(mesh, channel, NULL);
  57
  58         if(meshlink_channel_send(mesh, channel, "Hello", 5) != 5) {
  59                 fprintf(stderr, "Could not send whole message\n");
  60         }
  61 }
  62
  63 int main1(int rfd, int wfd) {
  64         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
  65
  66         meshlink_handle_t *mesh1 = meshlink_open("channels_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
  67
  68         if(!mesh1) {
  69                 fprintf(stderr, "Could not initialize configuration for foo\n");
  70                 return 1;
  71         }
  72
  73         meshlink_enable_discovery(mesh1, false);
  74
  75         meshlink_add_address(mesh1, "localhost");
  76
  77         char *data = meshlink_export(mesh1);
  78
  79         if(!data) {
  80                 fprintf(stderr, "Foo could not export its configuration\n");
  81                 return 1;
  82         }
  83
  84         size_t len = strlen(data);
  85         write(wfd, &len, sizeof(len));
  86         write(wfd, data, len);
  87         free(data);
  88
  89         read(rfd, &len, sizeof(len));
  90         char indata[len + 1];
  91         read(rfd, indata, len);
  92         indata[len] = 0;
  93
  94         fprintf(stderr, "Foo exchanged data\n");
  95
  96         meshlink_import(mesh1, indata);
  97
  98         meshlink_set_channel_accept_cb(mesh1, reject_cb);
  99         meshlink_set_node_status_cb(mesh1, status_cb);
 100
 101         if(!meshlink_start(mesh1)) {
 102                 fprintf(stderr, "Foo could not start\n");
 103                 return 1;
 104         }
 105
 106         for(int i = 0; i < 20; i++) {
 107                 sleep(1);
 108
 109                 if(bar_reachable) {
 110                         break;
 111                 }
 112         }
 113
 114         if(!bar_reachable) {
 115                 fprintf(stderr, "Bar not reachable for foo after 20 seconds\n");
 116                 return 1;
 117         }
 118
 119         // Open a channel from foo to bar.
 120
 121         meshlink_node_t *bar = meshlink_get_node(mesh1, "bar");
 122
 123         if(!bar) {
 124                 fprintf(stderr, "Foo could not find bar\n");
 125                 return 1;
 126         }
 127
 128         meshlink_channel_t *channel = meshlink_channel_open(mesh1, bar, 7, foo_receive_cb, NULL, 0);
 129         meshlink_set_channel_poll_cb(mesh1, channel, poll_cb);
 130
 131         for(int i = 0; i < 5; i++) {
 132                 sleep(1);
 133
 134                 if(bar_responded) {
 135                         break;
 136                 }
 137         }
 138
 139         if(!bar_responded) {
 140                 fprintf(stderr, "Bar did not respond to foo's channel message\n");
 141                 return 1;
 142         }
 143
 144         meshlink_channel_close(mesh1, channel);
 145
 146         // Clean up.
 147
 148         meshlink_close(mesh1);
 149
 150         return 0;
 151 }
 152
 153
 154 int main2(int rfd, int wfd) {
 155         sleep(1);
 156
 157         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 158
 159         meshlink_handle_t *mesh2 = meshlink_open("channels_conf.2", "bar", "channels", DEV_CLASS_BACKBONE);
 160
 161         if(!mesh2) {
 162                 fprintf(stderr, "Could not initialize configuration for bar\n");
 163                 return 1;
 164         }
 165
 166         meshlink_enable_discovery(mesh2, false);
 167
 168         char *data = meshlink_export(mesh2);
 169
 170         if(!data) {
 171                 fprintf(stderr, "Bar could not export its configuration\n");
 172                 return 1;
 173         }
 174
 175         size_t len = strlen(data);
 176
 177         if(write(wfd, &len, sizeof(len)) <= 0) {
 178                 abort();
 179         }
 180
 181         if(write(wfd, data, len) <= 0) {
 182                 abort();
 183         }
 184
 185         free(data);
 186
 187         read(rfd, &len, sizeof(len));
 188         char indata[len + 1];
 189         read(rfd, indata, len);
 190         indata[len] = 0;
 191
 192         fprintf(stderr, "Bar exchanged data\n");
 193
 194         meshlink_import(mesh2, indata);
 195
 196         meshlink_set_channel_accept_cb(mesh2, accept_cb);
 197
 198         if(!meshlink_start(mesh2)) {
 199                 fprintf(stderr, "Bar could not start\n");
 200                 return 1;
 201         }
 202
 203         sleep(20);
 204
 205         // Clean up.
 206
 207         meshlink_close(mesh2);
 208
 209         return 0;
 210 }
 211
 212
 213 int main(int argc, char *argv[]) {
 214         int fda[2], fdb[2];
 215
 216         pipe2(fda, 0);
 217         pipe2(fdb, 0);
 218
 219         if(fork()) {
 220                 return main1(fda[0], fdb[1]);
 221         } else {
 222                 return main2(fdb[0], fda[1]);
 223         }
 224 }