]> git.meshlink.io Git - meshlink/blob - test/channels-cornercases.c
Test concurrent AIO and non-AIO transfers.
[meshlink] / test / channels-cornercases.c
1 #define _GNU_SOURCE
2
3 #include <stdio.h>
4 #include <unistd.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <sys/time.h>
8 #include <assert.h>
9 #include <pthread.h>
10
11 #include "../src/meshlink.h"
12 #include "utils.h"
13
14 volatile bool b_responded = false;
15 volatile bool b_closed = false;
16 volatile bool a_nonzero_poll_cb = false;
17
18 void log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) {
19         static struct timeval tv0;
20         struct timeval tv;
21
22         if(tv0.tv_sec == 0) {
23                 gettimeofday(&tv0, NULL);
24         }
25
26         gettimeofday(&tv, NULL);
27         fprintf(stderr, "%u.%.03u ", (unsigned int)(tv.tv_sec - tv0.tv_sec), (unsigned int)tv.tv_usec / 1000);
28
29         if(mesh) {
30                 fprintf(stderr, "(%s) ", mesh->name);
31         }
32
33         fprintf(stderr, "[%d] %s\n", level, text);
34 }
35
36 void a_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
37         (void)mesh;
38         (void)channel;
39
40         if(len == 5 && !memcmp(data, "Hello", 5)) {
41                 b_responded = true;
42         } else if(len == 0) {
43                 b_closed = true;
44         }
45 }
46
47 void b_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
48         // Send one message back, then close the channel.
49         if(len) {
50                 meshlink_channel_send(mesh, channel, data, len);
51         }
52
53         meshlink_channel_close(mesh, channel);
54 }
55
56 bool reject_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
57         (void)mesh;
58         (void)channel;
59         (void)port;
60         (void)data;
61         (void)len;
62
63         return false;
64 }
65
66 bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
67         (void)port;
68
69         meshlink_set_channel_accept_cb(mesh, NULL);
70         meshlink_set_channel_receive_cb(mesh, channel, b_receive_cb);
71
72         if(data) {
73                 b_receive_cb(mesh, channel, data, len);
74         }
75
76         return true;
77 }
78
79 void poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t len) {
80         (void)len;
81
82         meshlink_set_channel_poll_cb(mesh, channel, NULL);
83         set_sync_flag(channel->priv, true);
84 }
85
86 void poll_cb2(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t len) {
87         (void)mesh;
88         (void)channel;
89
90         if(len) {
91                 a_nonzero_poll_cb = true;
92         }
93 }
94
95 int main() {
96         meshlink_handle_t *a, *b;
97         open_meshlink_pair(&a, &b, "channels-cornercases");
98         //meshlink_set_log_cb(a, MESHLINK_DEBUG, log_cb);
99         //meshlink_set_log_cb(b, MESHLINK_DEBUG, log_cb);
100
101         // Set the callbacks.
102
103         meshlink_set_channel_accept_cb(a, reject_cb);
104         meshlink_set_channel_accept_cb(b, accept_cb);
105
106         // Open a channel from a to b before starting the mesh.
107
108         meshlink_node_t *nb = meshlink_get_node(a, "b");
109         assert(nb);
110
111         struct sync_flag channel_opened = {.flag = false};
112
113         meshlink_channel_t *channel = meshlink_channel_open(a, nb, 7, a_receive_cb, NULL, 0);
114         assert(channel);
115
116         channel->priv = &channel_opened;
117         meshlink_set_channel_poll_cb(a, channel, poll_cb);
118
119         // Start MeshLink and wait for the channel to become connected.
120         start_meshlink_pair(a, b);
121
122         assert(wait_sync_flag(&channel_opened, 20));
123
124         // Re-initialize everything
125         close_meshlink_pair(a, b, "channels-cornercases");
126         b_responded = false;
127         b_closed = false;
128         channel_opened.flag = false;
129         open_meshlink_pair(&a, &b, "channels-cornercases");
130
131         meshlink_set_channel_accept_cb(a, reject_cb);
132         meshlink_set_channel_accept_cb(b, accept_cb);
133
134         start_meshlink_pair(a, b);
135
136         // Create a channel to b
137         nb = meshlink_get_node(a, "b");
138         assert(nb);
139
140         channel = meshlink_channel_open(a, nb, 7, a_receive_cb, NULL, 0);
141         assert(channel);
142         channel->priv = &channel_opened;
143         meshlink_set_channel_poll_cb(a, channel, poll_cb);
144
145         assert(wait_sync_flag(&channel_opened, 20));
146
147         assert(!b_responded);
148         assert(!b_closed);
149
150         // Send a message to b
151
152         meshlink_channel_send(a, channel, "Hello", 5);
153
154         sleep(1);
155
156         assert(b_responded);
157         assert(b_closed);
158
159         // Try to create a second channel
160
161         meshlink_channel_t *channel2 = meshlink_channel_open(a, nb, 7, a_receive_cb, NULL, 0);
162         assert(channel2);
163         meshlink_set_channel_poll_cb(a, channel2, poll_cb2);
164
165         sleep(1);
166
167         assert(!a_nonzero_poll_cb);
168
169         return 0;
170 }