]> git.meshlink.io Git - meshlink/blob - test/utils.c
Ignore ADD_EDGE messages we know are outdated.
[meshlink] / test / utils.c
1 #define _GNU_SOURCE
2
3 #ifdef NDEBUG
4 #undef NDEBUG
5 #endif
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <pthread.h>
10 #include <assert.h>
11 #include <errno.h>
12 #include <time.h>
13
14 #include "utils.h"
15
16 void init_sync_flag(struct sync_flag *s) {
17         assert(pthread_mutex_init(&s->mutex, NULL) == 0);
18         assert(pthread_cond_init(&s->cond, NULL) == 0);
19         s->flag = false;
20 }
21
22 void set_sync_flag(struct sync_flag *s, bool value) {
23         assert(pthread_mutex_lock(&s->mutex) == 0);
24         s->flag = value;
25         assert(pthread_cond_broadcast(&s->cond) == 0);
26         assert(pthread_mutex_unlock(&s->mutex) == 0);
27 }
28
29 void reset_sync_flag(struct sync_flag *s) {
30         assert(pthread_mutex_lock(&s->mutex) == 0);
31         s->flag = false;
32         assert(pthread_mutex_unlock(&s->mutex) == 0);
33 }
34
35 bool check_sync_flag(struct sync_flag *s) {
36         bool flag;
37         assert(pthread_mutex_lock(&s->mutex) == 0);
38         flag = s->flag;
39         assert(pthread_mutex_unlock(&s->mutex) == 0);
40         return flag;
41 }
42
43 bool wait_sync_flag(struct sync_flag *s, int seconds) {
44         struct timespec timeout;
45         clock_gettime(CLOCK_REALTIME, &timeout);
46         timeout.tv_sec += seconds;
47
48         assert(pthread_mutex_lock(&s->mutex) == 0);
49
50         while(!s->flag) {
51                 if(!pthread_cond_timedwait(&s->cond, &s->mutex, &timeout) || errno != EINTR) {
52                         break;
53                 }
54         }
55
56         assert(pthread_mutex_unlock(&s->mutex) == 0);
57
58         return s->flag;
59 }
60
61 void link_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
62         // Import and export both side's data
63
64         assert(meshlink_set_canonical_address(a, meshlink_get_self(a), "localhost", NULL));
65         assert(meshlink_set_canonical_address(b, meshlink_get_self(b), "localhost", NULL));
66
67         char *data = meshlink_export(a);
68         assert(data);
69         assert(meshlink_import(b, data));
70         free(data);
71
72         data = meshlink_export(b);
73         assert(data);
74         assert(meshlink_import(a, data));
75         free(data);
76 }
77
78 void open_meshlink_pair(meshlink_handle_t **pa, meshlink_handle_t **pb, const char *prefix) {
79         // Create two new MeshLink instances
80
81         *pa = *pb = NULL;
82
83         char *a_name, *b_name;
84
85         assert(asprintf(&a_name, "%s_conf.1", prefix) > 0);
86         assert(a_name);
87
88         assert(asprintf(&b_name, "%s_conf.2", prefix) > 0);
89         assert(b_name);
90
91         assert(meshlink_destroy(a_name));
92         assert(meshlink_destroy(b_name));
93
94         meshlink_handle_t *a = meshlink_open(a_name, "a", prefix, DEV_CLASS_BACKBONE);
95         assert(a);
96
97         meshlink_handle_t *b = meshlink_open(b_name, "b", prefix, DEV_CLASS_BACKBONE);
98         assert(b);
99
100         free(a_name);
101         free(b_name);
102
103         meshlink_enable_discovery(a, false);
104         meshlink_enable_discovery(b, false);
105
106         link_meshlink_pair(a, b);
107
108         *pa = a;
109         *pb = b;
110 }
111
112 void open_meshlink_pair_ephemeral(meshlink_handle_t **pa, meshlink_handle_t **pb, const char *prefix) {
113         // Create two new MeshLink instances
114
115         *pa = *pb = NULL;
116
117         meshlink_handle_t *a = meshlink_open_ephemeral("a", prefix, DEV_CLASS_BACKBONE);
118         meshlink_handle_t *b = meshlink_open_ephemeral("b", prefix, DEV_CLASS_BACKBONE);
119
120         assert(a);
121         assert(b);
122
123         meshlink_enable_discovery(a, false);
124         meshlink_enable_discovery(b, false);
125
126         link_meshlink_pair(a, b);
127
128         *pa = a;
129         *pb = b;
130 }
131
132 // Don't poll in the application thread, use a condition variable to signal when the peer is online.
133 static void pair_status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
134         (void)node;
135
136         if(reachable && meshlink_get_self(mesh) != node) {
137                 set_sync_flag(mesh->priv, true);
138         }
139 }
140
141 void start_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
142         struct sync_flag pair_status = {.flag = false};
143         init_sync_flag(&pair_status);
144
145         a->priv = &pair_status;
146         meshlink_set_node_status_cb(a, pair_status_cb);
147
148         assert(meshlink_start(a));
149         assert(meshlink_start(b));
150
151         assert(wait_sync_flag(&pair_status, 5));
152
153         meshlink_set_node_status_cb(a, NULL);
154         a->priv = NULL;
155 }
156
157 void stop_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
158         meshlink_stop(a);
159         meshlink_stop(b);
160 }
161
162 void close_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
163         meshlink_close(a);
164         meshlink_close(b);
165 }
166
167 void log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) {
168         static const char *levelstr[] = {
169                 [MESHLINK_DEBUG] = "DEBUG",
170                 [MESHLINK_INFO] = "INFO",
171                 [MESHLINK_WARNING] = "WARNING",
172                 [MESHLINK_ERROR] = "ERROR",
173                 [MESHLINK_CRITICAL] = "CRITICAL",
174         };
175
176         static struct timespec ts0;
177         struct timespec ts;
178
179         clock_gettime(CLOCK_MONOTONIC, &ts);
180
181         if(ts0.tv_sec == 0) {
182                 ts0 = ts;
183         }
184
185         float diff = (ts.tv_sec - ts0.tv_sec) + (ts.tv_nsec - ts0.tv_nsec) * 1e-9;
186
187         fprintf(stderr, "%7.3f (%s) [%s] %s\n",
188                 diff,
189                 mesh ? mesh->name : "",
190                 levelstr[level],
191                 text);
192 }