/*
meshlink.c -- Implementation of the MeshLink API.
- Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+ Copyright (C) 2014, 2017 Guus Sliepen <guus@meshlink.io>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "node.h"
#include "protocol.h"
#include "route.h"
+#include "sockaddr.h"
#include "utils.h"
#include "xalloc.h"
#include "ed25519/sha512.h"
fclose(f);
}
-static char *get_my_hostname(meshlink_handle_t* mesh) {
- char *hostname = NULL;
- char *port = NULL;
- char *hostport = NULL;
- char *name = mesh->self->name;
- char filename[PATH_MAX] = "";
- char line[4096];
- FILE *f;
- // Use first Address statement in own host config file
- snprintf(filename, sizeof filename, "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name);
- scan_for_hostname(filename, &hostname, &port);
+static bool is_valid_hostname(const char *hostname) {
+ for(const char *p = hostname; *p; p++) {
+ if(!(isalnum(*p) || *p == '-' || *p == '.' || *p == ':'))
+ return false;
+ }
- if(hostname)
- goto done;
+ return true;
+}
+
+char *meshlink_get_external_address(meshlink_handle_t *mesh) {
+ char *hostname = NULL;
- // If that doesn't work, guess externally visible hostname
logger(mesh, MESHLINK_DEBUG, "Trying to discover externally visible hostname...\n");
struct addrinfo *ai = str2addrinfo("meshlink.io", "80", SOCK_STREAM);
struct addrinfo *aip = ai;
static const char request[] = "GET http://www.meshlink.io/host.cgi HTTP/1.0\r\n\r\n";
+ char line[256];
while(aip) {
int s = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
freeaddrinfo(ai);
// Check that the hostname is reasonable
- if(hostname) {
- for(char *p = hostname; *p; p++) {
- if(isalnum(*p) || *p == '-' || *p == '.' || *p == ':')
- continue;
- // If not, forget it.
- free(hostname);
- hostname = NULL;
- break;
- }
+ if(hostname && !is_valid_hostname(hostname)) {
+ free(hostname);
+ hostname = NULL;
}
+ if(!hostname)
+ meshlink_errno = MESHLINK_ERESOLV;
+
+ return hostname;
+}
+
+static char *get_my_hostname(meshlink_handle_t* mesh) {
+ char *hostname = NULL;
+ char *port = NULL;
+ char *hostport = NULL;
+ char *name = mesh->self->name;
+ char filename[PATH_MAX] = "";
+ FILE *f;
+
+ // Use first Address statement in own host config file
+ snprintf(filename, sizeof filename, "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name);
+ scan_for_hostname(filename, &hostname, &port);
+
+ if(hostname)
+ goto done;
+
+ hostname = meshlink_get_external_address(mesh);
if(!hostname)
return NULL;
return tmin;
}
+// Find out what local address a socket would use if we connect to the given address.
+// We do this using connect() on a UDP socket, so the kernel has to resolve the address
+// of both endpoints, but this will actually not send any UDP packet.
+static bool getlocaladdrname(char *destaddr, char *host, socklen_t hostlen) {
+ struct addrinfo *rai = NULL;
+ const struct addrinfo hint = {
+ .ai_family = AF_UNSPEC,
+ .ai_socktype = SOCK_DGRAM,
+ .ai_protocol = IPPROTO_UDP,
+ };
+
+ if(getaddrinfo(destaddr, "80", &hint, &rai) || !rai)
+ return false;
+
+ int sock = socket(rai->ai_family, rai->ai_socktype, rai->ai_protocol);
+ if(sock == -1) {
+ freeaddrinfo(rai);
+ return false;
+ }
+
+ if(connect(sock, rai->ai_addr, rai->ai_addrlen) && !sockwouldblock(errno)) {
+ freeaddrinfo(rai);
+ return false;
+ }
+
+ freeaddrinfo(rai);
+
+ struct sockaddr_storage sn;
+ socklen_t sl = sizeof sn;
+
+ if(getsockname(sock, (struct sockaddr *)&sn, &sl))
+ return false;
+
+ if(getnameinfo((struct sockaddr *)&sn, sl, host, hostlen, NULL, 0, NI_NUMERICHOST | NI_NUMERICSERV))
+ return false;
+
+ return true;
+}
+
+// Get our local address(es) by simulating connecting to an Internet host.
+static void add_local_addresses(meshlink_handle_t *mesh) {
+ char host[NI_MAXHOST];
+ char entry[MAX_STRING_SIZE];
+
+ // IPv4 example.org
+
+ if(getlocaladdrname("93.184.216.34", host, sizeof host)) {
+ snprintf(entry, sizeof entry, "%s %s", host, mesh->myport);
+ append_config_file(mesh, mesh->name, "Address", entry);
+ }
+
+ // IPv6 example.org
+
+ if(getlocaladdrname("2606:2800:220:1:248:1893:25c8:1946", host, sizeof host)) {
+ snprintf(entry, sizeof entry, "%s %s", host, mesh->myport);
+ append_config_file(mesh, mesh->name, "Address", entry);
+ }
+}
+
static bool meshlink_setup(meshlink_handle_t *mesh) {
if(mkdir(mesh->confbase, 0777) && errno != EEXIST) {
logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", mesh->confbase, strerror(errno));
return NULL;
}
+ add_local_addresses(mesh);
+
idle_set(&mesh->loop, idle, mesh);
logger(NULL, MESHLINK_DEBUG, "meshlink_open returning\n");
meshlink_errno = MESHLINK_EINVAL;
return false;
}
- pthread_mutex_lock(&(mesh->mesh_mutex));
logger(mesh, MESHLINK_DEBUG, "meshlink_start called\n");
+ pthread_mutex_lock(&(mesh->mesh_mutex));
+
+ if(mesh->threadstarted) {
+ logger(mesh, MESHLINK_DEBUG, "thread was already running\n");
+ pthread_mutex_unlock(&(mesh->mesh_mutex));
+ return true;
+ }
+
+ if(mesh->listen_socket[0].tcp.fd < 0) {
+ logger(mesh, MESHLINK_ERROR, "Listening socket not open\n");
+ meshlink_errno = MESHLINK_ENETWORK;
+ return false;
+ }
+
mesh->thedatalen = 0;
// TODO: open listening sockets first
// Start the main thread
+ event_loop_start(&mesh->loop);
+
if(pthread_create(&mesh->thread, NULL, meshlink_main_loop, mesh) != 0) {
logger(mesh, MESHLINK_DEBUG, "Could not start thread: %s\n", strerror(errno));
memset(&mesh->thread, 0, sizeof mesh->thread);
// Stop discovery
discovery_stop(mesh);
- // Shut down a listening socket to signal the main thread to shut down
+ pthread_mutex_lock(&(mesh->mesh_mutex));
+ logger(mesh, MESHLINK_DEBUG, "meshlink_stop called\n");
+
+ // Shut down the main thread
+ event_loop_stop(&mesh->loop);
+ // Send ourselves a UDP packet to kick the event loop
listen_socket_t *s = &mesh->listen_socket[0];
- shutdown(s->tcp.fd, SHUT_RDWR);
+ if(sendto(s->udp.fd, "", 1, MSG_NOSIGNAL, &s->sa.sa, SALEN(s->sa.sa)) == -1)
+ logger(mesh, MESHLINK_ERROR, "Could not send a UDP packet to ourself");
// Wait for the main thread to finish
pthread_mutex_unlock(&(mesh->mesh_mutex));
mesh->threadstarted = false;
- // Fix the socket
-
- closesocket(s->tcp.fd);
- io_del(&mesh->loop, &s->tcp);
- s->tcp.fd = setup_listen_socket(&s->sa);
- if(s->tcp.fd < 0)
- logger(mesh, MESHLINK_ERROR, "Could not repair listenen socket!");
- else
- io_add(&mesh->loop, &s->tcp, handle_new_meta_connection, s, s->tcp.fd, IO_READ);
-
pthread_mutex_unlock(&(mesh->mesh_mutex));
}
free(mesh);
}
+static void deltree(const char *dirname) {
+ DIR *d = opendir(dirname);
+ if(d) {
+ struct dirent *ent;
+ while((ent = readdir(d))) {
+ if(ent->d_name[0] == '.')
+ continue;
+ char filename[PATH_MAX];
+ snprintf(filename, sizeof filename, "%s" SLASH "%s", dirname, ent->d_name);
+ if(unlink(filename))
+ deltree(filename);
+ }
+ closedir(d);
+ }
+ rmdir(dirname);
+ return;
+}
+
+bool meshlink_destroy(const char *confbase) {
+ if(!confbase) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return false;
+ }
+
+ char filename[PATH_MAX];
+ snprintf(filename, sizeof filename, "%s" SLASH "meshlink.conf", confbase);
+
+ if(unlink(filename)) {
+ if(errno == ENOENT) {
+ meshlink_errno = MESHLINK_ENOENT;
+ return false;
+ } else {
+ logger(NULL, MESHLINK_ERROR, "Cannot delete %s: %s\n", filename, strerror(errno));
+ meshlink_errno = MESHLINK_ESTORAGE;
+ return false;
+ }
+ }
+
+ deltree(confbase);
+
+ return true;
+}
+
void meshlink_set_receive_cb(meshlink_handle_t *mesh, meshlink_receive_cb_t cb) {
if(!mesh) {
meshlink_errno = MESHLINK_EINVAL;
return fingerprint;
}
+meshlink_node_t *meshlink_get_self(meshlink_handle_t *mesh) {
+ if(!mesh) {
+ meshlink_errno = MESHLINK_EINVAL;
+ return NULL;
+ }
+
+ return (meshlink_node_t *)mesh->self;
+}
+
meshlink_node_t *meshlink_get_node(meshlink_handle_t *mesh, const char *name) {
if(!mesh || !name) {
meshlink_errno = MESHLINK_EINVAL;
meshlink_errno = MESHLINK_EINVAL;
return false;
}
-
+
+ if(!is_valid_hostname(address)) {
+ logger(mesh, MESHLINK_DEBUG, "Invalid character in address: %s\n", address);
+ meshlink_errno = MESHLINK_EINVAL;
+ return false;
+ }
+
bool rval = false;
pthread_mutex_lock(&(mesh->mesh_mutex));
+ rval = append_config_file(mesh, mesh->self->name, "Address", address);
+ pthread_mutex_unlock(&(mesh->mesh_mutex));
- for(const char *p = address; *p; p++) {
- if(isalnum(*p) || *p == '-' || *p == '.' || *p == ':')
- continue;
- logger(mesh, MESHLINK_DEBUG, "Invalid character in address: %s\n", address);
+ return rval;
+}
+
+bool meshlink_add_external_address(meshlink_handle_t *mesh) {
+ if(!mesh) {
meshlink_errno = MESHLINK_EINVAL;
- pthread_mutex_unlock(&(mesh->mesh_mutex));
return false;
}
+ char *address = meshlink_get_external_address(mesh);
+ if(!address)
+ return false;
+
+ bool rval = false;
+
+ pthread_mutex_lock(&(mesh->mesh_mutex));
rval = append_config_file(mesh, mesh->self->name, "Address", address);
pthread_mutex_unlock(&(mesh->mesh_mutex));
+
+ free(address);
return rval;
}
void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const struct sockaddr *addr) {
if(!mesh || !node || !addr)
return;
+
+ // Ignore hints about ourself.
+ if((node_t *)node == mesh->self)
+ return;
pthread_mutex_lock(&(mesh->mesh_mutex));
*nmemb = result_size;
} else {
*nmemb = 0;
- free(result);
meshlink_errno = MESHLINK_ENOMEM;
}