break;
}
- if(found) {
+ if(found || !is_valid_hostname(host[i])) {
free(host[i]);
free(port[i]);
host[i] = NULL;
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;
}
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);
// 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
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(devclass < 0 || devclass >= DEV_CLASS_COUNT) {
mesh->log_cb = global_log_cb;
mesh->log_level = global_log_level;
+ randomize(&mesh->prng_state, sizeof(mesh->prng_state));
+
memcpy(mesh->dev_class_traits, default_class_traits, sizeof(default_class_traits));
if(usingname) {
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->mesh_mutex);
+ pthread_mutex_destroy(&mesh->mesh_mutex);
+
memset(mesh, 0, sizeof(*mesh));
free(mesh);
}
}
+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->mesh_mutex));
+ mesh->error_cb = cb;
+ pthread_mutex_unlock(&(mesh->mesh_mutex));
+}
+
bool meshlink_send(meshlink_handle_t *mesh, meshlink_node_t *destination, const void *data, size_t len) {
meshlink_packethdr_t *hdr;
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) {
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) {
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));
+
+ if(!node) {
+ meshlink_errno = MESHLINK_ENOENT;
+ }
+
return node;
}
pthread_mutex_lock(&(mesh->mesh_mutex));
submesh = (meshlink_submesh_t *)lookup_submesh(mesh, name);
pthread_mutex_unlock(&(mesh->mesh_mutex));
+
+ if(!submesh) {
+ meshlink_errno = MESHLINK_ENOENT;
+ }
+
return submesh;
}
return -1;
}
- return atoi(mesh->myport);
+ int port;
+
+ pthread_mutex_lock(&(mesh->mesh_mutex));
+ port = atoi(mesh->myport);
+ pthread_mutex_unlock(&(mesh->mesh_mutex));
+
+ return port;
}
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 */
/* Write meshlink.conf with the updated port number */
write_main_config_files(mesh);
- if(!config_sync(mesh, "current")) {
- return false;
- }
+ rval = config_sync(mesh, "current");
done:
pthread_mutex_unlock(&(mesh->mesh_mutex));
pthread_mutex_unlock(&(mesh->mesh_mutex));
+ free(buf);
+
if(!packmsg_done(&in)) {
logger(mesh, MESHLINK_ERROR, "Invalid data\n");
meshlink_errno = MESHLINK_EPEER;
}
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->mesh_mutex);
channel->poll_cb = cb;
utcp_set_poll_cb(channel->c, (cb || channel->aio_send) ? channel_poll : NULL);
+ pthread_mutex_unlock(&mesh->mesh_mutex);
}
void meshlink_set_channel_accept_cb(meshlink_handle_t *mesh, meshlink_channel_accept_cb_t cb) {
return NULL;
}
+ pthread_mutex_lock(&mesh->mesh_mutex);
+
node_t *n = (node_t *)node;
if(!n->utcp) {
if(!n->utcp) {
meshlink_errno = errno == ENOMEM ? MESHLINK_ENOMEM : MESHLINK_EINTERNAL;
+ pthread_mutex_unlock(&mesh->mesh_mutex);
return NULL;
}
}
if(n->status.blacklisted) {
logger(mesh, MESHLINK_ERROR, "Cannot open a channel with blacklisted node\n");
+ pthread_mutex_unlock(&mesh->mesh_mutex);
return NULL;
}
channel->receive_cb = cb;
channel->c = utcp_connect_ex(n->utcp, port, channel_recv, channel, flags);
+ pthread_mutex_unlock(&mesh->mesh_mutex);
+
if(!channel->c) {
meshlink_errno = errno == ENOMEM ? MESHLINK_ENOMEM : MESHLINK_EINTERNAL;
free(channel);
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);
}
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) {
projects / meshlink / blobdiff