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

   1 #define _GNU_SOURCE 1
   2 #include <stdio.h>
   3 #include <unistd.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <assert.h>
   7 #include <sys/types.h>
   8 #include <sys/wait.h>
   9 #include <errno.h>
  10
  11 #ifdef __linux__
  12 #include <sys/prctl.h>
  13 #endif
  14
  15 #include "utils.h"
  16 #include "../src/meshlink.h"
  17
  18 static struct sync_flag bar_responded;
  19 static struct sync_flag foo_connected;
  20 static struct sync_flag foo_gone;
  21
  22 static void foo_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
  23         (void)mesh;
  24         (void)channel;
  25         (void)len;
  26
  27         if(len == 5 && !memcmp(data, "Hello", 5)) {
  28                 set_sync_flag(&bar_responded, true);
  29         }
  30 }
  31
  32 static void bar_status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
  33         (void)mesh;
  34
  35         if(!strcmp(node->name, "foo") && !reachable) {
  36                 set_sync_flag(&foo_gone, true);
  37         }
  38 }
  39
  40 static void bar_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
  41         // Echo the data back.
  42         if(len) {
  43                 meshlink_channel_send(mesh, channel, data, len);
  44         } else {
  45                 meshlink_channel_close(mesh, channel);
  46         }
  47 }
  48
  49 static bool reject_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
  50         (void)mesh;
  51         (void)channel;
  52         (void)port;
  53         (void)data;
  54         (void)len;
  55
  56         return false;
  57 }
  58
  59 static bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
  60         if(port != 7) {
  61                 return false;
  62         }
  63
  64         meshlink_set_node_status_cb(mesh, bar_status_cb);
  65         meshlink_set_channel_receive_cb(mesh, channel, bar_receive_cb);
  66         set_sync_flag(&foo_connected, true);
  67
  68         if(data) {
  69                 bar_receive_cb(mesh, channel, data, len);
  70         }
  71
  72         return true;
  73 }
  74
  75 static void poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t len) {
  76         (void)len;
  77
  78         meshlink_set_channel_poll_cb(mesh, channel, NULL);
  79
  80         if(meshlink_channel_send(mesh, channel, "Hello", 5) != 5) {
  81                 fprintf(stderr, "Could not send whole message\n");
  82         }
  83 }
  84
  85 static int main1(int rfd, int wfd) {
  86         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
  87
  88         assert(meshlink_destroy("channels_fork_conf.1"));
  89         meshlink_handle_t *mesh = meshlink_open("channels_fork_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
  90         assert(mesh);
  91
  92         meshlink_enable_discovery(mesh, false);
  93
  94         meshlink_add_address(mesh, "localhost");
  95
  96         char *data = meshlink_export(mesh);
  97         assert(data);
  98
  99         ssize_t len = strlen(data);
 100         assert(write(wfd, &len, sizeof(len)) == sizeof(len));
 101         assert(write(wfd, data, len) == len);
 102         free(data);
 103
 104         assert(read(rfd, &len, sizeof(len)) == sizeof(len));
 105         char indata[len + 1];
 106         assert(read(rfd, indata, len) == len);
 107         indata[len] = 0;
 108
 109         assert(meshlink_import(mesh, indata));
 110
 111         meshlink_set_channel_accept_cb(mesh, reject_cb);
 112
 113         assert(meshlink_start(mesh));
 114
 115         // Open a channel from foo to bar.
 116
 117         meshlink_node_t *bar = meshlink_get_node(mesh, "bar");
 118         assert(bar);
 119
 120         meshlink_channel_t *channel = meshlink_channel_open(mesh, bar, 7, foo_receive_cb, NULL, 0);
 121         assert(channel);
 122
 123         meshlink_set_channel_poll_cb(mesh, channel, poll_cb);
 124
 125         assert(wait_sync_flag(&bar_responded, 20));
 126
 127         meshlink_channel_close(mesh, channel);
 128
 129         // Clean up.
 130
 131         meshlink_close(mesh);
 132
 133         return 0;
 134 }
 135
 136
 137 static int main2(int rfd, int wfd) {
 138 #ifdef __linux__
 139         prctl(PR_SET_PDEATHSIG, SIGTERM);
 140 #endif
 141
 142         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 143
 144         assert(meshlink_destroy("channels_fork_conf.2"));
 145         meshlink_handle_t *mesh = meshlink_open("channels_fork_conf.2", "bar", "channels", DEV_CLASS_BACKBONE);
 146         assert(mesh);
 147
 148         meshlink_enable_discovery(mesh, false);
 149
 150         meshlink_add_address(mesh, "localhost");
 151
 152         char *data = meshlink_export(mesh);
 153         assert(data);
 154
 155         ssize_t len = strlen(data);
 156         assert(write(wfd, &len, sizeof(len)) == sizeof(len));
 157         assert(write(wfd, data, len) == len);
 158         free(data);
 159
 160         assert(read(rfd, &len, sizeof(len)) == sizeof(len));
 161         char indata[len + 1];
 162         assert(read(rfd, indata, len) == len);
 163         indata[len] = 0;
 164
 165         assert(meshlink_import(mesh, indata));
 166
 167         meshlink_set_channel_accept_cb(mesh, accept_cb);
 168
 169         assert(meshlink_start(mesh));
 170
 171         assert(wait_sync_flag(&foo_connected, 20));
 172         assert(wait_sync_flag(&foo_gone, 20));
 173
 174         meshlink_close(mesh);
 175
 176         return 0;
 177 }
 178
 179 static void alarm_handler(int sig) {
 180         (void)sig;
 181         assert(0);
 182 }
 183
 184 int main() {
 185         int fda[2], fdb[2];
 186
 187         assert(pipe2(fda, 0) != -1);
 188         assert(pipe2(fdb, 0) != -1);
 189
 190         if(!fork()) {
 191                 return main2(fdb[0], fda[1]);
 192         }
 193
 194         signal(SIGALRM, alarm_handler);
 195         alarm(30);
 196         assert(main1(fda[0], fdb[1]) == 0);
 197
 198         int wstatus;
 199         assert(wait(&wstatus) != -1 || errno == ECHILD);
 200         assert(WIFEXITED(wstatus));
 201         assert(WEXITSTATUS(wstatus) == 0);
 202 }