}
}
+ /* Ensure the configuration directory metadata is on disk */
+ if(!config_sync(mesh, "current")) {
+ 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);
return false;
}
+ /* Ensure the configuration directory metadata is on disk */
+ if(!config_sync(mesh, "current")) {
+ return false;
+ }
+
if(!main_config_lock(mesh)) {
logger(NULL, MESHLINK_ERROR, "Cannot lock main config file\n");
meshlink_errno = MESHLINK_ESTORAGE;
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");
}
/* 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;
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;
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;
+
+ memcpy(mesh->dev_class_traits, default_class_traits, sizeof(default_class_traits));
if(usingname) {
mesh->name = xstrdup(params->name);
pthread_mutex_unlock(&(mesh->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->mesh_mutex));
+ mesh->node_pmtu_cb = cb;
+ pthread_mutex_unlock(&(mesh->mesh_mutex));
+}
+
void meshlink_set_node_duplicate_cb(meshlink_handle_t *mesh, meshlink_node_duplicate_cb_t cb) {
if(!mesh) {
meshlink_errno = MESHLINK_EINVAL;
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);
rval = true;
}
+ /* 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);
+
+ if(!config_sync(mesh, "current")) {
+ return false;
+ }
+
done:
pthread_mutex_unlock(&(mesh->mesh_mutex));
* 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)) {
return false;
}
+ if(!config_sync(mesh, "current")) {
+ return false;
+ }
+
return true;
}
n->status.blacklisted = true;
node_write_config(mesh, n);
+ config_sync(mesh, "current");
+
logger(mesh, MESHLINK_DEBUG, "Blacklisted %s.\n", node->name);
//Immediately terminate any connections we have with the blacklisted node
n->status.blacklisted = false;
node_write_config(mesh, n);
+ config_sync(mesh, "current");
+
+ if(n->status.reachable) {
+ update_node_status(mesh, n);
+ }
pthread_mutex_unlock(&(mesh->mesh_mutex));
return;
return;
}
+ pthread_mutex_lock(&mesh->mesh_mutex);
utcp_shutdown(channel->c, direction);
+ pthread_mutex_unlock(&mesh->mesh_mutex);
}
void meshlink_channel_close(meshlink_handle_t *mesh, meshlink_channel_t *channel) {
return;
}
+ pthread_mutex_lock(&mesh->mesh_mutex);
+
utcp_close(channel->c);
/* Clean up any outstanding AIO buffers. */
free(aio);
}
+ pthread_mutex_unlock(&mesh->mesh_mutex);
+
free(channel);
}
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) {
#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->mesh_mutex);
+ mesh->dev_class_traits[devclass].pinginterval = pinginterval;
+ mesh->dev_class_traits[devclass].pingtimeout = pingtimeout;
+ pthread_mutex_unlock(&mesh->mesh_mutex);
+}
+
void handle_network_change(meshlink_handle_t *mesh, bool online) {
(void)online;
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
-};
projects / meshlink / blobdiff