git.meshlink.io Git - meshlink/blob - test/echo-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         fprintf(stderr, "Foo received from Bar:\n%s", (char*)data);
  25         fprintf(stderr, "==============================\n");
  26         fprintf(stderr, "%s", (char*)data );
  27         fprintf(stdout, "%s", (char*)data );
  28 }
  29
  30 void bar_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
  31         // Echo the data back.
  32         fprintf(stderr, "Bar received:\n%s", (char*)data);
  33         fprintf(stderr, "==============================\n");
  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         meshlink_set_channel_receive_cb(mesh, channel, bar_receive_cb);
  45         if(data)
  46                 bar_receive_cb(mesh, channel, data, len);
  47         return true;
  48 }
  49
  50 void poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t len) {
  51         meshlink_set_channel_poll_cb(mesh, channel, NULL);
  52         bar_responded=true;
  53 }
  54
  55 int main1(int rfd, int wfd) {
  56         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
  57
  58         meshlink_handle_t *mesh1 = meshlink_open("channels_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
  59         if(!mesh1) {
  60                 fprintf(stderr, "Could not initialize configuration for foo\n");
  61                 return 1;
  62         }
  63
  64         meshlink_add_address(mesh1, "localhost");
  65
  66         char *data = meshlink_export(mesh1);
  67         if(!data) {
  68                 fprintf(stderr, "Foo could not export its configuration\n");
  69                 return 1;
  70         }
  71
  72         size_t len = strlen(data);
  73         write(wfd, &len, sizeof len);
  74         write(wfd, data, len);
  75         free(data);
  76
  77         read(rfd, &len, sizeof len);
  78         char indata[len + 1];
  79         read(rfd, indata, len);
  80         indata[len] = 0;
  81
  82         fprintf(stderr, "Foo exchanged data\n");
  83
  84         meshlink_import(mesh1, indata);
  85
  86         meshlink_set_channel_accept_cb(mesh1, reject_cb);
  87         meshlink_set_node_status_cb(mesh1, status_cb);
  88
  89         if(!meshlink_start(mesh1)) {
  90                 fprintf(stderr, "Foo could not start\n");
  91                 return 1;
  92         }
  93
  94         for(int i = 0; i < 20; i++) {
  95                 sleep(1);
  96                 if(bar_reachable)
  97                         break;
  98         }
  99
 100         if(!bar_reachable) {
 101                 fprintf(stderr, "Bar not reachable for foo after 20 seconds\n");
 102                 return 1;
 103         }
 104
 105         // Open a channel from foo to bar.
 106
 107         meshlink_node_t *bar = meshlink_get_node(mesh1, "bar");
 108         if(!bar) {
 109                 fprintf(stderr, "Foo could not find bar\n");
 110                 return 1;
 111         }
 112
 113         meshlink_channel_t *channel = meshlink_channel_open(mesh1, bar, 7, foo_receive_cb, NULL, 0);
 114         meshlink_set_channel_poll_cb(mesh1, channel, poll_cb);
 115
 116         // read and buffer stdin
 117         int BUF_SIZE = 1024;
 118         char buffer[BUF_SIZE];
 119         size_t contentSize = 1;
 120         char *content = malloc( sizeof(char) * BUF_SIZE );
 121         if (!content) {
 122                 fprintf(stderr, "Could not allocate buffer\n");
 123         }
 124
 125         fprintf(stderr, "Foo reading from stdin...\n");
 126         content[0] = '\0';
 127         while(fgets(buffer,BUF_SIZE,stdin)) {
 128                 char *old = content;
 129                 contentSize += strlen(buffer);
 130                 content = realloc(content, contentSize);
 131                 strcat(content,buffer);
 132         }
 133
 134         for(int i = 0; i < 5; i++) {
 135                 sleep(1);
 136                 if(bar_responded)
 137                         break;
 138         }
 139
 140         if(!bar_responded) {
 141                 fprintf(stderr, "Bar did not respond to foo's channel message\n");
 142                 return 1;
 143         }
 144
 145         fprintf(stderr, "Foo sending:\n%s", content);
 146         fprintf(stderr, "==============================\n");
 147
 148         if(meshlink_channel_send(mesh1, channel, content, contentSize) != contentSize)
 149                 fprintf(stderr, "Could not send whole message\n");
 150
 151         sleep(20);
 152
 153         free(content);
 154
 155         meshlink_channel_close(mesh1, channel);
 156
 157         // Clean up.
 158
 159         meshlink_close(mesh1);
 160
 161         return 0;
 162 }
 163
 164
 165 int main2(int rfd, int wfd) {
 166         sleep(1);
 167
 168         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 169
 170         meshlink_handle_t *mesh2 = meshlink_open("channels_conf.2", "bar", "channels", DEV_CLASS_BACKBONE);
 171         if(!mesh2) {
 172                 fprintf(stderr, "Could not initialize configuration for bar\n");
 173                 return 1;
 174         }
 175
 176         char *data = meshlink_export(mesh2);
 177         if(!data) {
 178                 fprintf(stderr, "Bar could not export its configuration\n");
 179                 return 1;
 180         }
 181
 182         size_t len = strlen(data);
 183         if(write(wfd, &len, sizeof len) <= 0) abort();
 184         if(write(wfd, data, len) <= 0) abort();
 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], result;
 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 }