X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fmeshlink.c;h=66d87ee986cde60a8b3689fb0820b1bbbb7f0f51;hb=56e0dd5ad3936663d398500f80c9a502553659df;hp=769e52c6e896c8021691fe678619a424ea8ddabb;hpb=a1b6ee1e25c9b0cbd2265d86a2d4020eddba735b;p=meshlink

diff --git a/src/meshlink.c b/src/meshlink.c
index 769e52c6..66d87ee9 100644
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -177,6 +177,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,6 +187,12 @@ 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
+
+		// 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;
+		}
 
 		if(!*port && !strcasecmp(line, "Port")) {
 			*port = xstrdup(q);
@@ -228,16 +235,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 +330,6 @@ char *meshlink_get_external_address(meshlink_handle_t *mesh) {
 				break;
 			}
 		}
-
-		aip = aip->ai_next;
-		continue;
 	}
 
 	if(ai) {
@@ -288,6 +342,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 +365,67 @@ char *meshlink_get_external_address(meshlink_handle_t *mesh) {
 	return hostname;
 }
 
+// This gets the hostname part for use in invitation URLs
 static char *get_my_hostname(meshlink_handle_t *mesh) {
-	char *hostname = NULL;
+	char *hostname[2] = {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);
+	scan_for_hostname(filename, &hostname[0], &port);
 
-	if(hostname) {
+	if(hostname[0]) {
 		goto done;
 	}
 
-	hostname = meshlink_get_external_address(mesh);
+	hostname[0] = meshlink_get_external_address_for_family(mesh, AF_INET);
+	hostname[1] = meshlink_get_external_address_for_family(mesh, AF_INET6);
 
-	if(!hostname) {
+	if(!hostname[0] && !hostname[1]) {
 		return NULL;
 	}
 
-	f = fopen(filename, "a");
+	if(!strcmp(hostname[0], hostname[1])) {
+		free(hostname[1]);
+		hostname[1] = NULL;
+	}
 
-	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));
+	port = xstrdup(mesh->myport);
+
+	for(int i = 0; i < 2; i++) {
+		if(hostname[i]) {
+			char *tmphostport;
+			xasprintf(&tmphostport, "%s %s", hostname[i], port);
+			append_config_file(mesh, mesh->self->name, "Address", tmphostport);
+			free(tmphostport);
+		}
 	}
 
 done:
 
-	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);
+	for(int i = 0; i < 2; i++) {
+		if(!hostname[i]) {
+			continue;
 		}
+
+		char *newhostport;
+		xasprintf(&newhostport, (strchr(hostname[i], ':') ? "%s%s[%s]" : "%s%s%s"), hostport ? hostport : "", hostport ? "," : "", hostname[i]);
+		free(hostname[i]);
+		free(hostport);
+		hostport = newhostport;
+	}
+
+	if(port) {
+		char *newhostport;
+		xasprintf(&newhostport, "%s:%s", hostport, port);
+		free(port);
+		free(hostport);
+		hostport = newhostport;
 	}
 
-	free(hostname);
-	free(port);
 	return hostport;
 }
 
@@ -444,7 +526,7 @@ static bool try_bind(int port) {
 	return true;
 }
 
-static int check_port(meshlink_handle_t *mesh) {
+int check_port(meshlink_handle_t *mesh) {
 	for(int i = 0; i < 1000; i++) {
 		int port = 0x1000 + (rand() & 0x7fff);
 
@@ -454,7 +536,8 @@ static int check_port(meshlink_handle_t *mesh) {
 			FILE *f = fopen(filename, "a");
 
 			if(!f) {
-				logger(mesh, MESHLINK_DEBUG, "Please change MeshLink's Port manually.\n");
+				meshlink_errno = MESHLINK_ESTORAGE;
+				logger(mesh, MESHLINK_DEBUG, "Could not store Port.\n");
 				return 0;
 			}
 
@@ -464,7 +547,8 @@ static int check_port(meshlink_handle_t *mesh) {
 		}
 	}
 
-	logger(mesh, MESHLINK_DEBUG, "Please change MeshLink's Port manually.\n");
+	meshlink_errno = MESHLINK_ENETWORK;
+	logger(mesh, MESHLINK_DEBUG, "Could not find any available network port.\n");
 	return 0;
 }
 
@@ -639,9 +723,10 @@ static bool finalize_join(meshlink_handle_t *mesh) {
 static bool invitation_send(void *handle, uint8_t type, const void *data, size_t len) {
 	(void)type;
 	meshlink_handle_t *mesh = handle;
+	const char *ptr = data;
 
 	while(len) {
-		int result = send(mesh->sock, data, len, 0);
+		int result = send(mesh->sock, ptr, len, 0);
 
 		if(result == -1 && errno == EINTR) {
 			continue;
@@ -649,7 +734,7 @@ static bool invitation_send(void *handle, uint8_t type, const void *data, size_t
 			return false;
 		}
 
-		data += result;
+		ptr += result;
 		len -= result;
 	}
 
@@ -788,7 +873,12 @@ static bool ecdsa_keygen(meshlink_handle_t *mesh) {
 		logger(mesh, MESHLINK_DEBUG, "Done.\n");
 	}
 
-	snprintf(privname, sizeof(privname), "%s" SLASH "ecdsa_key.priv", mesh->confbase);
+	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;
+	}
+
 	f = fopen(privname, "wb");
 
 	if(!f) {
@@ -848,49 +938,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];
@@ -948,10 +995,15 @@ static bool meshlink_setup(meshlink_handle_t *mesh) {
 
 	if(!ecdsa_keygen(mesh)) {
 		meshlink_errno = MESHLINK_EINTERNAL;
+		unlink(filename);
 		return false;
 	}
 
-	check_port(mesh);
+	if(check_port(mesh) == 0) {
+		meshlink_errno = MESHLINK_ENETWORK;
+		unlink(filename);
+		return false;
+	}
 
 	return true;
 }
@@ -998,6 +1050,7 @@ 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;
 
 	if(usingname) {
 		mesh->name = xstrdup(name);
@@ -1158,10 +1211,18 @@ void meshlink_stop(meshlink_handle_t *mesh) {
 	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
@@ -1573,7 +1634,11 @@ static bool refresh_invitation_key(meshlink_handle_t *mesh) {
 
 		char invname[PATH_MAX];
 		struct stat st;
-		snprintf(invname, sizeof(invname), "%s" SLASH "%s", filename, ent->d_name);
+
+		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;
+		}
 
 		if(!stat(invname, &st)) {
 			if(mesh->invitation_key && deadline < st.st_mtime) {
@@ -1914,6 +1979,14 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 
 	pthread_mutex_lock(&(mesh->mesh_mutex));
 
+	//Before doing meshlink_join make sure we are not connected to another mesh
+	if(mesh->threadstarted) {
+		logger(mesh, MESHLINK_DEBUG, "Already connected to a mesh\n");
+		meshlink_errno = MESHLINK_EINVAL;
+		pthread_mutex_unlock(&(mesh->mesh_mutex));
+		return false;
+	}
+
 	//TODO: think of a better name for this variable, or of a different way to tokenize the invitation URL.
 	char copy[strlen(invitation) + 1];
 	strcpy(copy, invitation);
@@ -1933,33 +2006,14 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 	}
 
 	char *address = copy;
-	char *port = NULL;
-
-	if(*address == '[') {
-		address++;
-		char *bracket = strchr(address, ']');
-
-		if(!bracket) {
-			goto invalid;
-		}
-
-		*bracket = 0;
-
-		if(bracket[1] == ':') {
-			port = bracket + 2;
-		}
-	} else {
-		port = strchr(address, ':');
-
-		if(port) {
-			*port++ = 0;
-		}
-	}
+	char *port = strrchr(address, ':');
 
 	if(!port) {
 		goto invalid;
 	}
 
+	*port++ = 0;
+
 	if(!b64decode(slash, mesh->hash, 18) || !b64decode(slash + 24, mesh->cookie, 18)) {
 		goto invalid;
 	}
@@ -1974,43 +2028,73 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 	}
 
 	char *b64key = ecdsa_get_base64_public_key(key);
+	char *comma;
+	mesh->sock = -1;
 
-	//Before doing meshlink_join make sure we are not connected to another mesh
-	if(mesh->threadstarted) {
-		goto invalid;
-	}
+	while(address && *address) {
+		// We allow commas in the address part to support multiple addresses in one invitation URL.
+		comma = strchr(address, ',');
 
-	// Connect to the meshlink daemon mentioned in the URL.
-	struct addrinfo *ai = str2addrinfo(address, port, SOCK_STREAM);
+		if(comma) {
+			*comma++ = 0;
+		}
 
-	if(!ai) {
-		meshlink_errno = MESHLINK_ERESOLV;
-		pthread_mutex_unlock(&(mesh->mesh_mutex));
-		return false;
-	}
+		// IPv6 address are enclosed in brackets, per RFC 3986
+		if(*address == '[') {
+			address++;
+			char *bracket = strchr(address, ']');
 
-	mesh->sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+			if(!bracket) {
+				goto invalid;
+			}
 
-	if(mesh->sock <= 0) {
-		logger(mesh, MESHLINK_DEBUG, "Could not open socket: %s\n", strerror(errno));
-		freeaddrinfo(ai);
-		meshlink_errno = MESHLINK_ENETWORK;
-		pthread_mutex_unlock(&(mesh->mesh_mutex));
-		return false;
-	}
+			*bracket++ = 0;
 
-	set_timeout(mesh->sock, 5000);
+			if(comma && bracket != comma) {
+				goto invalid;
+			}
+		}
 
-	if(connect(mesh->sock, ai->ai_addr, ai->ai_addrlen)) {
-		logger(mesh, MESHLINK_DEBUG, "Could not connect to %s port %s: %s\n", address, port, strerror(errno));
-		closesocket(mesh->sock);
-		freeaddrinfo(ai);
-		meshlink_errno = MESHLINK_ENETWORK;
-		pthread_mutex_unlock(&(mesh->mesh_mutex));
-		return false;
+		// 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) {
+				mesh->sock = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
+
+				if(mesh->sock == -1) {
+					logger(mesh, MESHLINK_DEBUG, "Could not open socket: %s\n", strerror(errno));
+					meshlink_errno = MESHLINK_ENETWORK;
+					continue;
+				}
+
+				set_timeout(mesh->sock, 5000);
+
+				if(connect(mesh->sock, aip->ai_addr, aip->ai_addrlen)) {
+					logger(mesh, MESHLINK_DEBUG, "Could not connect to %s port %s: %s\n", address, port, strerror(errno));
+					meshlink_errno = MESHLINK_ENETWORK;
+					closesocket(mesh->sock);
+					mesh->sock = -1;
+					continue;
+				}
+			}
+
+			freeaddrinfo(ai);
+		} else {
+			meshlink_errno = MESHLINK_ERESOLV;
+		}
+
+		if(mesh->sock != -1 || !comma) {
+			break;
+		}
+
+		address = comma;
 	}
 
-	freeaddrinfo(ai);
+	if(mesh->sock == -1) {
+		pthread_mutex_unlock(&mesh->mesh_mutex);
+		return false;
+	}
 
 	logger(mesh, MESHLINK_DEBUG, "Connected to %s port %s...\n", address, port);
 
@@ -2117,7 +2201,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 	return true;
 
 invalid:
-	logger(mesh, MESHLINK_DEBUG, "Invalid invitation URL or you are already connected to a Mesh ?\n");
+	logger(mesh, MESHLINK_DEBUG, "Invalid invitation URL\n");
 	meshlink_errno = MESHLINK_EINVAL;
 	pthread_mutex_unlock(&(mesh->mesh_mutex));
 	return false;