X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fmeshlink.c;h=b407e5b53dca8e7a263be76d08c6a1e8511ac661;hb=e99687f6b8c784e9a1805d1435e91a08b4ea6408;hp=60a4306ceb5ae16b8ba633a440eae0968ce11c85;hpb=2f014ef78a8bcbf6cdac86bf9602e4a4903cf51e;p=meshlink

diff --git a/src/meshlink.c b/src/meshlink.c
index 60a4306c..b407e5b5 100644
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -1,6 +1,6 @@
 /*
     meshlink.c -- Implementation of the MeshLink API.
-    Copyright (C) 2014, 2017 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2018 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
@@ -56,64 +56,13 @@ meshlink_log_level_t global_log_level;
 //TODO: this can go away completely
 const var_t variables[] = {
 	/* Server configuration */
-	{"AddressFamily", VAR_SERVER},
-	{"AutoConnect", VAR_SERVER | VAR_SAFE},
-	{"BindToAddress", VAR_SERVER | VAR_MULTIPLE},
-	{"BindToInterface", VAR_SERVER},
-	{"Broadcast", VAR_SERVER | VAR_SAFE},
 	{"ConnectTo", VAR_SERVER | VAR_MULTIPLE | VAR_SAFE},
-	{"DecrementTTL", VAR_SERVER},
-	{"Device", VAR_SERVER},
-	{"DeviceType", VAR_SERVER},
-	{"DirectOnly", VAR_SERVER},
-	{"ECDSAPrivateKeyFile", VAR_SERVER},
-	{"ExperimentalProtocol", VAR_SERVER},
-	{"Forwarding", VAR_SERVER},
-	{"GraphDumpFile", VAR_SERVER | VAR_OBSOLETE},
-	{"Hostnames", VAR_SERVER},
-	{"IffOneQueue", VAR_SERVER},
-	{"Interface", VAR_SERVER},
-	{"KeyExpire", VAR_SERVER},
-	{"ListenAddress", VAR_SERVER | VAR_MULTIPLE},
-	{"LocalDiscovery", VAR_SERVER},
-	{"MACExpire", VAR_SERVER},
-	{"MaxConnectionBurst", VAR_SERVER},
-	{"MaxOutputBufferSize", VAR_SERVER},
-	{"MaxTimeout", VAR_SERVER},
-	{"Mode", VAR_SERVER | VAR_SAFE},
 	{"Name", VAR_SERVER},
-	{"PingInterval", VAR_SERVER},
-	{"PingTimeout", VAR_SERVER},
-	{"PriorityInheritance", VAR_SERVER},
-	{"PrivateKey", VAR_SERVER | VAR_OBSOLETE},
-	{"PrivateKeyFile", VAR_SERVER},
-	{"ProcessPriority", VAR_SERVER},
-	{"Proxy", VAR_SERVER},
-	{"ReplayWindow", VAR_SERVER},
-	{"ScriptsExtension", VAR_SERVER},
-	{"ScriptsInterpreter", VAR_SERVER},
-	{"StrictSubnets", VAR_SERVER},
-	{"TunnelServer", VAR_SERVER},
-	{"VDEGroup", VAR_SERVER},
-	{"VDEPort", VAR_SERVER},
 	/* Host configuration */
+	{"CanonicalAddress", VAR_HOST},
 	{"Address", VAR_HOST | VAR_MULTIPLE},
-	{"Cipher", VAR_SERVER | VAR_HOST},
-	{"ClampMSS", VAR_SERVER | VAR_HOST},
-	{"Compression", VAR_SERVER | VAR_HOST},
-	{"Digest", VAR_SERVER | VAR_HOST},
 	{"ECDSAPublicKey", VAR_HOST},
-	{"ECDSAPublicKeyFile", VAR_SERVER | VAR_HOST},
-	{"IndirectData", VAR_SERVER | VAR_HOST},
-	{"MACLength", VAR_SERVER | VAR_HOST},
-	{"PMTU", VAR_SERVER | VAR_HOST},
-	{"PMTUDiscovery", VAR_SERVER | VAR_HOST},
 	{"Port", VAR_HOST},
-	{"PublicKey", VAR_HOST | VAR_OBSOLETE},
-	{"PublicKeyFile", VAR_SERVER | VAR_HOST | VAR_OBSOLETE},
-	{"Subnet", VAR_HOST | VAR_MULTIPLE | VAR_SAFE},
-	{"TCPOnly", VAR_SERVER | VAR_HOST},
-	{"Weight", VAR_HOST | VAR_SAFE},
 	{NULL, 0}
 };
 
@@ -148,6 +97,7 @@ static int rstrip(char *value) {
 
 static void scan_for_hostname(const char *filename, char **hostname, char **port) {
 	char line[4096];
+	bool canonical = false;
 
 	if(!filename || (*hostname && *port)) {
 		return;
@@ -177,6 +127,7 @@ static void scan_for_hostname(const char *filename, char **hostname, char **port
 			q += 1 + strspn(q + 1, "\t ");
 		}
 
+		// q is now pointing to the hostname
 		*p = 0;
 		p = q + strcspn(q, "\t ");
 
@@ -186,19 +137,33 @@ static void scan_for_hostname(const char *filename, char **hostname, char **port
 
 		p += strspn(p, "\t ");
 		p[strcspn(p, "\t ")] = 0;
+		// p is now pointing to the port, if present
 
 		if(!*port && !strcasecmp(line, "Port")) {
 			*port = xstrdup(q);
-		} else if(!*hostname && !strcasecmp(line, "Address")) {
+		} else if(!canonical && !*hostname && !strcasecmp(line, "Address")) {
+			// Check that the hostname is a symbolic name (it's not a numeric IPv4 or IPv6 address)
+			if(!q[strspn(q, "0123456789.")] || strchr(q, ':')) {
+				continue;
+			}
+
 			*hostname = xstrdup(q);
 
+			if(*p) {
+				free(*port);
+				*port = xstrdup(p);
+			}
+		} else if(!strcasecmp(line, "CanonicalAddress")) {
+			*hostname = xstrdup(q);
+			canonical = true;
+
 			if(*p) {
 				free(*port);
 				*port = xstrdup(p);
 			}
 		}
 
-		if(*hostname && *port) {
+		if(canonical && *hostname && *port) {
 			break;
 		}
 	}
@@ -207,6 +172,10 @@ static void scan_for_hostname(const char *filename, char **hostname, char **port
 }
 
 static bool is_valid_hostname(const char *hostname) {
+	if(!*hostname) {
+		return false;
+	}
+
 	for(const char *p = hostname; *p; p++) {
 		if(!(isalnum(*p) || *p == '-' || *p == '.' || *p == ':')) {
 			return false;
@@ -216,6 +185,26 @@ static bool is_valid_hostname(const char *hostname) {
 	return true;
 }
 
+static bool is_valid_port(const char *port) {
+	if(!*port) {
+		return false;
+	}
+
+	if(isdigit(*port)) {
+		char *end;
+		unsigned long int result = strtoul(port, &end, 10);
+		return result && result < 65536 && !*end;
+	}
+
+	for(const char *p = port; *p; p++) {
+		if(!(isalnum(*p) || *p == '-')) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
 static void set_timeout(int sock, int timeout) {
 #ifdef _WIN32
 	DWORD tv = timeout;
@@ -228,16 +217,66 @@ static void set_timeout(int sock, int timeout) {
 	setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
 }
 
+// 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;
+}
+
 char *meshlink_get_external_address(meshlink_handle_t *mesh) {
+	return meshlink_get_external_address_for_family(mesh, AF_UNSPEC);
+}
+
+char *meshlink_get_external_address_for_family(meshlink_handle_t *mesh, int family) {
 	char *hostname = NULL;
 
 	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) {
+	for(struct addrinfo *aip = ai; aip; aip = aip->ai_next) {
+		if(family != AF_UNSPEC && aip->ai_family != family) {
+			continue;
+		}
+
 		int s = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
 
 		if(s >= 0) {
@@ -273,9 +312,6 @@ char *meshlink_get_external_address(meshlink_handle_t *mesh) {
 				break;
 			}
 		}
-
-		aip = aip->ai_next;
-		continue;
 	}
 
 	if(ai) {
@@ -288,6 +324,22 @@ char *meshlink_get_external_address(meshlink_handle_t *mesh) {
 		hostname = NULL;
 	}
 
+	// If there is no hostname, determine the address used for an outgoing connection.
+	if(!hostname) {
+		char localaddr[NI_MAXHOST];
+		bool success = false;
+
+		if(family == AF_INET) {
+			success = getlocaladdrname("93.184.216.34", localaddr, sizeof(localaddr));
+		} else if(family == AF_INET6) {
+			success = getlocaladdrname("2606:2800:220:1:248:1893:25c8:1946", localaddr, sizeof(localaddr));
+		}
+
+		if(success) {
+			hostname = xstrdup(localaddr);
+		}
+	}
+
 	if(!hostname) {
 		meshlink_errno = MESHLINK_ERESOLV;
 	}
@@ -295,55 +347,68 @@ char *meshlink_get_external_address(meshlink_handle_t *mesh) {
 	return hostname;
 }
 
+// String comparison which handles NULL arguments
+static bool safe_streq(const char *a, const char *b) {
+	if(!a || !b) {
+		return a == b;
+	} else {
+		return !strcmp(a, b);
+	}
+}
+
+// This gets the hostname part for use in invitation URLs
 static char *get_my_hostname(meshlink_handle_t *mesh) {
-	char *hostname = NULL;
-	char *port = NULL;
+	char *hostname[3] = {NULL};
+	char *port[3] = {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);
+	// Use the best Address statement in our own host config file
+	char filename[PATH_MAX] = "";
+	snprintf(filename, sizeof(filename), "%s" SLASH "hosts" SLASH "%s", mesh->confbase, mesh->self->name);
+	scan_for_hostname(filename, &hostname[0], &port[0]);
 
-	if(hostname) {
-		goto done;
-	}
+	hostname[1] = meshlink_get_external_address_for_family(mesh, AF_INET);
+	hostname[2] = meshlink_get_external_address_for_family(mesh, AF_INET6);
 
-	hostname = meshlink_get_external_address(mesh);
+	// Concatenate all unique address to the hostport string
+	for(int i = 0; i < 3; i++) {
+		if(!hostname[i]) {
+			continue;
+		}
 
-	if(!hostname) {
-		return NULL;
-	}
+		// Ignore duplicate hostnames
+		bool found = false;
 
-	f = fopen(filename, "a");
+		for(int j = 0; i < j; j++) {
+			if(safe_streq(hostname[i], hostname[j]) && safe_streq(port[i], port[j])) {
+				found = true;
+				break;
+			}
+		}
 
-	if(f) {
-		fprintf(f, "\nAddress = %s\n", hostname);
-		fclose(f);
-	} else {
-		logger(mesh, MESHLINK_DEBUG, "Could not append Address to %s: %s\n", filename, strerror(errno));
-	}
+		if(found) {
+			free(hostname[i]);
+			free(port[i]);
+			hostname[i] = NULL;
+			port[i] = NULL;
+			continue;
+		}
 
-done:
+		// Ensure we have the same addresses in our own host config file.
+		char *tmphostport;
+		xasprintf(&tmphostport, "%s %s", hostname[i], port[i] ? port[i] : mesh->myport);
+		append_config_file(mesh, mesh->self->name, "Address", tmphostport);
+		free(tmphostport);
 
-	if(port) {
-		if(strchr(hostname, ':')) {
-			xasprintf(&hostport, "[%s]:%s", hostname, port);
-		} else {
-			xasprintf(&hostport, "%s:%s", hostname, port);
-		}
-	} else {
-		if(strchr(hostname, ':')) {
-			xasprintf(&hostport, "[%s]", hostname);
-		} else {
-			hostport = xstrdup(hostname);
-		}
+		// Append the address to the hostport string
+		char *newhostport;
+		xasprintf(&newhostport, (strchr(hostname[i], ':') ? "%s%s[%s]:%s" : "%s%s%s:%s"), hostport ? hostport : "", hostport ? "," : "", hostname[i], port[i] ? port[i] : mesh->myport);
+		free(hostname[i]);
+		free(port[i]);
+		free(hostport);
+		hostport = newhostport;
 	}
 
-	free(hostname);
-	free(port);
 	return hostport;
 }
 
@@ -470,6 +535,31 @@ int check_port(meshlink_handle_t *mesh) {
 	return 0;
 }
 
+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);
+}
+
 static bool finalize_join(meshlink_handle_t *mesh) {
 	char *name = xstrdup(get_value(mesh->data, "Name"));
 
@@ -495,6 +585,19 @@ static bool finalize_join(meshlink_handle_t *mesh) {
 
 	fprintf(f, "Name = %s\n", name);
 
+	// Wipe all old host config files and invitations
+	snprintf(filename, sizeof(filename), "%s" SLASH "hosts", mesh->confbase);
+	deltree(filename);
+
+	if(mkdir(filename, 0777) && errno != EEXIST) {
+		logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", filename, strerror(errno));
+		return false;
+	}
+
+	snprintf(filename, sizeof(filename), "%s" SLASH "invitations", mesh->confbase);
+	deltree(filename);
+
+	// Create a new host config file for ourself
 	snprintf(filename, sizeof(filename), "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name);
 	FILE *fh = fopen(filename, "w");
 
@@ -537,7 +640,7 @@ static bool finalize_join(meshlink_handle_t *mesh) {
 			continue;
 		}
 
-		// Check the list of known variables //TODO: most variables will not be available in meshlink, only name and key will be absolutely necessary
+		// Check the list of known variables
 		bool found = false;
 		int i;
 
@@ -626,8 +729,10 @@ static bool finalize_join(meshlink_handle_t *mesh) {
 	sptps_send_record(&(mesh->sptps), 1, b64key, strlen(b64key));
 	free(b64key);
 
+	free(mesh->name);
 	free(mesh->self->name);
 	free(mesh->self->connection->name);
+	mesh->name = xstrdup(name);
 	mesh->self->name = xstrdup(name);
 	mesh->self->connection->name = name;
 
@@ -766,6 +871,8 @@ static const char *errstr[] = {
 	[MESHLINK_ESTORAGE] = "Storage error",
 	[MESHLINK_ENETWORK] = "Network error",
 	[MESHLINK_EPEER] = "Error communicating with peer",
+	[MESHLINK_ENOTSUP] = "Operation not supported",
+	[MESHLINK_EBUSY] = "MeshLink instance already in use",
 };
 
 const char *meshlink_strerror(meshlink_errno_t err) {
@@ -791,7 +898,7 @@ static bool ecdsa_keygen(meshlink_handle_t *mesh) {
 		logger(mesh, MESHLINK_DEBUG, "Done.\n");
 	}
 
-	if (snprintf(privname, sizeof(privname), "%s" SLASH "ecdsa_key.priv", mesh->confbase) >= PATH_MAX) {
+	if(snprintf(privname, sizeof(privname), "%s" SLASH "ecdsa_key.priv", mesh->confbase) >= PATH_MAX) {
 		logger(mesh, MESHLINK_DEBUG, "Filename too long: %s" SLASH "ecdsa_key.priv\n", mesh->confbase);
 		meshlink_errno = MESHLINK_ESTORAGE;
 		return false;
@@ -856,49 +963,6 @@ static struct timeval idle(event_loop_t *loop, void *data) {
 	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];
@@ -960,7 +1024,7 @@ static bool meshlink_setup(meshlink_handle_t *mesh) {
 		return false;
 	}
 
-	if (check_port(mesh) == 0) {
+	if(check_port(mesh) == 0) {
 		meshlink_errno = MESHLINK_ENETWORK;
 		unlink(filename);
 		return false;
@@ -987,6 +1051,12 @@ meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const c
 		return NULL;
 	}
 
+	if(strchr(appname, ' ')) {
+		logger(NULL, MESHLINK_ERROR, "Invalid appname given!\n");
+		meshlink_errno = MESHLINK_EINVAL;
+		return NULL;
+	}
+
 	if(!name || !*name) {
 		logger(NULL, MESHLINK_ERROR, "No name given!\n");
 		//return NULL;
@@ -1011,6 +1081,8 @@ meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const c
 	mesh->confbase = xstrdup(confbase);
 	mesh->appname = xstrdup(appname);
 	mesh->devclass = devclass;
+	mesh->discovery = true;
+	mesh->invitation_timeout = 604800; // 1 week
 
 	if(usingname) {
 		mesh->name = xstrdup(name);
@@ -1048,6 +1120,34 @@ meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const c
 		}
 	}
 
+	// Open the configuration file and lock it
+
+	mesh->conffile = fopen(filename, "r");
+
+	if(!mesh->conffile) {
+		logger(NULL, MESHLINK_ERROR, "Cannot not open %s: %s\n", filename, strerror(errno));
+		meshlink_close(mesh);
+		meshlink_errno = MESHLINK_ESTORAGE;
+		return NULL;
+	}
+
+#ifdef FD_CLOEXEC
+	fcntl(fileno(mesh->conffile), F_SETFD, FD_CLOEXEC);
+#endif
+
+#ifdef HAVE_MINGW
+	// TODO: use _locking()?
+#else
+
+	if(flock(fileno(mesh->conffile), LOCK_EX | LOCK_NB) != 0) {
+		logger(NULL, MESHLINK_ERROR, "Cannot lock %s: %s\n", filename, strerror(errno));
+		meshlink_close(mesh);
+		meshlink_errno = MESHLINK_EBUSY;
+		return NULL;
+	}
+
+#endif
+
 	// Read the configuration
 
 	init_configuration(&mesh->config);
@@ -1139,16 +1239,21 @@ bool meshlink_start(meshlink_handle_t *mesh) {
 		logger(mesh, MESHLINK_DEBUG, "Could not start thread: %s\n", strerror(errno));
 		memset(&mesh->thread, 0, sizeof(mesh)->thread);
 		meshlink_errno = MESHLINK_EINTERNAL;
+		event_loop_stop(&mesh->loop);
 		pthread_mutex_unlock(&(mesh->mesh_mutex));
 		return false;
 	}
 
 	mesh->threadstarted = true;
 
+#if HAVE_CATTA
+
 	if(mesh->discovery) {
 		discovery_start(mesh);
 	}
 
+#endif
+
 	pthread_mutex_unlock(&(mesh->mesh_mutex));
 	return true;
 }
@@ -1162,27 +1267,41 @@ void meshlink_stop(meshlink_handle_t *mesh) {
 	pthread_mutex_lock(&(mesh->mesh_mutex));
 	logger(mesh, MESHLINK_DEBUG, "meshlink_stop called\n");
 
+#if HAVE_CATTA
+
 	// Stop discovery
 	if(mesh->discovery) {
 		discovery_stop(mesh);
 	}
 
+#endif
+
 	// 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];
+	for(int i = 0; i < mesh->listen_sockets; i++) {
+		sockaddr_t sa;
+		socklen_t salen = sizeof(sa.sa);
+
+		if(getsockname(mesh->listen_socket[i].udp.fd, &sa.sa, &salen) == -1) {
+			logger(mesh, MESHLINK_ERROR, "System call `%s' failed: %s", "getsockname", sockstrerror(sockerrno));
+			continue;
+		}
 
-	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");
+		if(sendto(mesh->listen_socket[i].udp.fd, "", 1, MSG_NOSIGNAL, &sa.sa, salen) == -1) {
+			logger(mesh, MESHLINK_ERROR, "Could not send a UDP packet to ourself: %s", sockstrerror(sockerrno));
+		}
 	}
 
-	// Wait for the main thread to finish
-	pthread_mutex_unlock(&(mesh->mesh_mutex));
-	pthread_join(mesh->thread, NULL);
-	pthread_mutex_lock(&(mesh->mesh_mutex));
+	if(mesh->threadstarted) {
+		// Wait for the main thread to finish
+		pthread_mutex_unlock(&(mesh->mesh_mutex));
+		pthread_join(mesh->thread, NULL);
+		pthread_mutex_lock(&(mesh->mesh_mutex));
 
-	mesh->threadstarted = false;
+		mesh->threadstarted = false;
+	}
 
 	// Close all metaconnections
 	if(mesh->connections) {
@@ -1196,10 +1315,9 @@ void meshlink_stop(meshlink_handle_t *mesh) {
 
 	if(mesh->outgoings) {
 		list_delete_list(mesh->outgoings);
+		mesh->outgoings = NULL;
 	}
 
-	mesh->outgoings = NULL;
-
 	pthread_mutex_unlock(&(mesh->mesh_mutex));
 }
 
@@ -1239,37 +1357,15 @@ void meshlink_close(meshlink_handle_t *mesh) {
 	free(mesh->confbase);
 	pthread_mutex_destroy(&(mesh->mesh_mutex));
 
+	if(mesh->conffile) {
+		fclose(mesh->conffile);
+        }
+
 	memset(mesh, 0, sizeof(*mesh));
 
 	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;
@@ -1317,6 +1413,17 @@ void meshlink_set_node_status_cb(meshlink_handle_t *mesh, meshlink_node_status_c
 	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;
+		return;
+	}
+
+	pthread_mutex_lock(&(mesh->mesh_mutex));
+	mesh->node_duplicate_cb = cb;
+	pthread_mutex_unlock(&(mesh->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));
@@ -1586,7 +1693,8 @@ static bool refresh_invitation_key(meshlink_handle_t *mesh) {
 
 		char invname[PATH_MAX];
 		struct stat st;
-		if (snprintf(invname, sizeof(invname), "%s" SLASH "%s", filename, ent->d_name) >= PATH_MAX) {
+
+		if(snprintf(invname, sizeof(invname), "%s" SLASH "%s", filename, ent->d_name) >= PATH_MAX) {
 			logger(mesh, MESHLINK_DEBUG, "Filename too long: %s" SLASH "%s", filename, ent->d_name);
 			continue;
 		}
@@ -1676,8 +1784,8 @@ static bool refresh_invitation_key(meshlink_handle_t *mesh) {
 	return mesh->invitation_key;
 }
 
-bool meshlink_add_address(meshlink_handle_t *mesh, const char *address) {
-	if(!mesh || !address) {
+bool meshlink_set_canonical_address(meshlink_handle_t *mesh, meshlink_node_t *node, const char *address, const char *port) {
+	if(!mesh || !node || !address) {
 		meshlink_errno = MESHLINK_EINVAL;
 		return false;
 	}
@@ -1688,15 +1796,32 @@ bool meshlink_add_address(meshlink_handle_t *mesh, const char *address) {
 		return false;
 	}
 
-	bool rval = false;
+	if(port && !is_valid_port(port)) {
+		logger(mesh, MESHLINK_DEBUG, "Invalid character in port: %s\n", address);
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	char *canonical_address;
+
+	if(port) {
+		xasprintf(&canonical_address, "%s %s", address, port);
+	} else {
+		canonical_address = xstrdup(address);
+	}
 
 	pthread_mutex_lock(&(mesh->mesh_mutex));
-	rval = append_config_file(mesh, mesh->self->name, "Address", address);
+	bool rval = modify_config_file(mesh, node->name, "CanonicalAddress", canonical_address, 1);
 	pthread_mutex_unlock(&(mesh->mesh_mutex));
 
+	free(canonical_address);
 	return rval;
 }
 
+bool meshlink_add_address(meshlink_handle_t *mesh, const char *address) {
+	return meshlink_set_canonical_address(mesh, (meshlink_node_t *)mesh->self, address, NULL);
+}
+
 bool meshlink_add_external_address(meshlink_handle_t *mesh) {
 	if(!mesh) {
 		meshlink_errno = MESHLINK_EINVAL;
@@ -1782,6 +1907,10 @@ done:
 	return rval;
 }
 
+void meshlink_set_invitation_timeout(meshlink_handle_t *mesh, int timeout) {
+	mesh->invitation_timeout = timeout;
+}
+
 char *meshlink_invite(meshlink_handle_t *mesh, const char *name) {
 	if(!mesh) {
 		meshlink_errno = MESHLINK_EINVAL;
@@ -1875,8 +2004,6 @@ char *meshlink_invite(meshlink_handle_t *mesh, const char *name) {
 
 	// Fill in the details.
 	fprintf(f, "Name = %s\n", name);
-	//if(netname)
-	//      fprintf(f, "NetName = %s\n", netname);
 	fprintf(f, "ConnectTo = %s\n", mesh->self->name);
 
 	// Copy Broadcast and Mode
@@ -1942,7 +2069,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 	char copy[strlen(invitation) + 1];
 	strcpy(copy, invitation);
 
-	// Split the invitation URL into hostname, port, key hash and cookie.
+	// Split the invitation URL into a list of hostname/port tuples, a key hash and a cookie.
 
 	char *slash = strchr(copy, '/');
 
@@ -1957,13 +2084,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 	}
 
 	char *address = copy;
-	char *port = strrchr(address, ':');
-
-	if (!port) {
-		goto invalid;
-	}
-
-	*port++ = 0;
+	char *port = NULL;
 
 	if(!b64decode(slash, mesh->hash, 18) || !b64decode(slash + 24, mesh->cookie, 18)) {
 		goto invalid;
@@ -1982,27 +2103,44 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 	char *comma;
 	mesh->sock = -1;
 
-	while (address && *address) {
+	while(address && *address) {
 		// We allow commas in the address part to support multiple addresses in one invitation URL.
 		comma = strchr(address, ',');
-		if (comma)
+
+		if(comma) {
 			*comma++ = 0;
+		}
+
+		// Split of the port
+		port = strrchr(address, ':');
+
+		if(!port) {
+			goto invalid;
+		}
+
+		*port++ = 0;
 
 		// IPv6 address are enclosed in brackets, per RFC 3986
-		if (*address == '[') {
+		if(*address == '[') {
 			address++;
 			char *bracket = strchr(address, ']');
-			if (!bracket)
+
+			if(!bracket) {
 				goto invalid;
+			}
+
 			*bracket++ = 0;
-			if (comma && bracket != comma)
+
+			if(*bracket) {
 				goto invalid;
+			}
 		}
 
 		// Connect to the meshlink daemon mentioned in the URL.
 		struct addrinfo *ai = str2addrinfo(address, port, SOCK_STREAM);
-		if (ai) {
-			for (struct addrinfo *aip = ai; aip; aip = aip->ai_next) {
+
+		if(ai) {
+			for(struct addrinfo *aip = ai; aip; aip = aip->ai_next) {
 				mesh->sock = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
 
 				if(mesh->sock == -1) {
@@ -2027,13 +2165,14 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 			meshlink_errno = MESHLINK_ERESOLV;
 		}
 
-		if (mesh->sock != -1 || !comma)
+		if(mesh->sock != -1 || !comma) {
 			break;
+		}
 
 		address = comma;
 	}
 
-	if (mesh->sock == -1) {
+	if(mesh->sock == -1) {
 		pthread_mutex_unlock(&mesh->mesh_mutex);
 		return false;
 	}
@@ -2044,7 +2183,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 
 	mesh->blen = 0;
 
-	if(!sendline(mesh->sock, "0 ?%s %d.%d", b64key, PROT_MAJOR, 1)) {
+	if(!sendline(mesh->sock, "0 ?%s %d.%d %s", b64key, PROT_MAJOR, 1, mesh->appname)) {
 		logger(mesh, MESHLINK_DEBUG, "Error sending request to %s port %s: %s\n", address, port, strerror(errno));
 		closesocket(mesh->sock);
 		meshlink_errno = MESHLINK_ENETWORK;
@@ -2279,8 +2418,14 @@ void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) {
 	//Make blacklisting persistent in the config file
 	append_config_file(mesh, n->name, "blacklisted", "yes");
 
+	//Immediately terminate any connections we have with the blacklisted node
+	for list_each(connection_t, c, mesh->connections) {
+		if(c->node == n) {
+			terminate_connection(mesh, c, c->status.active);
+		}
+	}
+
 	pthread_mutex_unlock(&(mesh->mesh_mutex));
-	return;
 }
 
 void meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) {
@@ -2392,6 +2537,11 @@ static void channel_accept(struct utcp_connection *utcp_connection, uint16_t por
 
 static ssize_t channel_send(struct utcp *utcp, const void *data, size_t len) {
 	node_t *n = utcp->priv;
+
+	if(n->status.destroyed) {
+		return -1;
+	}
+
 	meshlink_handle_t *mesh = n->mesh;
 	return meshlink_send(mesh, (meshlink_node_t *)n, data, len) ? (ssize_t)len : -1;
 }
@@ -2565,7 +2715,18 @@ void update_node_status(meshlink_handle_t *mesh, node_t *n) {
 	}
 }
 
+void handle_duplicate_node(meshlink_handle_t *mesh, node_t *n) {
+	if(!mesh->node_duplicate_cb || n->status.duplicate) {
+		return;
+	}
+
+	n->status.duplicate = true;
+	mesh->node_duplicate_cb(mesh, (meshlink_node_t *)n);
+}
+
 void meshlink_enable_discovery(meshlink_handle_t *mesh, bool enable) {
+#if HAVE_CATTA
+
 	if(!mesh) {
 		meshlink_errno = MESHLINK_EINVAL;
 		return;
@@ -2589,6 +2750,11 @@ void meshlink_enable_discovery(meshlink_handle_t *mesh, bool enable) {
 
 end:
 	pthread_mutex_unlock(&mesh->mesh_mutex);
+#else
+	(void)mesh;
+	(void)enable;
+	meshlink_errno = MESHLINK_ENOTSUP;
+#endif
 }
 
 static void __attribute__((constructor)) meshlink_init(void) {