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_add_address(mesh1, "localhost");
  62
  63         char *data = meshlink_export(mesh1);
  64         if(!data) {
  65                 fprintf(stderr, "Foo could not export its configuration\n");
  66                 return 1;
  67         }
  68
  69         size_t len = strlen(data);
  70         write(wfd, &len, sizeof len);
  71         write(wfd, data, len);
  72         free(data);
  73
  74         read(rfd, &len, sizeof len);
  75         char indata[len + 1];
  76         read(rfd, indata, len);
  77         indata[len] = 0;
  78
  79         fprintf(stderr, "Foo exchanged data\n");
  80
  81         meshlink_import(mesh1, indata);
  82
  83         meshlink_set_channel_accept_cb(mesh1, reject_cb);
  84         meshlink_set_node_status_cb(mesh1, status_cb);
  85
  86         if(!meshlink_start(mesh1)) {
  87                 fprintf(stderr, "Foo could not start\n");
  88                 return 1;
  89         }
  90
  91         for(int i = 0; i < 20; i++) {
  92                 sleep(1);
  93                 if(bar_reachable)
  94                         break;
  95         }
  96
  97         if(!bar_reachable) {
  98                 fprintf(stderr, "Bar not reachable for foo after 20 seconds\n");
  99                 return 1;
 100         }
 101
 102         // Open a channel from foo to bar.
 103
 104         meshlink_node_t *bar = meshlink_get_node(mesh1, "bar");
 105         if(!bar) {
 106                 fprintf(stderr, "Foo could not find bar\n");
 107                 return 1;
 108         }
 109
 110         meshlink_channel_t *channel = meshlink_channel_open(mesh1, bar, 7, foo_receive_cb, NULL, 0);
 111         meshlink_set_channel_poll_cb(mesh1, channel, poll_cb);
 112
 113         for(int i = 0; i < 5; i++) {
 114                 sleep(1);
 115                 if(bar_responded)
 116                         break;
 117         }
 118
 119         if(!bar_responded) {
 120                 fprintf(stderr, "Bar did not respond to foo's channel message\n");
 121                 return 1;
 122         }
 123
 124         meshlink_channel_close(mesh1, channel);
 125
 126         // Clean up.
 127
 128         meshlink_close(mesh1);
 129
 130         return 0;
 131 }
 132
 133
 134 int main2(int rfd, int wfd) {
 135         sleep(1);
 136
 137         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 138
 139         meshlink_handle_t *mesh2 = meshlink_open("channels_conf.2", "bar", "channels", DEV_CLASS_BACKBONE);
 140         if(!mesh2) {
 141                 fprintf(stderr, "Could not initialize configuration for bar\n");
 142                 return 1;
 143         }
 144
 145         char *data = meshlink_export(mesh2);
 146         if(!data) {
 147                 fprintf(stderr, "Bar could not export its configuration\n");
 148                 return 1;
 149         }
 150
 151         size_t len = strlen(data);
 152         if(write(wfd, &len, sizeof len) <= 0) abort();
 153         if(write(wfd, data, len) <= 0) abort();
 154         free(data);
 155
 156         read(rfd, &len, sizeof len);
 157         char indata[len + 1];
 158         read(rfd, indata, len);
 159         indata[len] = 0;
 160
 161         fprintf(stderr, "Bar exchanged data\n");
 162
 163         meshlink_import(mesh2, indata);
 164
 165         meshlink_set_channel_accept_cb(mesh2, accept_cb);
 166
 167         if(!meshlink_start(mesh2)) {
 168                 fprintf(stderr, "Bar could not start\n");
 169                 return 1;
 170         }
 171
 172         sleep(20);
 173
 174         // Clean up.
 175
 176         meshlink_close(mesh2);
 177
 178         return 0;
 179 }
 180
 181
 182 int main(int argc, char *argv[]) {
 183         int fda[2], fdb[2], result;
 184
 185         pipe2(fda, 0);
 186         pipe2(fdb, 0);
 187
 188         if(fork())
 189                 return main1(fda[0], fdb[1]);
 190         else
 191                 return main2(fdb[0], fda[1]);
 192 }