git.meshlink.io Git - meshlink-tiny/blob - test/invite-join.c

   1 #ifdef NDEBUG
   2 #undef NDEBUG
   3 #endif
   4
   5 #include <stdio.h>
   6 #include <unistd.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/time.h>
  10 #include <assert.h>
  11 #include <errno.h>
  12
  13 #include "meshlink-tiny.h"
  14 #include "devtools.h"
  15 #include "utils.h"
  16
  17 static struct sync_flag baz_reachable;
  18 static struct sync_flag seven_reachable;
  19 static struct sync_flag commits_first_flag;
  20
  21 static void status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
  22         (void)mesh;
  23
  24         if(reachable && !strcmp(node->name, "baz")) {
  25                 set_sync_flag(&baz_reachable, true);
  26         }
  27
  28         if(reachable && !strcmp(node->name, "seven")) {
  29                 set_sync_flag(&seven_reachable, true);
  30         }
  31 }
  32
  33 static void invitee_commits_first_cb(bool inviter_first) {
  34         // Check that eight has committed foo's host config file, but foo hasn't committed eight's
  35         assert(access("invite_join_conf.8/current/hosts/foo", F_OK) == 0);
  36         assert(access("invite_join_conf.1/current/hosts/eight", F_OK) == -1 && errno == ENOENT);
  37         set_sync_flag(&commits_first_flag, !inviter_first);
  38 }
  39
  40 static void inviter_commits_first_cb(bool inviter_first) {
  41         // Check that foo has committed nine's host config file, but nine hasn't committed foo's
  42         assert(access("invite_join_conf.1/current/hosts/nine", F_OK) == 0);
  43         assert(access("invite_join_conf.9/current/hosts/foo", F_OK) == -1 && errno == ENOENT);
  44         set_sync_flag(&commits_first_flag, inviter_first);
  45 }
  46
  47 int main(void) {
  48         init_sync_flag(&baz_reachable);
  49         init_sync_flag(&seven_reachable);
  50         init_sync_flag(&commits_first_flag);
  51
  52         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
  53
  54         assert(meshlink_destroy("invite_join_conf.1"));
  55         assert(meshlink_destroy("invite_join_conf.2"));
  56         assert(meshlink_destroy("invite_join_conf.3"));
  57         assert(meshlink_destroy("invite_join_conf.4"));
  58         assert(meshlink_destroy("invite_join_conf.5"));
  59         assert(meshlink_destroy("invite_join_conf.6"));
  60         assert(meshlink_destroy("invite_join_conf.7"));
  61         assert(meshlink_destroy("invite_join_conf.8"));
  62         assert(meshlink_destroy("invite_join_conf.9"));
  63
  64         // Open thee new meshlink instance.
  65
  66         meshlink_handle_t *mesh1 = meshlink_open("invite_join_conf.1", "foo", "invite-join", DEV_CLASS_BACKBONE);
  67         assert(mesh1);
  68
  69         meshlink_handle_t *mesh2 = meshlink_open("invite_join_conf.2", "bar", "invite-join", DEV_CLASS_BACKBONE);
  70         assert(mesh2);
  71
  72         meshlink_handle_t *mesh3 = meshlink_open("invite_join_conf.3", "quux", "invite-join", DEV_CLASS_BACKBONE);
  73         assert(mesh3);
  74
  75         // Have the first instance generate invitations.
  76
  77         meshlink_set_node_status_cb(mesh1, status_cb);
  78
  79         assert(meshlink_set_canonical_address(mesh1, meshlink_get_self(mesh1), "localhost", NULL));
  80
  81         char *baz_url = meshlink_invite(mesh1, NULL, "baz");
  82         assert(baz_url);
  83
  84         char *quux_url = meshlink_invite(mesh1, NULL, "quux");
  85         assert(quux_url);
  86
  87         // Check that the second instances cannot join if it is already started
  88
  89         assert(meshlink_start(mesh1));
  90         assert(meshlink_start(mesh2));
  91         meshlink_errno = MESHLINK_OK;
  92         assert(!meshlink_join(mesh2, baz_url));
  93         assert(meshlink_errno = MESHLINK_EINVAL);
  94
  95         // Have the second instance join the first.
  96
  97         meshlink_stop(mesh2);
  98         assert(meshlink_join(mesh2, baz_url));
  99         assert(meshlink_start(mesh2));
 100
 101         // Wait for the two to connect.
 102
 103         assert(wait_sync_flag(&baz_reachable, 20));
 104
 105         // Wait for UDP communication to become possible.
 106
 107         int pmtu = meshlink_get_pmtu(mesh1, meshlink_get_node(mesh1, "baz"));
 108
 109         for(int i = 0; i < 10 && !pmtu; i++) {
 110                 sleep(1);
 111                 pmtu = meshlink_get_pmtu(mesh1, meshlink_get_node(mesh1, "baz"));
 112         }
 113
 114         assert(pmtu);
 115
 116         // Check that an invitation cannot be used twice
 117
 118         assert(!meshlink_join(mesh3, baz_url));
 119         free(baz_url);
 120
 121         // Check that nodes cannot join with expired invitations
 122
 123         meshlink_set_invitation_timeout(mesh1, 0);
 124
 125         assert(!meshlink_join(mesh3, quux_url));
 126         free(quux_url);
 127
 128         // Check that existing nodes cannot join another mesh
 129
 130         char *corge_url = meshlink_invite(mesh3, NULL, "corge");
 131         assert(corge_url);
 132
 133         assert(meshlink_start(mesh3));
 134
 135         meshlink_stop(mesh2);
 136
 137         assert(!meshlink_join(mesh2, corge_url));
 138         free(corge_url);
 139
 140         // Check that invitations work correctly after changing ports
 141
 142         meshlink_set_invitation_timeout(mesh1, 86400);
 143         meshlink_stop(mesh1);
 144         meshlink_stop(mesh3);
 145
 146         int oldport = meshlink_get_port(mesh1);
 147         bool success = false;
 148
 149         for(int i = 0; !success && i < 100; i++) {
 150                 success = meshlink_set_port(mesh1, 0x9000 + rand() % 0x1000);
 151         }
 152
 153         assert(success);
 154         int newport = meshlink_get_port(mesh1);
 155         assert(oldport != newport);
 156
 157         assert(meshlink_set_canonical_address(mesh1, meshlink_get_self(mesh1), "localhost", NULL));
 158
 159         assert(meshlink_start(mesh1));
 160         quux_url = meshlink_invite(mesh1, NULL, "quux");
 161         assert(quux_url);
 162
 163         // The old port should not be in the invitation URL
 164
 165         char portstr[10];
 166         snprintf(portstr, sizeof(portstr), ":%d", oldport);
 167         assert(!strstr(quux_url, portstr));
 168
 169         // The new port should be in the invitation URL
 170
 171         snprintf(portstr, sizeof(portstr), ":%d", newport);
 172         assert(strstr(quux_url, portstr));
 173
 174         // The invitation should work
 175
 176         assert(meshlink_join(mesh3, quux_url));
 177         free(quux_url);
 178
 179         // Check that adding duplicate addresses get removed correctly
 180
 181         assert(meshlink_add_invitation_address(mesh1, "localhost", portstr + 1));
 182         corge_url = meshlink_invite(mesh1, NULL, "corge");
 183         assert(corge_url);
 184         char *localhost = strstr(corge_url, "localhost");
 185         assert(localhost);
 186         assert(!strstr(localhost + 1, "localhost"));
 187         free(corge_url);
 188
 189         // Check that resetting and adding multiple, different invitation address works
 190
 191         meshlink_clear_invitation_addresses(mesh1);
 192         assert(meshlink_add_invitation_address(mesh1, "1.invalid.", "12345"));
 193         assert(meshlink_add_invitation_address(mesh1, "2.invalid.", NULL));
 194         assert(meshlink_add_invitation_address(mesh1, "3.invalid.", NULL));
 195         assert(meshlink_add_invitation_address(mesh1, "4.invalid.", NULL));
 196         assert(meshlink_add_invitation_address(mesh1, "5.invalid.", NULL));
 197         char *grault_url = meshlink_invite(mesh1, NULL, "grault");
 198         assert(grault_url);
 199         localhost = strstr(grault_url, "localhost");
 200         assert(localhost);
 201         char *invalid1 = strstr(grault_url, "1.invalid.:12345");
 202         assert(invalid1);
 203         char *invalid5 = strstr(grault_url, "5.invalid.");
 204         assert(invalid5);
 205
 206         // Check that explicitly added invitation addresses come before others, in the order they were specified.
 207
 208         assert(invalid1 < invalid5);
 209         assert(invalid5 < localhost);
 210         free(grault_url);
 211
 212         // Check inviting nodes into a submesh
 213
 214         assert(!meshlink_get_node_submesh(mesh1, meshlink_get_self(mesh1)));
 215
 216         meshlink_handle_t *mesh4 = meshlink_open("invite_join_conf.4", "four", "invite-join", DEV_CLASS_BACKBONE);
 217         meshlink_handle_t *mesh5 = meshlink_open("invite_join_conf.5", "five", "invite-join", DEV_CLASS_BACKBONE);
 218         meshlink_handle_t *mesh6 = meshlink_open("invite_join_conf.6", "six", "invite-join", DEV_CLASS_BACKBONE);
 219         assert(mesh4);
 220         assert(mesh5);
 221         assert(mesh6);
 222
 223         meshlink_enable_discovery(mesh4, false);
 224         meshlink_enable_discovery(mesh5, false);
 225         meshlink_enable_discovery(mesh6, false);
 226
 227         meshlink_submesh_t *submesh1 = meshlink_submesh_open(mesh1, "submesh1");
 228         meshlink_submesh_t *submesh2 = meshlink_submesh_open(mesh1, "submesh2");
 229         assert(submesh1);
 230         assert(submesh2);
 231
 232         char *four_url = meshlink_invite(mesh1, submesh1, mesh4->name);
 233         char *five_url = meshlink_invite(mesh1, submesh1, mesh5->name);
 234         char *six_url = meshlink_invite(mesh1, submesh2, mesh6->name);
 235         assert(four_url);
 236         assert(five_url);
 237         assert(six_url);
 238
 239         assert(meshlink_join(mesh4, four_url));
 240         assert(meshlink_join(mesh5, five_url));
 241         assert(meshlink_join(mesh6, six_url));
 242
 243         free(four_url);
 244         free(five_url);
 245         free(six_url);
 246
 247         assert(meshlink_start(mesh2));
 248         assert(meshlink_start(mesh4));
 249         assert(meshlink_start(mesh5));
 250         assert(meshlink_start(mesh6));
 251
 252         // Check that each node knows in which submesh it is
 253
 254         meshlink_submesh_t *mesh4_submesh = meshlink_get_node_submesh(mesh4, meshlink_get_self(mesh4));
 255         meshlink_submesh_t *mesh5_submesh = meshlink_get_node_submesh(mesh4, meshlink_get_self(mesh5));
 256         meshlink_submesh_t *mesh6_submesh = meshlink_get_node_submesh(mesh6, meshlink_get_self(mesh6));
 257         assert(mesh4_submesh);
 258         assert(mesh5_submesh);
 259         assert(mesh6_submesh);
 260         assert(!strcmp(mesh4_submesh->name, "submesh1"));
 261         assert(!strcmp(mesh5_submesh->name, "submesh1"));
 262         assert(!strcmp(mesh6_submesh->name, "submesh2"));
 263
 264         // Wait for nodes to connect, and check that foo sees the right submeshes
 265
 266         sleep(2);
 267         meshlink_node_t *mesh1_four = meshlink_get_node(mesh1, mesh4->name);
 268         meshlink_node_t *mesh1_six = meshlink_get_node(mesh1, mesh6->name);
 269         assert(meshlink_get_node_submesh(mesh1, meshlink_get_self(mesh1)) == NULL);
 270         assert(meshlink_get_node_submesh(mesh1, mesh1_four) == submesh1);
 271         assert(meshlink_get_node_submesh(mesh1, mesh1_six) == submesh2);
 272
 273         // Check that the new invitees still have the right submesh information
 274
 275         meshlink_node_t *mesh4_four = meshlink_get_node(mesh4, mesh4->name);
 276         meshlink_node_t *mesh4_five = meshlink_get_node(mesh4, mesh5->name);
 277         meshlink_node_t *mesh6_six = meshlink_get_node(mesh6, mesh6->name);
 278         assert(meshlink_get_node_submesh(mesh4, mesh4_four) == mesh4_submesh);
 279         assert(meshlink_get_node_submesh(mesh4, mesh4_five) == mesh4_submesh);
 280         assert(meshlink_get_node_submesh(mesh6, mesh6_six) == mesh6_submesh);
 281
 282         // Check that bar can see all the nodes in submeshes and vice versa
 283
 284         assert(meshlink_get_node(mesh2, mesh4->name));
 285         assert(meshlink_get_node(mesh2, mesh5->name));
 286         assert(meshlink_get_node(mesh2, mesh6->name));
 287         assert(meshlink_get_node(mesh4, mesh2->name));
 288         assert(meshlink_get_node(mesh5, mesh2->name));
 289         assert(meshlink_get_node(mesh6, mesh2->name));
 290
 291         // Check that four and five can see each other
 292
 293         assert(meshlink_get_node(mesh4, mesh5->name));
 294         assert(meshlink_get_node(mesh5, mesh4->name));
 295
 296         // Check that the nodes in different submeshes cannot see each other
 297
 298         assert(!meshlink_get_node(mesh4, mesh6->name));
 299         assert(!meshlink_get_node(mesh5, mesh6->name));
 300         assert(!meshlink_get_node(mesh6, mesh4->name));
 301         assert(!meshlink_get_node(mesh6, mesh5->name));
 302
 303         // Check that bar sees the right submesh information for the nodes in submeshes
 304
 305         meshlink_submesh_t *mesh2_four_submesh = meshlink_get_node_submesh(mesh2, meshlink_get_node(mesh2, mesh4->name));
 306         meshlink_submesh_t *mesh2_five_submesh = meshlink_get_node_submesh(mesh2, meshlink_get_node(mesh2, mesh5->name));
 307         meshlink_submesh_t *mesh2_six_submesh = meshlink_get_node_submesh(mesh2, meshlink_get_node(mesh2, mesh6->name));
 308         assert(mesh2_four_submesh);
 309         assert(mesh2_five_submesh);
 310         assert(mesh2_six_submesh);
 311         assert(!strcmp(mesh2_four_submesh->name, "submesh1"));
 312         assert(!strcmp(mesh2_five_submesh->name, "submesh1"));
 313         assert(!strcmp(mesh2_six_submesh->name, "submesh2"));
 314
 315         // Test case #2: check invalid parameters
 316
 317         meshlink_handle_t *mesh7 = meshlink_open("invite_join_conf.7", "seven", "invite-join", DEV_CLASS_BACKBONE);
 318         assert(mesh7);
 319         meshlink_enable_discovery(mesh7, false);
 320         char *seven_url = meshlink_invite(mesh1, NULL, "seven");
 321         assert(seven_url);
 322
 323         meshlink_errno = MESHLINK_OK;
 324         assert(!meshlink_invite(NULL, NULL, "seven"));
 325         assert(meshlink_errno == MESHLINK_EINVAL);
 326
 327         meshlink_errno = MESHLINK_OK;
 328         assert(!meshlink_invite(mesh1, NULL, NULL));
 329         assert(meshlink_errno == MESHLINK_EINVAL);
 330
 331         meshlink_errno = MESHLINK_OK;
 332         assert(!meshlink_invite(mesh1, NULL, ""));
 333         assert(meshlink_errno == MESHLINK_EINVAL);
 334
 335         meshlink_errno = MESHLINK_OK;
 336         assert(!meshlink_join(NULL, seven_url));
 337         assert(meshlink_errno == MESHLINK_EINVAL);
 338
 339         meshlink_errno = MESHLINK_OK;
 340         assert(!meshlink_join(mesh7, NULL));
 341         assert(meshlink_errno == MESHLINK_EINVAL);
 342
 343         meshlink_errno = MESHLINK_OK;
 344         assert(!meshlink_join(mesh7, ""));
 345         assert(meshlink_errno == MESHLINK_EINVAL);
 346
 347         // Test case #3 and #4: check persistence of inviter and invitee
 348
 349         assert(meshlink_join(mesh7, seven_url));
 350         free(seven_url);
 351         meshlink_close(mesh1);
 352         meshlink_stop(mesh2);
 353         meshlink_stop(mesh3);
 354         meshlink_stop(mesh4);
 355         meshlink_stop(mesh5);
 356         meshlink_stop(mesh6);
 357         meshlink_close(mesh7);
 358         mesh1 = meshlink_open("invite_join_conf.1", "foo", "invite-join", DEV_CLASS_BACKBONE);
 359         mesh7 = meshlink_open("invite_join_conf.7", "seven", "invite-join", DEV_CLASS_BACKBONE);
 360         assert(mesh1);
 361         assert(mesh7);
 362         meshlink_enable_discovery(mesh1, false);
 363         meshlink_enable_discovery(mesh7, false);
 364         meshlink_set_node_status_cb(mesh1, status_cb);
 365         assert(meshlink_start(mesh1));
 366         assert(meshlink_start(mesh7));
 367         assert(wait_sync_flag(&seven_reachable, 5));
 368         meshlink_stop(mesh7);
 369
 370         // Test case #6 and #7: check invalid inviter_commits_first combinations
 371
 372         meshlink_handle_t *mesh8 = meshlink_open("invite_join_conf.8", "eight", "invite-join", DEV_CLASS_BACKBONE);
 373         assert(mesh8);
 374         meshlink_enable_discovery(mesh8, false);
 375         char *eight_url = meshlink_invite(mesh1, NULL, "eight");
 376         assert(eight_url);
 377         meshlink_set_inviter_commits_first(mesh1, true);
 378         meshlink_set_inviter_commits_first(mesh8, false);
 379         assert(!meshlink_join(mesh8, eight_url));
 380         free(eight_url);
 381
 382         eight_url = meshlink_invite(mesh1, NULL, "eight");
 383         meshlink_set_inviter_commits_first(mesh1, false);
 384         meshlink_set_inviter_commits_first(mesh8, true);
 385         assert(!meshlink_join(mesh8, eight_url));
 386         free(eight_url);
 387
 388         // Test case #5: test invitee committing first scenario
 389
 390         eight_url = meshlink_invite(mesh1, NULL, "eight");
 391         meshlink_set_inviter_commits_first(mesh1, false);
 392         meshlink_set_inviter_commits_first(mesh8, false);
 393         devtool_set_inviter_commits_first = invitee_commits_first_cb;
 394         assert(meshlink_join(mesh8, eight_url));
 395         free(eight_url);
 396         assert(wait_sync_flag(&commits_first_flag, 5));
 397
 398         // Test case #6: test inviter committing first scenario
 399
 400         meshlink_handle_t *mesh9 = meshlink_open("invite_join_conf.9", "nine", "invite-join", DEV_CLASS_BACKBONE);
 401         assert(mesh9);
 402         meshlink_enable_discovery(mesh9, false);
 403         char *nine_url = meshlink_invite(mesh1, NULL, "nine");
 404         meshlink_set_inviter_commits_first(mesh1, true);
 405         meshlink_set_inviter_commits_first(mesh9, true);
 406         devtool_set_inviter_commits_first = inviter_commits_first_cb;
 407         reset_sync_flag(&commits_first_flag);
 408         assert(meshlink_join(mesh9, nine_url));
 409         free(nine_url);
 410         assert(wait_sync_flag(&commits_first_flag, 5));
 411
 412         // Clean up.
 413
 414         meshlink_close(mesh9);
 415         meshlink_close(mesh8);
 416         meshlink_close(mesh7);
 417         meshlink_close(mesh6);
 418         meshlink_close(mesh5);
 419         meshlink_close(mesh4);
 420         meshlink_close(mesh3);
 421         meshlink_close(mesh2);
 422         meshlink_close(mesh1);
 423 }