}
}
+#ifdef HAVE_GETIFADDRS
+struct getifaddrs_in_netns_params {
+ struct ifaddrs **ifa;
+ int netns;
+};
+
+#ifdef HAVE_SETNS
+static void *getifaddrs_in_netns_thread(void *arg) {
+ struct getifaddrs_in_netns_params *params = arg;
+
+ if(setns(params->netns, CLONE_NEWNET) == -1) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return NULL;
+ }
+
+ if(getifaddrs(params->ifa) != 0) {
+ *params->ifa = NULL;
+ }
+
+ return NULL;
+}
+#endif // HAVE_SETNS
+
+static int getifaddrs_in_netns(struct ifaddrs **ifa, int netns) {
+ if(netns == -1) {
+ return getifaddrs(ifa);
+ }
+
+#ifdef HAVE_SETNS
+ struct getifaddrs_in_netns_params params = {ifa, netns};
+ pthread_t thr;
+
+ if(pthread_create(&thr, NULL, getifaddrs_in_netns_thread, ¶ms) == 0) {
+ if(pthread_join(thr, NULL) != 0) {
+ abort();
+ }
+ }
+
+ return *params.ifa ? 0 : -1;
+#else
+ return -1;
+#endif // HAVE_SETNS
+
+}
+#endif
+
char *meshlink_get_local_address_for_family(meshlink_handle_t *mesh, int family) {
- (void)mesh;
+ if(!mesh) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return NULL;
+ }
// Determine address of the local interface used for outgoing connections.
char localaddr[NI_MAXHOST];
if(!success) {
struct ifaddrs *ifa = NULL;
- getifaddrs(&ifa);
+ getifaddrs_in_netns(&ifa, mesh->netns);
for(struct ifaddrs *ifap = ifa; ifap; ifap = ifap->ifa_next) {
sockaddr_t *sa = (sockaddr_t *)ifap->ifa_addr;
- if(sa->sa.sa_family != family) {
+ if(!sa || sa->sa.sa_family != family) {
continue;
}
}
/* Write our own host config file */
- if(!node_write_config(mesh, mesh->self)) {
+ if(!node_write_config(mesh, mesh->self, true)) {
return false;
}
n->last_reachable = 0;
n->last_unreachable = 0;
- if(!node_write_config(mesh, n)) {
+ if(!node_write_config(mesh, n, true)) {
free_node(n);
return false;
}
}
/* Ensure the configuration directory metadata is on disk */
- if(!config_sync(mesh, "current") || !sync_path(mesh->confbase)) {
+ if(!config_sync(mesh, "current") || (mesh->confbase && !sync_path(mesh->confbase))) {
return false;
}
return true;
}
+bool meshlink_open_params_set_storage_policy(meshlink_open_params_t *params, meshlink_storage_policy_t policy) {
+ if(!params) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return false;
+ }
+
+ params->storage_policy = policy;
+
+ return true;
+}
+
bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *new_key, size_t new_keylen) {
if(!mesh || !new_key || !new_keylen) {
logger(mesh, MESHLINK_ERROR, "Invalid arguments given!\n");
// If no configuration exists yet, create it.
+ bool new_configuration = false;
+
if(!meshlink_confbase_exists(mesh)) {
if(!mesh->name) {
logger(NULL, MESHLINK_ERROR, "No configuration files found!\n");
meshlink_close(mesh);
return NULL;
}
+
+ new_configuration = true;
} else {
if(!meshlink_read_config(mesh)) {
logger(NULL, MESHLINK_ERROR, "Cannot read main configuration\n");
}
}
+ mesh->storage_policy = params->storage_policy;
+
#ifdef HAVE_MINGW
struct WSAData wsa_state;
WSAStartup(MAKEWORD(2, 2), &wsa_state);
add_local_addresses(mesh);
- if(!node_write_config(mesh, mesh->self)) {
+ if(!node_write_config(mesh, mesh->self, new_configuration)) {
logger(NULL, MESHLINK_ERROR, "Cannot update configuration\n");
return NULL;
}
return false;
}
+ // Reset node connection timers
+ for splay_each(node_t, n, mesh->nodes) {
+ n->last_connect_try = 0;
+ }
+
// TODO: open listening sockets first
//Check that a valid name is set
if(mesh->nodes) {
for splay_each(node_t, n, mesh->nodes) {
if(n->status.dirty) {
- n->status.dirty = !node_write_config(mesh, n);
+ if(!node_write_config(mesh, n, false)) {
+ // ignore
+ }
}
}
}
pthread_mutex_unlock(&mesh->mutex);
}
+void meshlink_set_blacklisted_cb(struct meshlink_handle *mesh, meshlink_blacklisted_cb_t cb) {
+ if(!mesh) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return;
+ }
+
+ if(pthread_mutex_lock(&mesh->mutex) != 0) {
+ abort();
+ }
+
+ mesh->blacklisted_cb = cb;
+ pthread_mutex_unlock(&mesh->mutex);
+}
+
static bool prepare_packet(meshlink_handle_t *mesh, meshlink_node_t *destination, const void *data, size_t len, vpn_packet_t *packet) {
meshlink_packethdr_t *hdr;
return false;
}
+static bool search_node_by_blacklisted(const node_t *node, const void *condition) {
+ return *(bool *)condition == node->status.blacklisted;
+}
+
static bool search_node_by_submesh(const node_t *node, const void *condition) {
if(condition == node->submesh) {
return true;
return meshlink_get_all_nodes_by_condition(mesh, &range, nodes, nmemb, search_node_by_last_reachable);
}
+meshlink_node_t **meshlink_get_all_nodes_by_blacklisted(meshlink_handle_t *mesh, bool blacklisted, meshlink_node_t **nodes, size_t *nmemb) {
+ if(!mesh || !nmemb) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return NULL;
+ }
+
+ return meshlink_get_all_nodes_by_condition(mesh, &blacklisted, nodes, nmemb, search_node_by_blacklisted);
+}
+
dev_class_t meshlink_get_node_dev_class(meshlink_handle_t *mesh, meshlink_node_t *node) {
if(!mesh || !node) {
meshlink_errno = MESHLINK_EINVAL;
return devclass;
}
+bool meshlink_get_node_blacklisted(meshlink_handle_t *mesh, meshlink_node_t *node) {
+ if(!mesh) {
+ meshlink_errno = MESHLINK_EINVAL;
+ }
+
+ if(!node) {
+ return mesh->default_blacklist;
+ }
+
+ bool blacklisted;
+
+ if(pthread_mutex_lock(&mesh->mutex) != 0) {
+ abort();
+ }
+
+ blacklisted = ((node_t *)node)->status.blacklisted;
+
+ pthread_mutex_unlock(&mesh->mutex);
+
+ return blacklisted;
+}
+
meshlink_submesh_t *meshlink_get_node_submesh(meshlink_handle_t *mesh, meshlink_node_t *node) {
if(!mesh || !node) {
meshlink_errno = MESHLINK_EINVAL;
char *canonical_address;
- if(port) {
- xasprintf(&canonical_address, "%s %s", address, port);
- } else {
- canonical_address = xstrdup(address);
- }
+ xasprintf(&canonical_address, "%s %s", address, port ? port : mesh->myport);
if(pthread_mutex_lock(&mesh->mutex) != 0) {
abort();
free(n->canonical_address);
n->canonical_address = canonical_address;
- if(!node_write_config(mesh, n)) {
+ if(!node_write_config(mesh, n, false)) {
+ pthread_mutex_unlock(&mesh->mutex);
+ return false;
+ }
+
+ pthread_mutex_unlock(&mesh->mutex);
+
+ return config_sync(mesh, "current");
+}
+
+bool meshlink_clear_canonical_address(meshlink_handle_t *mesh, meshlink_node_t *node) {
+ if(!mesh || !node) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return false;
+ }
+
+ if(pthread_mutex_lock(&mesh->mutex) != 0) {
+ abort();
+ }
+
+ node_t *n = (node_t *)node;
+ free(n->canonical_address);
+ n->canonical_address = NULL;
+
+ if(!node_write_config(mesh, n, false)) {
pthread_mutex_unlock(&mesh->mutex);
return false;
}
// If we changed our own host config file, write it out now
if(mesh->self->status.dirty) {
- if(!node_write_config(mesh, mesh->self)) {
+ if(!node_write_config(mesh, mesh->self, false)) {
logger(mesh, MESHLINK_ERROR, "Could not write our own host config file!\n");
pthread_mutex_unlock(&mesh->mutex);
return NULL;
n->last_reachable = 0;
n->last_unreachable = 0;
- if(!node_write_config(mesh, n)) {
+ if(!node_write_config(mesh, n, true)) {
free_node(n);
return false;
}
*/
for list_each(connection_t, c, mesh->connections) {
if(c->node == n) {
+ if(c->status.active) {
+ send_error(mesh, c, BLACKLISTED, "blacklisted");
+ }
+
shutdown(c->socket, SHUT_RDWR);
}
}
mesh->node_status_cb(mesh, (meshlink_node_t *)n, false);
}
- return node_write_config(mesh, n) && config_sync(mesh, "current");
+ /* Remove any outstanding invitations */
+ invitation_purge_node(mesh, n->name);
+
+ return node_write_config(mesh, n, true) && config_sync(mesh, "current");
}
bool meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) {
update_node_status(mesh, n);
}
- return node_write_config(mesh, n) && config_sync(mesh, "current");
+ return node_write_config(mesh, n, true) && config_sync(mesh, "current");
}
bool meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) {
return false;
}
+ /* Delete any pending invitations */
+ invitation_purge_node(mesh, n->name);
+
/* Delete the node struct and any remaining edges referencing this node */
node_del(mesh, n);
node_t *n = (node_t *)node;
if(node_add_recent_address(mesh, n, (sockaddr_t *)addr)) {
- if(!node_write_config(mesh, n)) {
+ if(!node_write_config(mesh, n, false)) {
logger(mesh, MESHLINK_DEBUG, "Could not update %s\n", n->name);
}
}
(void)port;
node_t *n = utcp->priv;
meshlink_handle_t *mesh = n->mesh;
- return mesh->channel_accept_cb;
+
+ if(mesh->channel_accept_cb && mesh->channel_listen_cb) {
+ return mesh->channel_listen_cb(mesh, (meshlink_node_t *)n, port);
+ } else {
+ return mesh->channel_accept_cb;
+ }
}
/* Finish one AIO buffer, return true if the channel is still open. */
node_t *n = utcp_connection->utcp->priv;
meshlink_handle_t *mesh = n->mesh;
- if(n->mtuprobes == 31) {
+ if(n->mtuprobes == 31 && n->mtutimeout.cb) {
timeout_set(&mesh->loop, &n->mtutimeout, &(struct timespec) {
0, 0
});
}
if(sent != (ssize_t)todo) {
- /* We should never get a partial send at this point */
- assert(sent <= 0);
-
/* Sending failed, abort all outstanding AIO buffers and send a poll callback. */
if(!aio_abort(mesh, channel, &channel->aio_send)) {
return;
pthread_mutex_unlock(&mesh->mutex);
}
+void meshlink_set_channel_listen_cb(meshlink_handle_t *mesh, meshlink_channel_listen_cb_t cb) {
+ if(!mesh) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return;
+ }
+
+ if(pthread_mutex_lock(&mesh->mutex) != 0) {
+ abort();
+ }
+
+ mesh->channel_listen_cb = cb;
+
+ pthread_mutex_unlock(&mesh->mutex);
+}
+
void meshlink_set_channel_accept_cb(meshlink_handle_t *mesh, meshlink_channel_accept_cb_t cb) {
if(!mesh) {
meshlink_errno = MESHLINK_EINVAL;
}
void meshlink_set_channel_sndbuf(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t size) {
- (void)mesh;
+ meshlink_set_channel_sndbuf_storage(mesh, channel, NULL, size);
+}
- if(!channel) {
+void meshlink_set_channel_rcvbuf(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t size) {
+ meshlink_set_channel_rcvbuf_storage(mesh, channel, NULL, size);
+}
+
+void meshlink_set_channel_sndbuf_storage(meshlink_handle_t *mesh, meshlink_channel_t *channel, void *buf, size_t size) {
+ if(!mesh || !channel) {
meshlink_errno = MESHLINK_EINVAL;
return;
}
abort();
}
- utcp_set_sndbuf(channel->c, size);
+ utcp_set_sndbuf(channel->c, buf, size);
pthread_mutex_unlock(&mesh->mutex);
}
-void meshlink_set_channel_rcvbuf(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t size) {
- (void)mesh;
+void meshlink_set_channel_rcvbuf_storage(meshlink_handle_t *mesh, meshlink_channel_t *channel, void *buf, size_t size) {
+ if(!mesh || !channel) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return;
+ }
- if(!channel) {
+ if(pthread_mutex_lock(&mesh->mutex) != 0) {
+ abort();
+ }
+
+ utcp_set_rcvbuf(channel->c, buf, size);
+ pthread_mutex_unlock(&mesh->mutex);
+}
+
+void meshlink_set_channel_flags(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint32_t flags) {
+ if(!mesh || !channel) {
meshlink_errno = MESHLINK_EINVAL;
return;
}
abort();
}
- utcp_set_rcvbuf(channel->c, size);
+ utcp_set_flags(channel->c, flags);
pthread_mutex_unlock(&mesh->mutex);
}
utcp_set_clock_granularity(granularity);
}
+void meshlink_set_storage_policy(struct meshlink_handle *mesh, meshlink_storage_policy_t policy) {
+ if(!mesh) {
+ meshlink_errno = EINVAL;
+ return;
+ }
+
+ if(pthread_mutex_lock(&mesh->mutex) != 0) {
+ abort();
+ }
+
+ mesh->storage_policy = policy;
+ pthread_mutex_unlock(&mesh->mutex);
+}
+
void handle_network_change(meshlink_handle_t *mesh, bool online) {
(void)online;
projects / meshlink / blobdiff