X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fprotocol_auth.c;h=9bd5ffca6dc007652af6a4b35e8d69f3247c2af0;hb=2cfd1205dc9c6e9d42cc569f415afe13f52357ec;hp=fa71874f3d4e3464dbeb4f0efddb270b98efafb3;hpb=56ecf5049433a45c865f945915b65bdae307ba4f;p=meshlink

diff --git a/src/protocol_auth.c b/src/protocol_auth.c
index fa71874f..9bd5ffca 100644
--- a/src/protocol_auth.c
+++ b/src/protocol_auth.c
@@ -37,14 +37,14 @@
 #include "xalloc.h"
 #include "ed25519/sha512.h"
 
-static bool send_proxyrequest(connection_t *c) {
+static bool send_proxyrequest(meshlink_handle_t *mesh, connection_t *c) {
 	switch(mesh->proxytype) {
 		case PROXY_HTTP: {
 			char *host;
 			char *port;
 
 			sockaddr2str(&c->address, &host, &port);
-			send_request(c, "CONNECT %s:%s HTTP/1.1\r\n\r", host, port);
+			send_request(mesh, c, "CONNECT %s:%s HTTP/1.1\r\n\r", host, port);
 			free(host);
 			free(port);
 			return true;
@@ -63,7 +63,7 @@ static bool send_proxyrequest(connection_t *c) {
 				memcpy(s4req + 8, mesh->proxyuser, strlen(mesh->proxyuser));
 			s4req[sizeof s4req - 1] = 0;
 			c->tcplen = 8;
-			return send_meta(c, s4req, sizeof s4req);
+			return send_meta(mesh, c, s4req, sizeof s4req);
 		}
 		case PROXY_SOCKS5: {
 			int len = 3 + 6 + (c->address.sa.sa_family == AF_INET ? 4 : 16);
@@ -110,7 +110,7 @@ static bool send_proxyrequest(connection_t *c) {
 			}
 			if(i > len)
 				abort();
-			return send_meta(c, s5req, sizeof s5req);
+			return send_meta(mesh, c, s5req, sizeof s5req);
 		}
 		case PROXY_SOCKS4A:
 			logger(DEBUG_ALWAYS, LOG_ERR, "Proxy type not implemented yet");
@@ -123,19 +123,19 @@ static bool send_proxyrequest(connection_t *c) {
 	}
 }
 
-bool send_id(connection_t *c) {
+bool send_id(meshlink_handle_t *mesh, connection_t *c) {
 	gettimeofday(&c->start, NULL);
 
 	int minor = mesh->self->connection->protocol_minor;
 
 	if(mesh->proxytype && c->outgoing)
-		if(!send_proxyrequest(c))
+		if(!send_proxyrequest(mesh, c))
 			return false;
 
-	return send_request(c, "%d %s %d.%d", ID, mesh->self->connection->name, mesh->self->connection->protocol_major, minor);
+	return send_request(mesh, c, "%d %s %d.%d", ID, mesh->self->connection->name, mesh->self->connection->protocol_major, minor);
 }
 
-static bool finalize_invitation(connection_t *c, const char *data, uint16_t len) {
+static bool finalize_invitation(meshlink_handle_t *mesh, connection_t *c, const void *data, uint16_t len) {
 	if(strchr(data, '\n')) {
 		logger(DEBUG_ALWAYS, LOG_ERR, "Received invalid key from invited node %s (%s)!\n", c->name, c->hostname);
 		return false;
@@ -155,7 +155,7 @@ static bool finalize_invitation(connection_t *c, const char *data, uint16_t len)
 		return false;
 	}
 
-	fprintf(f, "ECDSAPublicKey = %s\n", data);
+	fprintf(f, "ECDSAPublicKey = %s\n", (const char *)data);
 	fclose(f);
 
 	logger(DEBUG_CONNECTIONS, LOG_INFO, "Key succesfully received from %s (%s)", c->name, c->hostname);
@@ -163,17 +163,21 @@ static bool finalize_invitation(connection_t *c, const char *data, uint16_t len)
 	//TODO: callback to application to inform of an accepted invitation
 
 	sptps_send_record(&c->sptps, 2, data, 0);
+
+	load_all_nodes(mesh);
+
 	return true;
 }
 
-static bool receive_invitation_sptps(void *handle, uint8_t type, const char *data, uint16_t len) {
+static bool receive_invitation_sptps(void *handle, uint8_t type, const void *data, uint16_t len) {
 	connection_t *c = handle;
+	meshlink_handle_t *mesh = c->mesh;
 
 	if(type == 128)
 		return true;
 
 	if(type == 1 && c->status.invitation_used)
-		return finalize_invitation(c, data, len);
+		return finalize_invitation(mesh, c, data, len);
 
 	if(type != 0 || len != 18 || c->status.invitation_used)
 		return false;
@@ -248,7 +252,7 @@ static bool receive_invitation_sptps(void *handle, uint8_t type, const char *dat
 	return true;
 }
 
-bool id_h(connection_t *c, const char *request) {
+bool id_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
 	char name[MAX_STRING_SIZE];
 
 	if(sscanf(request, "%*d " MAX_STRING " %d.%d", name, &c->protocol_major, &c->protocol_minor) < 2) {
@@ -275,13 +279,14 @@ bool id_h(connection_t *c, const char *request) {
 		char *mykey = ecdsa_get_base64_public_key(mesh->invitation_key);
 		if(!mykey)
 			return false;
-		if(!send_request(c, "%d %s", ACK, mykey))
+		if(!send_request(mesh, c, "%d %s", ACK, mykey))
 			return false;
 		free(mykey);
 
 		c->protocol_minor = 2;
+		c->allow_request = 1;
 
-		return sptps_start(&c->sptps, c, false, false, mesh->invitation_key, c->ecdsa, "tinc invitation", 15, send_meta_sptps, receive_invitation_sptps);
+		return sptps_start(&c->sptps, c, false, false, mesh->invitation_key, c->ecdsa, "meshlink invitation", 15, send_meta_sptps, receive_invitation_sptps);
 	}
 
 	/* Check if identity is a valid name */
@@ -317,12 +322,12 @@ bool id_h(connection_t *c, const char *request) {
 	if(!c->config_tree) {
 		init_configuration(&c->config_tree);
 
-		if(!read_host_config(c->config_tree, c->name)) {
+		if(!read_host_config(mesh, c->config_tree, c->name)) {
 			logger(DEBUG_ALWAYS, LOG_ERR, "Peer %s had unknown identity (%s)", c->hostname, c->name);
 			return false;
 		}
 
-		read_ecdsa_public_key(c);
+		read_ecdsa_public_key(mesh, c);
 	} else {
 		if(c->protocol_minor && !ecdsa_active(c->ecdsa))
 			c->protocol_minor = 1;
@@ -340,19 +345,18 @@ bool id_h(connection_t *c, const char *request) {
 	char label[25 + strlen(mesh->self->name) + strlen(c->name)];
 
 	if(c->outgoing)
-		snprintf(label, sizeof label, "tinc TCP key expansion %s %s", mesh->self->name, c->name);
+		snprintf(label, sizeof label, "meshlink TCP key expansion %s %s", mesh->self->name, c->name);
 	else
-		snprintf(label, sizeof label, "tinc TCP key expansion %s %s", c->name, mesh->self->name);
+		snprintf(label, sizeof label, "meshlink TCP key expansion %s %s", c->name, mesh->self->name);
 
 	return sptps_start(&c->sptps, c, c->outgoing, false, mesh->self->connection->ecdsa, c->ecdsa, label, sizeof label, send_meta_sptps, receive_meta_sptps);
 }
 
-bool send_ack(connection_t *c) {
+bool send_ack(meshlink_handle_t *mesh, connection_t *c) {
 	/* ACK message contains rest of the information the other end needs
 	   to create node_t and edge_t structures. */
 
 	struct timeval now;
-	bool choice;
 
 	/* Estimate weight */
 
@@ -364,25 +368,24 @@ bool send_ack(connection_t *c) {
 	if(mesh->self->options & OPTION_PMTU_DISCOVERY)
 		c->options |= OPTION_PMTU_DISCOVERY;
 
-	return send_request(c, "%d %s %d %x", ACK, mesh->myport, c->estimated_weight, (c->options & 0xffffff) | (PROT_MINOR << 24));
+	return send_request(mesh, c, "%d %s %d %x", ACK, mesh->myport, c->estimated_weight, (c->options & 0xffffff) | (PROT_MINOR << 24));
 }
 
-static void send_everything(connection_t *c) {
+static void send_everything(meshlink_handle_t *mesh, connection_t *c) {
 	/* Send all known subnets and edges */
 
 	for splay_each(node_t, n, mesh->nodes) {
 		for splay_each(edge_t, e, n->edge_tree)
-			send_add_edge(c, e);
+			send_add_edge(mesh, c, e);
 	}
 }
 
-bool ack_h(connection_t *c, const char *request) {
+bool ack_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
 	char hisport[MAX_STRING_SIZE];
 	char *hisaddress;
-	int weight, mtu;
+	int weight;
 	uint32_t options;
 	node_t *n;
-	bool choice;
 
 	if(sscanf(request, "%*d " MAX_STRING " %d %x", hisport, &weight, &options) != 3) {
 		logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "ACK", c->name,
@@ -392,12 +395,12 @@ bool ack_h(connection_t *c, const char *request) {
 
 	/* Check if we already have a node_t for him */
 
-	n = lookup_node(c->name);
+	n = lookup_node(mesh, c->name);
 
 	if(!n) {
 		n = new_node();
 		n->name = xstrdup(c->name);
-		node_add(n);
+		node_add(mesh, n);
 	} else {
 		if(n->connection) {
 			/* Oh dear, we already have a connection to this node. */
@@ -412,9 +415,9 @@ bool ack_h(connection_t *c, const char *request) {
 				n->connection->outgoing = NULL;
 			}
 
-			terminate_connection(n->connection, false);
+			terminate_connection(mesh, n->connection, false);
 			/* Run graph algorithm to keep things in sync */
-			graph();
+			graph(mesh);
 		}
 	}
 
@@ -436,7 +439,7 @@ bool ack_h(connection_t *c, const char *request) {
 
 	/* Send him everything we know */
 
-	send_everything(c);
+	send_everything(mesh, c);
 
 	/* Create an edge_t for this connection */
 
@@ -450,15 +453,15 @@ bool ack_h(connection_t *c, const char *request) {
 	c->edge->connection = c;
 	c->edge->options = c->options;
 
-	edge_add(c->edge);
+	edge_add(mesh, c->edge);
 
 	/* Notify everyone of the new edge */
 
-	send_add_edge(mesh->everyone, c->edge);
+	send_add_edge(mesh, mesh->everyone, c->edge);
 
 	/* Run MST and SSSP algorithms */
 
-	graph();
+	graph(mesh);
 
 	return true;
 }