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