#include <unistd.h>
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <errno.h>
-#include "../src/meshlink.h"
-
-volatile bool bar_reachable = false;
-volatile bool bar_responded = false;
+#ifdef __linux__
+#include <sys/prctl.h>
+#endif
-void log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) {
- if(mesh) {
- fprintf(stderr, "(%s) ", mesh->name);
- }
+#include "utils.h"
+#include "../src/meshlink.h"
- fprintf(stderr, "[%d] %s\n", level, text);
-}
+static struct sync_flag bar_responded;
+static struct sync_flag foo_gone;
-void status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
+static void foo_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
(void)mesh;
+ (void)channel;
+ (void)len;
- if(!strcmp(node->name, "bar")) {
- bar_reachable = reachable;
+ if(len == 5 && !memcmp(data, "Hello", 5)) {
+ set_sync_flag(&bar_responded, true);
}
}
-void foo_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
+static void bar_status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
(void)mesh;
- (void)channel;
- (void)len;
- if(len == 5 && !memcmp(data, "Hello", 5)) {
- bar_responded = true;
+ if(!strcmp(node->name, "foo") && !reachable) {
+ set_sync_flag(&foo_gone, true);
}
}
-void bar_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
+static void bar_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
// Echo the data back.
- meshlink_channel_send(mesh, channel, data, len);
+ if(len) {
+ meshlink_channel_send(mesh, channel, data, len);
+ } else {
+ meshlink_channel_close(mesh, channel);
+ }
}
-bool reject_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
+static bool reject_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
(void)mesh;
(void)channel;
(void)port;
return false;
}
-bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
+static bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
if(port != 7) {
return false;
}
+ meshlink_set_node_status_cb(mesh, bar_status_cb);
meshlink_set_channel_receive_cb(mesh, channel, bar_receive_cb);
if(data) {
return true;
}
-void poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t len) {
+static void poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t len) {
(void)len;
meshlink_set_channel_poll_cb(mesh, channel, NULL);
}
}
-int main1(int rfd, int wfd) {
- int ret_val;
- (void)ret_val;
+static int main1(int rfd, int wfd) {
meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
- meshlink_handle_t *mesh1 = meshlink_open("channels_fork_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
-
- if(!mesh1) {
- fprintf(stderr, "Could not initialize configuration for foo\n");
- return 1;
- }
-
- meshlink_enable_discovery(mesh1, false);
+ assert(meshlink_destroy("channels_fork_conf.1"));
+ meshlink_handle_t *mesh = meshlink_open("channels_fork_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
+ assert(mesh);
- meshlink_add_address(mesh1, "localhost");
+ meshlink_enable_discovery(mesh, false);
- char *data = meshlink_export(mesh1);
+ meshlink_add_address(mesh, "localhost");
- if(!data) {
- fprintf(stderr, "Foo could not export its configuration\n");
- return 1;
- }
+ char *data = meshlink_export(mesh);
+ assert(data);
- size_t len = strlen(data);
- ret_val = write(wfd, &len, sizeof(len));
- ret_val = write(wfd, data, len);
+ ssize_t len = strlen(data);
+ assert(write(wfd, &len, sizeof(len)) == sizeof(len));
+ assert(write(wfd, data, len) == len);
free(data);
- ret_val = read(rfd, &len, sizeof(len));
+ assert(read(rfd, &len, sizeof(len)) == sizeof(len));
char indata[len + 1];
- ret_val = read(rfd, indata, len);
+ assert(read(rfd, indata, len) == len);
indata[len] = 0;
- fprintf(stderr, "Foo exchanged data\n");
+ assert(meshlink_import(mesh, indata));
- meshlink_import(mesh1, indata);
+ meshlink_set_channel_accept_cb(mesh, reject_cb);
- meshlink_set_channel_accept_cb(mesh1, reject_cb);
- meshlink_set_node_status_cb(mesh1, status_cb);
-
- if(!meshlink_start(mesh1)) {
- fprintf(stderr, "Foo could not start\n");
- return 1;
- }
-
- for(int i = 0; i < 20; i++) {
- sleep(1);
-
- if(bar_reachable) {
- break;
- }
- }
-
- if(!bar_reachable) {
- fprintf(stderr, "Bar not reachable for foo after 20 seconds\n");
- return 1;
- }
+ assert(meshlink_start(mesh));
// Open a channel from foo to bar.
- meshlink_node_t *bar = meshlink_get_node(mesh1, "bar");
-
- if(!bar) {
- fprintf(stderr, "Foo could not find bar\n");
- return 1;
- }
-
- meshlink_channel_t *channel = meshlink_channel_open(mesh1, bar, 7, foo_receive_cb, NULL, 0);
- meshlink_set_channel_poll_cb(mesh1, channel, poll_cb);
+ meshlink_node_t *bar = meshlink_get_node(mesh, "bar");
+ assert(bar);
- for(int i = 0; i < 5; i++) {
- sleep(1);
+ meshlink_channel_t *channel = meshlink_channel_open(mesh, bar, 7, foo_receive_cb, NULL, 0);
+ assert(channel);
- if(bar_responded) {
- break;
- }
- }
+ meshlink_set_channel_poll_cb(mesh, channel, poll_cb);
- if(!bar_responded) {
- fprintf(stderr, "Bar did not respond to foo's channel message\n");
- return 1;
- }
+ assert(wait_sync_flag(&bar_responded, 20));
- meshlink_channel_close(mesh1, channel);
+ meshlink_channel_close(mesh, channel);
// Clean up.
- meshlink_close(mesh1);
+ meshlink_close(mesh);
return 0;
}
-int main2(int rfd, int wfd) {
- int ret_val;
- (void)ret_val;
- sleep(1);
+static int main2(int rfd, int wfd) {
+#ifdef __linux__
+ prctl(PR_SET_PDEATHSIG, SIGTERM);
+#endif
meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
- meshlink_handle_t *mesh2 = meshlink_open("channels_fork_conf.2", "bar", "channels", DEV_CLASS_BACKBONE);
-
- if(!mesh2) {
- fprintf(stderr, "Could not initialize configuration for bar\n");
- return 1;
- }
-
- meshlink_enable_discovery(mesh2, false);
-
- char *data = meshlink_export(mesh2);
-
- if(!data) {
- fprintf(stderr, "Bar could not export its configuration\n");
- return 1;
- }
+ assert(meshlink_destroy("channels_fork_conf.2"));
+ meshlink_handle_t *mesh = meshlink_open("channels_fork_conf.2", "bar", "channels", DEV_CLASS_BACKBONE);
+ assert(mesh);
- size_t len = strlen(data);
+ meshlink_enable_discovery(mesh, false);
- if(write(wfd, &len, sizeof(len)) <= 0) {
- abort();
- }
+ meshlink_add_address(mesh, "localhost");
- if(write(wfd, data, len) <= 0) {
- abort();
- }
+ char *data = meshlink_export(mesh);
+ assert(data);
+ ssize_t len = strlen(data);
+ assert(write(wfd, &len, sizeof(len)) == sizeof(len));
+ assert(write(wfd, data, len) == len);
free(data);
- ret_val = read(rfd, &len, sizeof(len));
+ assert(read(rfd, &len, sizeof(len)) == sizeof(len));
char indata[len + 1];
- ret_val = read(rfd, indata, len);
+ assert(read(rfd, indata, len) == len);
indata[len] = 0;
- fprintf(stderr, "Bar exchanged data\n");
+ assert(meshlink_import(mesh, indata));
- meshlink_import(mesh2, indata);
+ meshlink_set_channel_accept_cb(mesh, accept_cb);
- meshlink_set_channel_accept_cb(mesh2, accept_cb);
+ assert(meshlink_start(mesh));
- if(!meshlink_start(mesh2)) {
- fprintf(stderr, "Bar could not start\n");
- return 1;
- }
-
- sleep(20);
+ assert(wait_sync_flag(&foo_gone, 20));
- // Clean up.
-
- meshlink_close(mesh2);
+ meshlink_close(mesh);
return 0;
}
+static void alarm_handler(int sig) {
+ (void)sig;
+ assert(0);
+}
int main() {
- int ret_val;
- (void)ret_val;
int fda[2], fdb[2];
- ret_val = pipe2(fda, 0);
- ret_val = pipe2(fdb, 0);
+ assert(pipe2(fda, 0) != -1);
+ assert(pipe2(fdb, 0) != -1);
- if(fork()) {
- return main1(fda[0], fdb[1]);
- } else {
+ if(!fork()) {
return main2(fdb[0], fda[1]);
}
+
+ signal(SIGALRM, alarm_handler);
+ alarm(30);
+ assert(main1(fda[0], fdb[1]) == 0);
+
+ int wstatus;
+ assert(wait(&wstatus) != -1 || errno == ECHILD);
+ assert(WIFEXITED(wstatus));
+ assert(WEXITSTATUS(wstatus) == 0);
}
projects / meshlink / blobdiff