X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fmeshlink.c;h=69ab8f244ef1e715e171b2b13fd8ff521fb27dab;hb=703197ca7614963ba9b831967352b6c90379af48;hp=42573c8ffa6f68837fb1e06f3a567f0baefbdbd9;hpb=c023ad12147aa88810629c110ea6b1ab94267196;p=meshlink diff --git a/src/meshlink.c b/src/meshlink.c index 42573c8f..69ab8f24 100644 --- a/src/meshlink.c +++ b/src/meshlink.c @@ -333,7 +333,7 @@ void remove_duplicate_hostnames(char *host[], char *port[], int n) { break; } - if(found) { + if(found || !is_valid_hostname(host[i])) { free(host[i]); free(port[i]); host[i] = NULL; @@ -417,7 +417,7 @@ static char *get_my_hostname(meshlink_handle_t *mesh, uint32_t flags) { char resolved_port[NI_MAXSERV]; err = getnameinfo(ai_in->ai_addr, ai_in->ai_addrlen, resolved_host, sizeof resolved_host, resolved_port, sizeof resolved_port, NI_NUMERICSERV); - if(err) { + if(err || !is_valid_hostname(resolved_host)) { freeaddrinfo(ai_in); continue; } @@ -514,9 +514,9 @@ static bool try_bind(int port) { return true; } -int check_port(meshlink_handle_t *mesh) { +static int check_port(meshlink_handle_t *mesh) { for(int i = 0; i < 1000; i++) { - int port = 0x1000 + (rand() & 0x7fff); + int port = 0x1000 + prng(mesh, 0x8000); if(try_bind(port)) { free(mesh->myport); @@ -575,7 +575,7 @@ static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len char *name = packmsg_get_str_dup(&in); packmsg_skip_element(&in); /* submesh */ - int32_t devclass = packmsg_get_int32(&in); + dev_class_t devclass = packmsg_get_int32(&in); uint32_t count = packmsg_get_array(&in); if(!name) { @@ -661,7 +661,12 @@ static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len } } - sptps_send_record(&(mesh->sptps), 1, ecdsa_get_public_key(mesh->private_key), 32); + /* Ensure the configuration directory metadata is on disk */ + if(!config_sync(mesh, "current") || !sync_path(mesh->confbase)) { + return false; + } + + sptps_send_record(&mesh->sptps, 1, ecdsa_get_public_key(mesh->private_key), 32); logger(mesh, MESHLINK_DEBUG, "Configuration stored in: %s\n", mesh->confbase); @@ -694,7 +699,7 @@ static bool invitation_receive(void *handle, uint8_t type, const void *msg, uint switch(type) { case SPTPS_HANDSHAKE: - return sptps_send_record(&(mesh->sptps), 0, mesh->cookie, sizeof(mesh)->cookie); + return sptps_send_record(&mesh->sptps, 0, mesh->cookie, sizeof(mesh)->cookie); case 0: return finalize_join(mesh, msg, len); @@ -791,6 +796,7 @@ static const char *errstr[] = { [MESHLINK_EPEER] = "Error communicating with peer", [MESHLINK_ENOTSUP] = "Operation not supported", [MESHLINK_EBUSY] = "MeshLink instance already in use", + [MESHLINK_EBLACKLISTED] = "Node is blacklisted", }; const char *meshlink_strerror(meshlink_errno_t err) { @@ -841,6 +847,7 @@ static struct timeval idle(event_loop_t *loop, void *data) { // Get our local address(es) by simulating connecting to an Internet host. static void add_local_addresses(meshlink_handle_t *mesh) { struct sockaddr_storage sn; + sn.ss_family = AF_UNKNOWN; socklen_t sl = sizeof(sn); // IPv4 example.org @@ -861,6 +868,18 @@ static void add_local_addresses(meshlink_handle_t *mesh) { } static bool meshlink_setup(meshlink_handle_t *mesh) { + if(!config_destroy(mesh->confbase, "new")) { + logger(mesh, MESHLINK_ERROR, "Could not delete configuration in %s/new: %s\n", mesh->confbase, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + return false; + } + + if(!config_destroy(mesh->confbase, "old")) { + logger(mesh, MESHLINK_ERROR, "Could not delete configuration in %s/old: %s\n", mesh->confbase, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + return false; + } + if(!config_init(mesh, "current")) { logger(mesh, MESHLINK_ERROR, "Could not set up configuration in %s/current: %s\n", mesh->confbase, strerror(errno)); meshlink_errno = MESHLINK_ESTORAGE; @@ -883,6 +902,7 @@ static bool meshlink_setup(meshlink_handle_t *mesh) { mesh->self->name = xstrdup(mesh->name); mesh->self->devclass = mesh->devclass; mesh->self->ecdsa = ecdsa_set_public_key(ecdsa_get_public_key(mesh->private_key)); + mesh->self->session_id = mesh->session_id; if(!write_main_config_files(mesh)) { logger(mesh, MESHLINK_ERROR, "Could not write main config files into %s/current: %s\n", mesh->confbase, strerror(errno)); @@ -890,9 +910,8 @@ static bool meshlink_setup(meshlink_handle_t *mesh) { return false; } - if(!main_config_lock(mesh)) { - logger(NULL, MESHLINK_ERROR, "Cannot lock main config file\n"); - meshlink_errno = MESHLINK_ESTORAGE; + /* Ensure the configuration directory metadata is on disk */ + if(!config_sync(mesh, "current")) { return false; } @@ -900,13 +919,6 @@ static bool meshlink_setup(meshlink_handle_t *mesh) { } static bool meshlink_read_config(meshlink_handle_t *mesh) { - // Open the configuration file and lock it - if(!main_config_lock(mesh)) { - logger(NULL, MESHLINK_ERROR, "Cannot lock main config file\n"); - meshlink_errno = MESHLINK_ESTORAGE; - return false; - } - config_t config; if(!main_config_read(mesh, "current", &config, mesh->config_key)) { @@ -956,6 +968,7 @@ static bool meshlink_read_config(meshlink_handle_t *mesh) { mesh->self = new_node(); mesh->self->name = xstrdup(name); mesh->self->devclass = mesh->devclass; + mesh->self->session_id = mesh->session_id; if(!node_read_public_key(mesh, mesh->self)) { logger(NULL, MESHLINK_ERROR, "Could not read our host configuration file!"); @@ -1003,16 +1016,17 @@ meshlink_open_params_t *meshlink_open_params_init(const char *confbase, const ch if(!name || !*name) { logger(NULL, MESHLINK_ERROR, "No name given!\n"); - //return NULL; - } else { //check name only if there is a name != NULL - if(!check_id(name)) { - logger(NULL, MESHLINK_ERROR, "Invalid name given!\n"); - meshlink_errno = MESHLINK_EINVAL; - return NULL; - } + meshlink_errno = MESHLINK_EINVAL; + return NULL; + }; + + if(!check_id(name)) { + logger(NULL, MESHLINK_ERROR, "Invalid name given!\n"); + meshlink_errno = MESHLINK_EINVAL; + return NULL; } - if((int)devclass < 0 || devclass > _DEV_CLASS_MAX) { + if(devclass < 0 || devclass >= DEV_CLASS_COUNT) { logger(NULL, MESHLINK_ERROR, "Invalid devclass given!\n"); meshlink_errno = MESHLINK_EINVAL; return NULL; @@ -1065,7 +1079,7 @@ bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *new_key, return false; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); // Create hash for the new key void *new_config_key; @@ -1074,7 +1088,7 @@ bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *new_key, if(!prf(new_key, new_keylen, "MeshLink configuration key", 26, new_config_key, CHACHA_POLY1305_KEYLEN)) { logger(mesh, MESHLINK_ERROR, "Error creating new configuration key!\n"); meshlink_errno = MESHLINK_EINTERNAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -1083,21 +1097,18 @@ bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *new_key, if(!config_copy(mesh, "current", mesh->config_key, "new", new_config_key)) { logger(mesh, MESHLINK_ERROR, "Could not set up configuration in %s/old: %s\n", mesh->confbase, strerror(errno)); meshlink_errno = MESHLINK_ESTORAGE; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } devtool_keyrotate_probe(1); - main_config_unlock(mesh); - // Rename confbase/current/ to confbase/old if(!config_rename(mesh, "current", "old")) { logger(mesh, MESHLINK_ERROR, "Cannot rename %s/current to %s/old\n", mesh->confbase, mesh->confbase); meshlink_errno = MESHLINK_ESTORAGE; - main_config_lock(mesh); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -1108,22 +1119,16 @@ bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *new_key, if(!config_rename(mesh, "new", "current")) { logger(mesh, MESHLINK_ERROR, "Cannot rename %s/new to %s/current\n", mesh->confbase, mesh->confbase); meshlink_errno = MESHLINK_ESTORAGE; - main_config_lock(mesh); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } devtool_keyrotate_probe(3); - if(!main_config_lock(mesh)) { - pthread_mutex_unlock(&(mesh->mesh_mutex)); - return false; - } - // Cleanup the "old" confbase sub-directory if(!config_destroy(mesh->confbase, "old")) { - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -1132,7 +1137,7 @@ bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *new_key, free(mesh->config_key); mesh->config_key = new_config_key; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return true; } @@ -1150,6 +1155,14 @@ void meshlink_open_params_free(meshlink_open_params_t *params) { free(params); } +/// Device class traits +static const dev_class_traits_t default_class_traits[DEV_CLASS_COUNT] = { + { .pingtimeout = 5, .pinginterval = 60, .min_connects = 3, .max_connects = 10000, .edge_weight = 1 }, // DEV_CLASS_BACKBONE + { .pingtimeout = 5, .pinginterval = 60, .min_connects = 3, .max_connects = 100, .edge_weight = 3 }, // DEV_CLASS_STATIONARY + { .pingtimeout = 5, .pinginterval = 60, .min_connects = 3, .max_connects = 3, .edge_weight = 6 }, // DEV_CLASS_PORTABLE + { .pingtimeout = 5, .pinginterval = 60, .min_connects = 1, .max_connects = 1, .edge_weight = 9 }, // DEV_CLASS_UNKNOWN +}; + meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const char *appname, dev_class_t devclass) { if(!confbase || !*confbase) { logger(NULL, MESHLINK_ERROR, "No confbase given!\n"); @@ -1178,7 +1191,8 @@ meshlink_handle_t *meshlink_open_encrypted(const char *confbase, const char *nam } /* Create a temporary struct on the stack, to avoid allocating and freeing one. */ - meshlink_open_params_t params = {NULL}; + meshlink_open_params_t params; + memset(¶ms, 0, sizeof(params)); params.confbase = (char *)confbase; params.name = (char *)name; @@ -1195,7 +1209,8 @@ meshlink_handle_t *meshlink_open_encrypted(const char *confbase, const char *nam meshlink_handle_t *meshlink_open_ephemeral(const char *name, const char *appname, dev_class_t devclass) { /* Create a temporary struct on the stack, to avoid allocating and freeing one. */ - meshlink_open_params_t params = {NULL}; + meshlink_open_params_t params; + memset(¶ms, 0, sizeof(params)); params.name = (char *)name; params.appname = (char *)appname; @@ -1237,7 +1252,7 @@ meshlink_handle_t *meshlink_open_ex(const meshlink_open_params_t *params) { } } - if((int)params->devclass < 0 || params->devclass > _DEV_CLASS_MAX) { + if(params->devclass < 0 || params->devclass >= DEV_CLASS_COUNT) { logger(NULL, MESHLINK_ERROR, "Invalid devclass given!\n"); meshlink_errno = MESHLINK_EINVAL; return NULL; @@ -1261,6 +1276,16 @@ meshlink_handle_t *meshlink_open_ex(const meshlink_open_params_t *params) { mesh->invitation_timeout = 604800; // 1 week mesh->netns = params->netns; mesh->submeshes = NULL; + mesh->log_cb = global_log_cb; + mesh->log_level = global_log_level; + + randomize(&mesh->prng_state, sizeof(mesh->prng_state)); + + do { + randomize(&mesh->session_id, sizeof(mesh->session_id)); + } while(mesh->session_id == 0); + + memcpy(mesh->dev_class_traits, default_class_traits, sizeof(default_class_traits)); if(usingname) { mesh->name = xstrdup(params->name); @@ -1282,7 +1307,7 @@ meshlink_handle_t *meshlink_open_ex(const meshlink_open_params_t *params) { pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); - pthread_mutex_init(&(mesh->mesh_mutex), &attr); + pthread_mutex_init(&mesh->mutex, &attr); mesh->threadstarted = false; event_loop_init(&mesh->loop); @@ -1290,6 +1315,12 @@ meshlink_handle_t *meshlink_open_ex(const meshlink_open_params_t *params) { meshlink_queue_init(&mesh->outpacketqueue); + // Atomically lock the configuration directory. + if(!main_config_lock(mesh)) { + meshlink_close(mesh); + return NULL; + } + // If no configuration exists yet, create it. if(!meshlink_confbase_exists(mesh)) { @@ -1342,7 +1373,11 @@ meshlink_handle_t *meshlink_open_ex(const meshlink_open_params_t *params) { } add_local_addresses(mesh); - node_write_config(mesh, mesh->self); + + if(!node_write_config(mesh, mesh->self)) { + logger(NULL, MESHLINK_ERROR, "Cannot update configuration\n"); + return NULL; + } idle_set(&mesh->loop, idle, mesh); @@ -1366,11 +1401,11 @@ meshlink_submesh_t *meshlink_submesh_open(meshlink_handle_t *mesh, const char * } //lock mesh->nodes - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); s = (meshlink_submesh_t *)create_submesh(mesh, submesh); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return s; } @@ -1400,14 +1435,14 @@ static void *meshlink_main_loop(void *arg) { #endif - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); logger(mesh, MESHLINK_DEBUG, "Starting main_loop...\n"); pthread_cond_broadcast(&mesh->cond); main_loop(mesh); logger(mesh, MESHLINK_DEBUG, "main_loop returned.\n"); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); #if HAVE_CATTA @@ -1432,14 +1467,14 @@ bool meshlink_start(meshlink_handle_t *mesh) { logger(mesh, MESHLINK_DEBUG, "meshlink_start called\n"); - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); assert(mesh->self->ecdsa); assert(!memcmp((uint8_t *)mesh->self->ecdsa + 64, (uint8_t *)mesh->private_key + 64, 32)); if(mesh->threadstarted) { logger(mesh, MESHLINK_DEBUG, "thread was already running\n"); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return true; } @@ -1457,7 +1492,7 @@ bool meshlink_start(meshlink_handle_t *mesh) { if(!mesh->name) { logger(mesh, MESHLINK_DEBUG, "No name given!\n"); meshlink_errno = MESHLINK_EINVAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -1472,14 +1507,16 @@ bool meshlink_start(meshlink_handle_t *mesh) { memset(&mesh->thread, 0, sizeof(mesh)->thread); meshlink_errno = MESHLINK_EINTERNAL; event_loop_stop(&mesh->loop); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } - pthread_cond_wait(&mesh->cond, &mesh->mesh_mutex); + pthread_cond_wait(&mesh->cond, &mesh->mutex); mesh->threadstarted = true; + mesh->self->last_reachable = time(NULL); + mesh->self->status.dirty = true; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return true; } @@ -1489,9 +1526,14 @@ void meshlink_stop(meshlink_handle_t *mesh) { return; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); logger(mesh, MESHLINK_DEBUG, "meshlink_stop called\n"); + if(mesh->self) { + mesh->self->last_unreachable = time(NULL); + mesh->self->status.dirty = true; + } + // Shut down the main thread event_loop_stop(&mesh->loop); @@ -1512,9 +1554,9 @@ void meshlink_stop(meshlink_handle_t *mesh) { if(mesh->threadstarted) { // Wait for the main thread to finish - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); pthread_join(mesh->thread, NULL); - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); mesh->threadstarted = false; } @@ -1531,17 +1573,16 @@ void meshlink_stop(meshlink_handle_t *mesh) { exit_outgoings(mesh); - // Write out any changed node config files + // Try to write out any changed node config files, ignore errors at this point. if(mesh->nodes) { for splay_each(node_t, n, mesh->nodes) { if(n->status.dirty) { - node_write_config(mesh, n); - n->status.dirty = false; + n->status.dirty = !node_write_config(mesh, n); } } } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); } void meshlink_close(meshlink_handle_t *mesh) { @@ -1554,7 +1595,7 @@ void meshlink_close(meshlink_handle_t *mesh) { meshlink_stop(mesh); // lock is not released after this - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); // Close and free all resources used. @@ -1578,15 +1619,23 @@ void meshlink_close(meshlink_handle_t *mesh) { close(mesh->netns); } + for(vpn_packet_t *packet; (packet = meshlink_queue_pop(&mesh->outpacketqueue));) { + free(packet); + } + + meshlink_queue_exit(&mesh->outpacketqueue); + free(mesh->name); free(mesh->appname); free(mesh->confbase); free(mesh->config_key); ecdsa_free(mesh->private_key); - pthread_mutex_destroy(&(mesh->mesh_mutex)); main_config_unlock(mesh); + pthread_mutex_unlock(&mesh->mutex); + pthread_mutex_destroy(&mesh->mutex); + memset(mesh, 0, sizeof(*mesh)); free(mesh); @@ -1598,16 +1647,56 @@ bool meshlink_destroy(const char *confbase) { return false; } - if(!config_destroy(confbase, "current")) { - logger(NULL, MESHLINK_ERROR, "Cannot remove confbase sub-directories %s: %s\n", confbase, strerror(errno)); + /* Exit early if the confbase directory itself doesn't exist */ + if(access(confbase, F_OK) && errno == ENOENT) { + return true; + } + + /* Take the lock the same way meshlink_open() would. */ + char lockfilename[PATH_MAX]; + snprintf(lockfilename, sizeof(lockfilename), "%s" SLASH "meshlink.lock", confbase); + + FILE *lockfile = fopen(lockfilename, "w+"); + + if(!lockfile) { + logger(NULL, MESHLINK_ERROR, "Could not open lock file %s: %s", lockfilename, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; return false; } - config_destroy(confbase, "new"); - config_destroy(confbase, "old"); +#ifdef FD_CLOEXEC + fcntl(fileno(lockfile), F_SETFD, FD_CLOEXEC); +#endif - if(rmdir(confbase) && errno != ENOENT) { - logger(NULL, MESHLINK_ERROR, "Cannot remove directory %s: %s\n", confbase, strerror(errno)); +#ifdef HAVE_MINGW + // TODO: use _locking()? +#else + + if(flock(fileno(lockfile), LOCK_EX | LOCK_NB) != 0) { + logger(NULL, MESHLINK_ERROR, "Configuration directory %s still in use\n", lockfilename); + fclose(lockfile); + meshlink_errno = MESHLINK_EBUSY; + return false; + } + +#endif + + if(!config_destroy(confbase, "current") || !config_destroy(confbase, "new") || !config_destroy(confbase, "old")) { + logger(NULL, MESHLINK_ERROR, "Cannot remove sub-directories in %s: %s\n", confbase, strerror(errno)); + return false; + } + + if(unlink(lockfilename)) { + logger(NULL, MESHLINK_ERROR, "Cannot remove lock file %s: %s\n", lockfilename, strerror(errno)); + fclose(lockfile); + meshlink_errno = MESHLINK_ESTORAGE; + return false; + } + + fclose(lockfile); + + if(!sync_path(confbase)) { + logger(NULL, MESHLINK_ERROR, "Cannot sync directory %s: %s\n", confbase, strerror(errno)); meshlink_errno = MESHLINK_ESTORAGE; return false; } @@ -1621,9 +1710,9 @@ void meshlink_set_receive_cb(meshlink_handle_t *mesh, meshlink_receive_cb_t cb) return; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); mesh->receive_cb = cb; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); } void meshlink_set_connection_try_cb(meshlink_handle_t *mesh, meshlink_connection_try_cb_t cb) { @@ -1632,9 +1721,9 @@ void meshlink_set_connection_try_cb(meshlink_handle_t *mesh, meshlink_connection return; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); mesh->connection_try_cb = cb; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); } void meshlink_set_node_status_cb(meshlink_handle_t *mesh, meshlink_node_status_cb_t cb) { @@ -1643,9 +1732,20 @@ void meshlink_set_node_status_cb(meshlink_handle_t *mesh, meshlink_node_status_c return; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); mesh->node_status_cb = cb; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); +} + +void meshlink_set_node_pmtu_cb(meshlink_handle_t *mesh, meshlink_node_pmtu_cb_t cb) { + if(!mesh) { + meshlink_errno = MESHLINK_EINVAL; + return; + } + + pthread_mutex_lock(&mesh->mutex); + mesh->node_pmtu_cb = cb; + pthread_mutex_unlock(&mesh->mutex); } void meshlink_set_node_duplicate_cb(meshlink_handle_t *mesh, meshlink_node_duplicate_cb_t cb) { @@ -1654,23 +1754,34 @@ void meshlink_set_node_duplicate_cb(meshlink_handle_t *mesh, meshlink_node_dupli return; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); mesh->node_duplicate_cb = cb; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); } void meshlink_set_log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, meshlink_log_cb_t cb) { if(mesh) { - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); mesh->log_cb = cb; mesh->log_level = cb ? level : 0; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); } else { global_log_cb = cb; global_log_level = cb ? level : 0; } } +void meshlink_set_error_cb(struct meshlink_handle *mesh, meshlink_error_cb_t cb) { + if(!mesh) { + meshlink_errno = MESHLINK_EINVAL; + return; + } + + pthread_mutex_lock(&mesh->mutex); + mesh->error_cb = cb; + pthread_mutex_unlock(&mesh->mutex); +} + bool meshlink_send(meshlink_handle_t *mesh, meshlink_node_t *destination, const void *data, size_t len) { meshlink_packethdr_t *hdr; @@ -1693,6 +1804,7 @@ bool meshlink_send(meshlink_handle_t *mesh, meshlink_node_t *destination, const if(n->status.blacklisted) { logger(mesh, MESHLINK_ERROR, "Node %s blacklisted, dropping packet\n", n->name); + meshlink_errno = MESHLINK_EBLACKLISTED; return false; } @@ -1725,13 +1837,14 @@ bool meshlink_send(meshlink_handle_t *mesh, meshlink_node_t *destination, const } // Notify event loop - signal_trigger(&(mesh->loop), &(mesh->datafromapp)); + signal_trigger(&mesh->loop, &mesh->datafromapp); return true; } -void meshlink_send_from_queue(event_loop_t *loop, meshlink_handle_t *mesh) { +void meshlink_send_from_queue(event_loop_t *loop, void *data) { (void)loop; + meshlink_handle_t *mesh = data; vpn_packet_t *packet = meshlink_queue_pop(&mesh->outpacketqueue); if(!packet) { @@ -1741,6 +1854,8 @@ void meshlink_send_from_queue(event_loop_t *loop, meshlink_handle_t *mesh) { mesh->self->in_packets++; mesh->self->in_bytes += packet->len; route(mesh, mesh->self, packet); + + free(packet); } ssize_t meshlink_get_pmtu(meshlink_handle_t *mesh, meshlink_node_t *destination) { @@ -1749,19 +1864,19 @@ ssize_t meshlink_get_pmtu(meshlink_handle_t *mesh, meshlink_node_t *destination) return -1; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); node_t *n = (node_t *)destination; if(!n->status.reachable) { - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return 0; } else if(n->mtuprobes > 30 && n->minmtu) { - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return n->minmtu; } else { - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return MTU; } } @@ -1772,13 +1887,13 @@ char *meshlink_get_fingerprint(meshlink_handle_t *mesh, meshlink_node_t *node) { return NULL; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); node_t *n = (node_t *)node; if(!node_read_public_key(mesh, n) || !n->ecdsa) { meshlink_errno = MESHLINK_EINTERNAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -1788,7 +1903,7 @@ char *meshlink_get_fingerprint(meshlink_handle_t *mesh, meshlink_node_t *node) { meshlink_errno = MESHLINK_EINTERNAL; } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return fingerprint; } @@ -1807,12 +1922,17 @@ meshlink_node_t *meshlink_get_node(meshlink_handle_t *mesh, const char *name) { return NULL; } - meshlink_node_t *node = NULL; + node_t *n = NULL; + + pthread_mutex_lock(&mesh->mutex); + n = lookup_node(mesh, (char *)name); // TODO: make lookup_node() use const + pthread_mutex_unlock(&mesh->mutex); - pthread_mutex_lock(&(mesh->mesh_mutex)); - node = (meshlink_node_t *)lookup_node(mesh, (char *)name); // TODO: make lookup_node() use const - pthread_mutex_unlock(&(mesh->mesh_mutex)); - return node; + if(!n) { + meshlink_errno = MESHLINK_ENOENT; + } + + return (meshlink_node_t *)n; } meshlink_submesh_t *meshlink_get_submesh(meshlink_handle_t *mesh, const char *name) { @@ -1823,9 +1943,14 @@ meshlink_submesh_t *meshlink_get_submesh(meshlink_handle_t *mesh, const char *na meshlink_submesh_t *submesh = NULL; - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); submesh = (meshlink_submesh_t *)lookup_submesh(mesh, name); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); + + if(!submesh) { + meshlink_errno = MESHLINK_ENOENT; + } + return submesh; } @@ -1838,7 +1963,7 @@ meshlink_node_t **meshlink_get_all_nodes(meshlink_handle_t *mesh, meshlink_node_ meshlink_node_t **result; //lock mesh->nodes - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); *nmemb = mesh->nodes->count; result = realloc(nodes, *nmemb * sizeof(*nodes)); @@ -1855,7 +1980,7 @@ meshlink_node_t **meshlink_get_all_nodes(meshlink_handle_t *mesh, meshlink_node_ meshlink_errno = MESHLINK_ENOMEM; } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return result; } @@ -1863,19 +1988,19 @@ meshlink_node_t **meshlink_get_all_nodes(meshlink_handle_t *mesh, meshlink_node_ static meshlink_node_t **meshlink_get_all_nodes_by_condition(meshlink_handle_t *mesh, const void *condition, meshlink_node_t **nodes, size_t *nmemb, search_node_by_condition_t search_node) { meshlink_node_t **result; - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); *nmemb = 0; for splay_each(node_t, n, mesh->nodes) { - if(true == search_node(n, condition)) { - *nmemb = *nmemb + 1; + if(search_node(n, condition)) { + ++*nmemb; } } if(*nmemb == 0) { free(nodes); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return NULL; } @@ -1885,7 +2010,7 @@ static meshlink_node_t **meshlink_get_all_nodes_by_condition(meshlink_handle_t * meshlink_node_t **p = result; for splay_each(node_t, n, mesh->nodes) { - if(true == search_node(n, condition)) { + if(search_node(n, condition)) { *p++ = (meshlink_node_t *)n; } } @@ -1895,7 +2020,7 @@ static meshlink_node_t **meshlink_get_all_nodes_by_condition(meshlink_handle_t * meshlink_errno = MESHLINK_ENOMEM; } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return result; } @@ -1918,8 +2043,33 @@ static bool search_node_by_submesh(const node_t *node, const void *condition) { return false; } +struct time_range { + time_t start; + time_t end; +}; + +static bool search_node_by_last_reachable(const node_t *node, const void *condition) { + const struct time_range *range = condition; + time_t start = node->last_reachable; + time_t end = node->last_unreachable; + + if(end < start) { + end = time(NULL); + + if(end < start) { + start = end; + } + } + + if(range->end >= range->start) { + return start <= range->end && end >= range->start; + } else { + return start > range->start || end < range->end; + } +} + meshlink_node_t **meshlink_get_all_nodes_by_dev_class(meshlink_handle_t *mesh, dev_class_t devclass, meshlink_node_t **nodes, size_t *nmemb) { - if(!mesh || ((int)devclass < 0) || (devclass > _DEV_CLASS_MAX) || !nmemb) { + if(!mesh || devclass < 0 || devclass >= DEV_CLASS_COUNT || !nmemb) { meshlink_errno = MESHLINK_EINVAL; return NULL; } @@ -1936,6 +2086,17 @@ meshlink_node_t **meshlink_get_all_nodes_by_submesh(meshlink_handle_t *mesh, mes return meshlink_get_all_nodes_by_condition(mesh, submesh, nodes, nmemb, search_node_by_submesh); } +meshlink_node_t **meshlink_get_all_nodes_by_last_reachable(meshlink_handle_t *mesh, time_t start, time_t end, meshlink_node_t **nodes, size_t *nmemb) { + if(!mesh || !nmemb) { + meshlink_errno = MESHLINK_EINVAL; + return NULL; + } + + struct time_range range = {start, end}; + + return meshlink_get_all_nodes_by_condition(mesh, &range, nodes, nmemb, search_node_by_last_reachable); +} + dev_class_t meshlink_get_node_dev_class(meshlink_handle_t *mesh, meshlink_node_t *node) { if(!mesh || !node) { meshlink_errno = MESHLINK_EINVAL; @@ -1944,11 +2105,11 @@ dev_class_t meshlink_get_node_dev_class(meshlink_handle_t *mesh, meshlink_node_t dev_class_t devclass; - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); devclass = ((node_t *)node)->devclass; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return devclass; } @@ -1979,16 +2140,16 @@ bool meshlink_sign(meshlink_handle_t *mesh, const void *data, size_t len, void * return false; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); if(!ecdsa_sign(mesh->private_key, data, len, signature)) { meshlink_errno = MESHLINK_EINTERNAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } *siglen = MESHLINK_SIGLEN; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return true; } @@ -2003,7 +2164,7 @@ bool meshlink_verify(meshlink_handle_t *mesh, meshlink_node_t *source, const voi return false; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); bool rval = false; @@ -2016,12 +2177,12 @@ bool meshlink_verify(meshlink_handle_t *mesh, meshlink_node_t *source, const voi rval = ecdsa_verify(((struct node_t *)source)->ecdsa, data, len, signature); } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return rval; } static bool refresh_invitation_key(meshlink_handle_t *mesh) { - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); size_t count = invitation_purge_old(mesh, time(NULL) - mesh->invitation_timeout); @@ -2029,7 +2190,7 @@ static bool refresh_invitation_key(meshlink_handle_t *mesh) { // TODO: Update invitation key if necessary? } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return mesh->invitation_key; } @@ -2060,16 +2221,20 @@ bool meshlink_set_canonical_address(meshlink_handle_t *mesh, meshlink_node_t *no canonical_address = xstrdup(address); } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); node_t *n = (node_t *)node; free(n->canonical_address); n->canonical_address = canonical_address; - node_write_config(mesh, n); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + if(!node_write_config(mesh, n)) { + pthread_mutex_unlock(&mesh->mutex); + return false; + } - return true; + pthread_mutex_unlock(&mesh->mutex); + + return config_sync(mesh, "current"); } bool meshlink_add_address(meshlink_handle_t *mesh, const char *address) { @@ -2105,7 +2270,13 @@ int meshlink_get_port(meshlink_handle_t *mesh) { return -1; } - return atoi(mesh->myport); + int port; + + pthread_mutex_lock(&mesh->mutex); + port = atoi(mesh->myport); + pthread_mutex_unlock(&mesh->mutex); + + return port; } bool meshlink_set_port(meshlink_handle_t *mesh, int port) { @@ -2127,7 +2298,7 @@ bool meshlink_set_port(meshlink_handle_t *mesh, int port) { bool rval = false; - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); if(mesh->threadstarted) { meshlink_errno = MESHLINK_EINVAL; @@ -2137,9 +2308,6 @@ bool meshlink_set_port(meshlink_handle_t *mesh, int port) { free(mesh->myport); xasprintf(&mesh->myport, "%d", port); - /* Write meshlink.conf with the updated port number */ - write_main_config_files(mesh); - /* Close down the network. This also deletes mesh->self. */ close_network_connections(mesh); @@ -2147,6 +2315,7 @@ bool meshlink_set_port(meshlink_handle_t *mesh, int port) { mesh->self = new_node(); mesh->self->name = xstrdup(mesh->name); mesh->self->devclass = mesh->devclass; + mesh->self->session_id = mesh->session_id; xasprintf(&mesh->myport, "%d", port); if(!node_read_public_key(mesh, mesh->self)) { @@ -2154,14 +2323,23 @@ bool meshlink_set_port(meshlink_handle_t *mesh, int port) { meshlink_errno = MESHLINK_ESTORAGE; free_node(mesh->self); mesh->self = NULL; + goto done; } else if(!setup_network(mesh)) { meshlink_errno = MESHLINK_ENETWORK; - } else { - rval = true; + goto done; } + /* Rebuild our own list of recent addresses */ + memset(mesh->self->recent, 0, sizeof(mesh->self->recent)); + add_local_addresses(mesh); + + /* Write meshlink.conf with the updated port number */ + write_main_config_files(mesh); + + rval = config_sync(mesh, "current"); + done: - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return rval && meshlink_get_port(mesh) == port; } @@ -2190,13 +2368,13 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c s = (meshlink_submesh_t *)mesh->self->submesh; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); // Check validity of the new node's name if(!check_id(name)) { logger(mesh, MESHLINK_DEBUG, "Invalid name for node.\n"); meshlink_errno = MESHLINK_EINVAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return NULL; } @@ -2204,7 +2382,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c if(config_exists(mesh, "current", name)) { logger(mesh, MESHLINK_DEBUG, "A host config file for %s already exists!\n", name); meshlink_errno = MESHLINK_EEXIST; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return NULL; } @@ -2212,7 +2390,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c if(meshlink_get_node(mesh, name)) { logger(mesh, MESHLINK_DEBUG, "A node with name %s is already known!\n", name); meshlink_errno = MESHLINK_EEXIST; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return NULL; } @@ -2222,13 +2400,13 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c if(!address) { logger(mesh, MESHLINK_DEBUG, "No Address known for ourselves!\n"); meshlink_errno = MESHLINK_ERESOLV; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return NULL; } if(!refresh_invitation_key(mesh)) { meshlink_errno = MESHLINK_EINTERNAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return NULL; } @@ -2268,7 +2446,8 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c * Note: make sure we only add config files of nodes that are in the core mesh or the same submesh, * and are not blacklisted. */ - config_t configs[5] = {NULL}; + config_t configs[5]; + memset(configs, 0, sizeof(configs)); int count = 0; if(config_read(mesh, "current", mesh->self->name, &configs[count], mesh->config_key)) { @@ -2288,7 +2467,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c if(!invitation_write(mesh, "current", cookiehash, &config, mesh->config_key)) { logger(mesh, MESHLINK_DEBUG, "Could not create invitation file %s: %s\n", cookiehash, strerror(errno)); meshlink_errno = MESHLINK_ESTORAGE; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return NULL; } @@ -2297,7 +2476,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c xasprintf(&url, "%s/%s%s", address, hash, cookie); free(address); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return url; } @@ -2311,13 +2490,13 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { return false; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); //Before doing meshlink_join make sure we are not connected to another mesh if(mesh->threadstarted) { logger(mesh, MESHLINK_ERROR, "Cannot join while started\n"); meshlink_errno = MESHLINK_EINVAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -2325,7 +2504,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { if(mesh->nodes->count > 1) { logger(mesh, MESHLINK_ERROR, "Already part of an existing mesh\n"); meshlink_errno = MESHLINK_EINVAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -2359,7 +2538,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { if(!key) { meshlink_errno = MESHLINK_EINTERNAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -2437,7 +2616,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { } if(mesh->sock == -1) { - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -2451,7 +2630,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { logger(mesh, MESHLINK_DEBUG, "Error sending request to %s port %s: %s\n", address, port, strerror(errno)); closesocket(mesh->sock); meshlink_errno = MESHLINK_ENETWORK; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -2464,7 +2643,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { logger(mesh, MESHLINK_DEBUG, "Cannot read greeting from peer\n"); closesocket(mesh->sock); meshlink_errno = MESHLINK_ENETWORK; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -2475,14 +2654,14 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { if(sha512(fingerprint, strlen(fingerprint), hishash)) { logger(mesh, MESHLINK_DEBUG, "Could not create hash\n%s\n", mesh->line + 2); meshlink_errno = MESHLINK_EINTERNAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } if(memcmp(hishash, mesh->hash, 18)) { logger(mesh, MESHLINK_DEBUG, "Peer has an invalid key!\n%s\n", mesh->line + 2); meshlink_errno = MESHLINK_EPEER; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -2491,21 +2670,21 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { if(!hiskey) { meshlink_errno = MESHLINK_EINTERNAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } // Start an SPTPS session if(!sptps_start(&mesh->sptps, mesh, true, false, key, hiskey, meshlink_invitation_label, sizeof(meshlink_invitation_label), invitation_send, invitation_receive)) { meshlink_errno = MESHLINK_EINTERNAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } // Feed rest of input buffer to SPTPS if(!sptps_receive_data(&mesh->sptps, mesh->buffer, mesh->blen)) { meshlink_errno = MESHLINK_EPEER; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -2519,13 +2698,13 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { logger(mesh, MESHLINK_DEBUG, "Error reading data from %s port %s: %s\n", address, port, strerror(errno)); meshlink_errno = MESHLINK_ENETWORK; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } if(!sptps_receive_data(&mesh->sptps, mesh->line, len)) { meshlink_errno = MESHLINK_EPEER; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } } @@ -2538,17 +2717,17 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { if(!mesh->success) { logger(mesh, MESHLINK_DEBUG, "Connection closed by peer, invitation cancelled.\n"); meshlink_errno = MESHLINK_EPEER; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return true; invalid: logger(mesh, MESHLINK_DEBUG, "Invalid invitation URL\n"); meshlink_errno = MESHLINK_EINVAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); return false; } @@ -2566,7 +2745,7 @@ char *meshlink_export(meshlink_handle_t *mesh) { packmsg_add_str(&out, mesh->name); packmsg_add_str(&out, CORE_MESH); - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); packmsg_add_int32(&out, mesh->self->devclass); packmsg_add_bool(&out, mesh->self->status.blacklisted); @@ -2575,7 +2754,7 @@ char *meshlink_export(meshlink_handle_t *mesh) { uint32_t count = 0; - for(uint32_t i = 0; i < 5; i++) { + for(uint32_t i = 0; i < MAX_RECENT; i++) { if(mesh->self->recent[i].sa.sa_family) { count++; } else { @@ -2589,7 +2768,10 @@ char *meshlink_export(meshlink_handle_t *mesh) { packmsg_add_sockaddr(&out, &mesh->self->recent[i]); } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + packmsg_add_int64(&out, 0); + packmsg_add_int64(&out, 0); + + pthread_mutex_unlock(&mesh->mutex); if(!packmsg_output_ok(&out)) { logger(mesh, MESHLINK_DEBUG, "Error creating export data\n"); @@ -2643,7 +2825,7 @@ bool meshlink_import(meshlink_handle_t *mesh, const char *data) { return false; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); while(count--) { const void *data; @@ -2687,11 +2869,17 @@ bool meshlink_import(meshlink_handle_t *mesh, const char *data) { break; } - config_write(mesh, "current", n->name, &config, mesh->config_key); + if(!config_write(mesh, "current", n->name, &config, mesh->config_key)) { + free_node(n); + return false; + } + node_add(mesh, n); } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_mutex_unlock(&mesh->mutex); + + free(buf); if(!packmsg_done(&in)) { logger(mesh, MESHLINK_ERROR, "Invalid data\n"); @@ -2699,41 +2887,33 @@ bool meshlink_import(meshlink_handle_t *mesh, const char *data) { return false; } - return true; -} - -void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) { - if(!mesh || !node) { - meshlink_errno = MESHLINK_EINVAL; - return; + if(!config_sync(mesh, "current")) { + return false; } - pthread_mutex_lock(&(mesh->mesh_mutex)); - - node_t *n; - n = (node_t *)node; + return true; +} +static bool blacklist(meshlink_handle_t *mesh, node_t *n) { if(n == mesh->self) { - logger(mesh, MESHLINK_ERROR, "%s blacklisting itself?\n", node->name); + logger(mesh, MESHLINK_ERROR, "%s blacklisting itself?\n", n->name); meshlink_errno = MESHLINK_EINVAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); - return; + return false; } if(n->status.blacklisted) { - logger(mesh, MESHLINK_DEBUG, "Node %s already blacklisted\n", node->name); - pthread_mutex_unlock(&(mesh->mesh_mutex)); - return; + logger(mesh, MESHLINK_DEBUG, "Node %s already blacklisted\n", n->name); + return true; } n->status.blacklisted = true; - node_write_config(mesh, n); - logger(mesh, MESHLINK_DEBUG, "Blacklisted %s.\n", node->name); - //Immediately terminate any connections we have with the blacklisted node + /* Immediately shut down any connections we have with the blacklisted node. + * We can't call terminate_connection(), because we might be called from a callback function. + */ for list_each(connection_t, c, mesh->connections) { if(c->node == n) { - terminate_connection(mesh, c, c->status.active); + shutdown(c->socket, SHUT_RDWR); } } @@ -2745,41 +2925,189 @@ void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) { n->mtuprobes = 0; n->status.udp_confirmed = false; + /* Graph updates will suppress status updates for blacklisted nodes, so we need to + * manually call the status callback if necessary. + */ + if(n->status.reachable && mesh->node_status_cb) { + mesh->node_status_cb(mesh, (meshlink_node_t *)n, false); + } + + return node_write_config(mesh, n) && config_sync(mesh, "current"); +} + +bool meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) { + if(!mesh || !node) { + meshlink_errno = MESHLINK_EINVAL; + return false; + } + + pthread_mutex_lock(&mesh->mutex); + + if(!blacklist(mesh, (node_t *)node)) { + pthread_mutex_unlock(&mesh->mutex); + return false; + } + + pthread_mutex_unlock(&mesh->mutex); + + logger(mesh, MESHLINK_DEBUG, "Blacklisted %s.\n", node->name); + return true; +} + +bool meshlink_blacklist_by_name(meshlink_handle_t *mesh, const char *name) { + if(!mesh || !name) { + meshlink_errno = MESHLINK_EINVAL; + return false; + } + + pthread_mutex_lock(&mesh->mutex); + + node_t *n = lookup_node(mesh, (char *)name); + + if(!n) { + n = new_node(); + n->name = xstrdup(name); + node_add(mesh, n); + } + + if(!blacklist(mesh, (node_t *)n)) { + pthread_mutex_unlock(&mesh->mutex); + return false; + } + + pthread_mutex_unlock(&mesh->mutex); + + logger(mesh, MESHLINK_DEBUG, "Blacklisted %s.\n", name); + return true; +} + +static bool whitelist(meshlink_handle_t *mesh, node_t *n) { + if(n == mesh->self) { + logger(mesh, MESHLINK_ERROR, "%s whitelisting itself?\n", n->name); + meshlink_errno = MESHLINK_EINVAL; + return false; + } + + if(!n->status.blacklisted) { + logger(mesh, MESHLINK_DEBUG, "Node %s was already whitelisted\n", n->name); + return true; + } + + n->status.blacklisted = false; + if(n->status.reachable) { update_node_status(mesh, n); } - pthread_mutex_unlock(&(mesh->mesh_mutex)); + return node_write_config(mesh, n) && config_sync(mesh, "current"); } -void meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) { +bool meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) { if(!mesh || !node) { meshlink_errno = MESHLINK_EINVAL; - return; + return false; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); - node_t *n = (node_t *)node; + if(!whitelist(mesh, (node_t *)node)) { + pthread_mutex_unlock(&mesh->mutex); + return false; + } - if(!n->status.blacklisted) { - logger(mesh, MESHLINK_DEBUG, "Node %s was already whitelisted\n", node->name); + pthread_mutex_unlock(&mesh->mutex); + + logger(mesh, MESHLINK_DEBUG, "Whitelisted %s.\n", node->name); + return true; +} + +bool meshlink_whitelist_by_name(meshlink_handle_t *mesh, const char *name) { + if(!mesh || !name) { meshlink_errno = MESHLINK_EINVAL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); - return; + return false; } - n->status.blacklisted = false; - node_write_config(mesh, n); + pthread_mutex_lock(&mesh->mutex); - pthread_mutex_unlock(&(mesh->mesh_mutex)); - return; + node_t *n = lookup_node(mesh, (char *)name); + + if(!n) { + n = new_node(); + n->name = xstrdup(name); + node_add(mesh, n); + } + + if(!whitelist(mesh, (node_t *)n)) { + pthread_mutex_unlock(&mesh->mutex); + return false; + } + + pthread_mutex_unlock(&mesh->mutex); + + logger(mesh, MESHLINK_DEBUG, "Whitelisted %s.\n", name); + return true; } void meshlink_set_default_blacklist(meshlink_handle_t *mesh, bool blacklist) { mesh->default_blacklist = blacklist; } +bool meshlink_forget_node(meshlink_handle_t *mesh, meshlink_node_t *node) { + if(!mesh || !node) { + meshlink_errno = MESHLINK_EINVAL; + return false; + } + + node_t *n = (node_t *)node; + + pthread_mutex_lock(&mesh->mutex); + + /* Check that the node is not reachable */ + if(n->status.reachable || n->connection) { + pthread_mutex_unlock(&mesh->mutex); + logger(mesh, MESHLINK_WARNING, "Could not forget %s: still reachable", n->name); + return false; + } + + /* Check that we don't have any active UTCP connections */ + if(n->utcp && utcp_is_active(n->utcp)) { + pthread_mutex_unlock(&mesh->mutex); + logger(mesh, MESHLINK_WARNING, "Could not forget %s: active UTCP connections", n->name); + return false; + } + + /* Check that we have no active connections to this node */ + for list_each(connection_t, c, mesh->connections) { + if(c->node == n) { + pthread_mutex_unlock(&mesh->mutex); + logger(mesh, MESHLINK_WARNING, "Could not forget %s: active connection", n->name); + return false; + } + } + + /* Remove any pending outgoings to this node */ + if(mesh->outgoings) { + for list_each(outgoing_t, outgoing, mesh->outgoings) { + if(outgoing->node == n) { + list_delete_node(mesh->outgoings, node); + } + } + } + + /* Delete the config file for this node */ + if(!config_delete(mesh, "current", n->name)) { + pthread_mutex_unlock(&mesh->mutex); + return false; + } + + /* Delete the node struct and any remaining edges referencing this node */ + node_del(mesh, n); + + pthread_mutex_unlock(&mesh->mutex); + + return config_sync(mesh, "current"); +} + /* Hint that a hostname may be found at an address * See header file for detailed comment. */ @@ -2789,14 +3117,17 @@ void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const return; } - pthread_mutex_lock(&(mesh->mesh_mutex)); + pthread_mutex_lock(&mesh->mutex); node_t *n = (node_t *)node; - memmove(n->recent + 1, n->recent, 4 * sizeof(*n->recent)); - memcpy(n->recent, addr, SALEN(*addr)); - node_write_config(mesh, n); - pthread_mutex_unlock(&(mesh->mesh_mutex)); + if(node_add_recent_address(mesh, n, (sockaddr_t *)addr)) { + if(!node_write_config(mesh, n)) { + logger(mesh, MESHLINK_DEBUG, "Could not update %s\n", n->name); + } + } + + pthread_mutex_unlock(&mesh->mutex); // @TODO do we want to fire off a connection attempt right away? } @@ -2996,9 +3327,15 @@ static void channel_poll(struct utcp_connection *connection, size_t len) { } void meshlink_set_channel_poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, meshlink_channel_poll_cb_t cb) { - (void)mesh; + if(!mesh || !channel) { + meshlink_errno = MESHLINK_EINVAL; + return; + } + + pthread_mutex_lock(&mesh->mutex); channel->poll_cb = cb; utcp_set_poll_cb(channel->c, (cb || channel->aio_send) ? channel_poll : NULL); + pthread_mutex_unlock(&mesh->mutex); } void meshlink_set_channel_accept_cb(meshlink_handle_t *mesh, meshlink_channel_accept_cb_t cb) { @@ -3007,7 +3344,7 @@ void meshlink_set_channel_accept_cb(meshlink_handle_t *mesh, meshlink_channel_ac return; } - pthread_mutex_lock(&mesh->mesh_mutex); + pthread_mutex_lock(&mesh->mutex); mesh->channel_accept_cb = cb; mesh->receive_cb = channel_receive; @@ -3017,7 +3354,7 @@ void meshlink_set_channel_accept_cb(meshlink_handle_t *mesh, meshlink_channel_ac } } - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); } void meshlink_set_channel_sndbuf(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t size) { @@ -3028,9 +3365,9 @@ void meshlink_set_channel_sndbuf(meshlink_handle_t *mesh, meshlink_channel_t *ch return; } - pthread_mutex_lock(&mesh->mesh_mutex); + pthread_mutex_lock(&mesh->mutex); utcp_set_sndbuf(channel->c, size); - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); } void meshlink_set_channel_rcvbuf(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t size) { @@ -3041,13 +3378,13 @@ void meshlink_set_channel_rcvbuf(meshlink_handle_t *mesh, meshlink_channel_t *ch return; } - pthread_mutex_lock(&mesh->mesh_mutex); + pthread_mutex_lock(&mesh->mutex); utcp_set_rcvbuf(channel->c, size); - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); } meshlink_channel_t *meshlink_channel_open_ex(meshlink_handle_t *mesh, meshlink_node_t *node, uint16_t port, meshlink_channel_receive_cb_t cb, const void *data, size_t len, uint32_t flags) { - if(data || len) { + if(data && len) { abort(); // TODO: handle non-NULL data } @@ -3056,6 +3393,8 @@ meshlink_channel_t *meshlink_channel_open_ex(meshlink_handle_t *mesh, meshlink_n return NULL; } + pthread_mutex_lock(&mesh->mutex); + node_t *n = (node_t *)node; if(!n->utcp) { @@ -3064,20 +3403,30 @@ meshlink_channel_t *meshlink_channel_open_ex(meshlink_handle_t *mesh, meshlink_n if(!n->utcp) { meshlink_errno = errno == ENOMEM ? MESHLINK_ENOMEM : MESHLINK_EINTERNAL; + pthread_mutex_unlock(&mesh->mutex); return NULL; } } if(n->status.blacklisted) { logger(mesh, MESHLINK_ERROR, "Cannot open a channel with blacklisted node\n"); + meshlink_errno = MESHLINK_EBLACKLISTED; + pthread_mutex_unlock(&mesh->mutex); return NULL; } meshlink_channel_t *channel = xzalloc(sizeof(*channel)); channel->node = n; channel->receive_cb = cb; + + if(data && !len) { + channel->priv = (void *)data; + } + channel->c = utcp_connect_ex(n->utcp, port, channel_recv, channel, flags); + pthread_mutex_unlock(&mesh->mutex); + if(!channel->c) { meshlink_errno = errno == ENOMEM ? MESHLINK_ENOMEM : MESHLINK_EINTERNAL; free(channel); @@ -3097,7 +3446,9 @@ void meshlink_channel_shutdown(meshlink_handle_t *mesh, meshlink_channel_t *chan return; } + pthread_mutex_lock(&mesh->mutex); utcp_shutdown(channel->c, direction); + pthread_mutex_unlock(&mesh->mutex); } void meshlink_channel_close(meshlink_handle_t *mesh, meshlink_channel_t *channel) { @@ -3106,6 +3457,8 @@ void meshlink_channel_close(meshlink_handle_t *mesh, meshlink_channel_t *channel return; } + pthread_mutex_lock(&mesh->mutex); + utcp_close(channel->c); /* Clean up any outstanding AIO buffers. */ @@ -3121,6 +3474,8 @@ void meshlink_channel_close(meshlink_handle_t *mesh, meshlink_channel_t *channel free(aio); } + pthread_mutex_unlock(&mesh->mutex); + free(channel); } @@ -3146,7 +3501,7 @@ ssize_t meshlink_channel_send(meshlink_handle_t *mesh, meshlink_channel_t *chann ssize_t retval; - pthread_mutex_lock(&mesh->mesh_mutex); + pthread_mutex_lock(&mesh->mutex); /* Disallow direct calls to utcp_send() while we still have AIO active. */ if(channel->aio_send) { @@ -3155,7 +3510,7 @@ ssize_t meshlink_channel_send(meshlink_handle_t *mesh, meshlink_channel_t *chann retval = utcp_send(channel->c, data, len); } - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); if(retval < 0) { meshlink_errno = MESHLINK_ENETWORK; @@ -3181,7 +3536,7 @@ bool meshlink_channel_aio_send(meshlink_handle_t *mesh, meshlink_channel_t *chan aio->cb.buffer = cb; aio->priv = priv; - pthread_mutex_lock(&mesh->mesh_mutex); + pthread_mutex_lock(&mesh->mutex); /* Append the AIO buffer descriptor to the end of the chain */ meshlink_aio_buffer_t **p = &channel->aio_send; @@ -3196,7 +3551,7 @@ bool meshlink_channel_aio_send(meshlink_handle_t *mesh, meshlink_channel_t *chan utcp_set_poll_cb(channel->c, channel_poll); channel_poll(channel->c, len); - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); return true; } @@ -3218,7 +3573,7 @@ bool meshlink_channel_aio_fd_send(meshlink_handle_t *mesh, meshlink_channel_t *c aio->cb.fd = cb; aio->priv = priv; - pthread_mutex_lock(&mesh->mesh_mutex); + pthread_mutex_lock(&mesh->mutex); /* Append the AIO buffer descriptor to the end of the chain */ meshlink_aio_buffer_t **p = &channel->aio_send; @@ -3233,7 +3588,7 @@ bool meshlink_channel_aio_fd_send(meshlink_handle_t *mesh, meshlink_channel_t *c utcp_set_poll_cb(channel->c, channel_poll); channel_poll(channel->c, len); - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); return true; } @@ -3255,7 +3610,7 @@ bool meshlink_channel_aio_receive(meshlink_handle_t *mesh, meshlink_channel_t *c aio->cb.buffer = cb; aio->priv = priv; - pthread_mutex_lock(&mesh->mesh_mutex); + pthread_mutex_lock(&mesh->mutex); /* Append the AIO buffer descriptor to the end of the chain */ meshlink_aio_buffer_t **p = &channel->aio_receive; @@ -3266,7 +3621,7 @@ bool meshlink_channel_aio_receive(meshlink_handle_t *mesh, meshlink_channel_t *c *p = aio; - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); return true; } @@ -3288,7 +3643,7 @@ bool meshlink_channel_aio_fd_receive(meshlink_handle_t *mesh, meshlink_channel_t aio->cb.fd = cb; aio->priv = priv; - pthread_mutex_lock(&mesh->mesh_mutex); + pthread_mutex_lock(&mesh->mutex); /* Append the AIO buffer descriptor to the end of the chain */ meshlink_aio_buffer_t **p = &channel->aio_receive; @@ -3299,7 +3654,7 @@ bool meshlink_channel_aio_fd_receive(meshlink_handle_t *mesh, meshlink_channel_t *p = aio; - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); return true; } @@ -3331,6 +3686,25 @@ size_t meshlink_channel_get_recvq(meshlink_handle_t *mesh, meshlink_channel_t *c return utcp_get_recvq(channel->c); } +void meshlink_set_node_channel_timeout(meshlink_handle_t *mesh, meshlink_node_t *node, int timeout) { + if(!mesh || !node) { + meshlink_errno = MESHLINK_EINVAL; + return; + } + + node_t *n = (node_t *)node; + + pthread_mutex_lock(&mesh->mutex); + + if(!n->utcp) { + n->utcp = utcp_init(channel_accept, channel_pre_accept, channel_send, n); + } + + utcp_set_user_timeout(n->utcp, timeout); + + pthread_mutex_unlock(&mesh->mutex); +} + void update_node_status(meshlink_handle_t *mesh, node_t *n) { if(n->status.reachable && mesh->channel_accept_cb && !n->utcp) { n->utcp = utcp_init(channel_accept, channel_pre_accept, channel_send, n); @@ -3339,6 +3713,16 @@ void update_node_status(meshlink_handle_t *mesh, node_t *n) { if(mesh->node_status_cb) { mesh->node_status_cb(mesh, (meshlink_node_t *)n, n->status.reachable && !n->status.blacklisted); } + + if(mesh->node_pmtu_cb) { + mesh->node_pmtu_cb(mesh, (meshlink_node_t *)n, n->minmtu); + } +} + +void update_node_pmtu(meshlink_handle_t *mesh, node_t *n) { + if(mesh->node_pmtu_cb && !n->status.blacklisted) { + mesh->node_pmtu_cb(mesh, (meshlink_node_t *)n, n->minmtu); + } } void handle_duplicate_node(meshlink_handle_t *mesh, node_t *n) { @@ -3358,7 +3742,7 @@ void meshlink_enable_discovery(meshlink_handle_t *mesh, bool enable) { return; } - pthread_mutex_lock(&mesh->mesh_mutex); + pthread_mutex_lock(&mesh->mutex); if(mesh->discovery == enable) { goto end; @@ -3375,7 +3759,7 @@ void meshlink_enable_discovery(meshlink_handle_t *mesh, bool enable) { mesh->discovery = enable; end: - pthread_mutex_unlock(&mesh->mesh_mutex); + pthread_mutex_unlock(&mesh->mutex); #else (void)mesh; (void)enable; @@ -3383,31 +3767,53 @@ end: #endif } +void meshlink_set_dev_class_timeouts(meshlink_handle_t *mesh, dev_class_t devclass, int pinginterval, int pingtimeout) { + if(!mesh || devclass < 0 || devclass >= DEV_CLASS_COUNT) { + meshlink_errno = EINVAL; + return; + } + + if(pinginterval < 1 || pingtimeout < 1 || pingtimeout > pinginterval) { + meshlink_errno = EINVAL; + return; + } + + pthread_mutex_lock(&mesh->mutex); + mesh->dev_class_traits[devclass].pinginterval = pinginterval; + mesh->dev_class_traits[devclass].pingtimeout = pingtimeout; + pthread_mutex_unlock(&mesh->mutex); +} + void handle_network_change(meshlink_handle_t *mesh, bool online) { (void)online; - if(!mesh->connections) { + if(!mesh->connections || !mesh->loop.running) { return; } retry(mesh); } +void call_error_cb(meshlink_handle_t *mesh, meshlink_errno_t meshlink_errno) { + // We should only call the callback function if we are in the background thread. + if(!mesh->error_cb) { + return; + } + + if(!mesh->threadstarted) { + return; + } + + if(mesh->thread == pthread_self()) { + mesh->error_cb(mesh, meshlink_errno); + } +} + + static void __attribute__((constructor)) meshlink_init(void) { crypto_init(); - unsigned int seed; - randomize(&seed, sizeof(seed)); - srand(seed); } static void __attribute__((destructor)) meshlink_exit(void) { crypto_exit(); } - -/// Device class traits -const dev_class_traits_t dev_class_traits[_DEV_CLASS_MAX + 1] = { - { .min_connects = 3, .max_connects = 10000, .edge_weight = 1 }, // DEV_CLASS_BACKBONE - { .min_connects = 3, .max_connects = 100, .edge_weight = 3 }, // DEV_CLASS_STATIONARY - { .min_connects = 3, .max_connects = 3, .edge_weight = 6 }, // DEV_CLASS_PORTABLE - { .min_connects = 1, .max_connects = 1, .edge_weight = 9 }, // DEV_CLASS_UNKNOWN -};