]> git.meshlink.io Git - meshlink/blob - test/channels-cornercases.c
Add meshlink_set_invitation_timeout().
[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         pthread_mutex_lock(&channel_opened.mutex);
113
114         meshlink_channel_t *channel = meshlink_channel_open(a, nb, 7, a_receive_cb, NULL, 0);
115         assert(channel);
116
117         channel->priv = &channel_opened;
118         meshlink_set_channel_poll_cb(a, channel, poll_cb);
119
120         // Start MeshLink and wait for the channel to become connected.
121         start_meshlink_pair(a, b);
122
123         assert(wait_sync_flag(&channel_opened, 20));
124
125         // Re-initialize everything
126         close_meshlink_pair(a, b, "channels-cornercases");
127         b_responded = false;
128         b_closed = false;
129         channel_opened.flag = false;
130         open_meshlink_pair(&a, &b, "channels-cornercases");
131
132         meshlink_set_channel_accept_cb(a, reject_cb);
133         meshlink_set_channel_accept_cb(b, accept_cb);
134
135         start_meshlink_pair(a, b);
136
137         // Create a channel to b
138         nb = meshlink_get_node(a, "b");
139         assert(nb);
140
141         channel = meshlink_channel_open(a, nb, 7, a_receive_cb, NULL, 0);
142         assert(channel);
143         channel->priv = &channel_opened;
144         meshlink_set_channel_poll_cb(a, channel, poll_cb);
145
146         assert(wait_sync_flag(&channel_opened, 20));
147
148         assert(!b_responded);
149         assert(!b_closed);
150
151         // Send a message to b
152
153         meshlink_channel_send(a, channel, "Hello", 5);
154
155         sleep(1);
156
157         assert(b_responded);
158         assert(b_closed);
159
160         // Try to create a second channel
161
162         meshlink_channel_t *channel2 = meshlink_channel_open(a, nb, 7, a_receive_cb, NULL, 0);
163         assert(channel2);
164         meshlink_set_channel_poll_cb(a, channel2, poll_cb2);
165
166         sleep(1);
167
168         assert(!a_nonzero_poll_cb);
169
170         return 0;
171 }