X-Git-Url: https://tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Fnet_packet.c;h=f301aa2247fd487b134bf781eeab81b01ada488b;hb=d917c8cb6b69475d568ccbe82389b9f2b3eb5e80;hp=abfb55c411435af0e07d56ab021d9c7c01bbb742;hpb=6dfdb323612184529b4b83c1be914dda8262de47;p=tinc

diff --git a/src/net_packet.c b/src/net_packet.c
index abfb55c4..f301aa22 100644
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -36,7 +36,6 @@
 #include LZO1X_H
 #endif
 
-#include "splay_tree.h"
 #include "cipher.h"
 #include "conf.h"
 #include "connection.h"
@@ -80,10 +79,8 @@ bool localdiscovery = false;
 
 static void send_mtu_probe_handler(int fd, short events, void *data) {
 	node_t *n = data;
-	vpn_packet_t packet;
-	int len, i;
 	int timeout = 1;
-	
+
 	n->mtuprobes++;
 
 	if(!n->status.reachable || !n->status.validkey) {
@@ -100,6 +97,7 @@ static void send_mtu_probe_handler(int fd, short events, void *data) {
 		}
 
 		logger(DEBUG_TRAFFIC, LOG_INFO, "%s (%s) did not respond to UDP ping, restarting PMTU discovery", n->name, n->hostname);
+		n->status.udp_confirmed = false;
 		n->mtuprobes = 1;
 		n->minmtu = 0;
 		n->maxmtu = MTU;
@@ -127,7 +125,9 @@ static void send_mtu_probe_handler(int fd, short events, void *data) {
 		timeout = pingtimeout;
 	}
 
-	for(i = 0; i < 3 + localdiscovery; i++) {
+	for(int i = 0; i < 3 + localdiscovery; i++) {
+		int len;
+
 		if(n->maxmtu <= n->minmtu)
 			len = n->maxmtu;
 		else
@@ -135,7 +135,8 @@ static void send_mtu_probe_handler(int fd, short events, void *data) {
 
 		if(len < 64)
 			len = 64;
-		
+
+		vpn_packet_t packet;
 		memset(packet.data, 0, 14);
 		randomize(packet.data + 14, len - 14);
 		packet.len = len;
@@ -166,6 +167,8 @@ static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
 		packet->data[0] = 1;
 		send_udppacket(n, packet);
 	} else {
+		n->status.udp_confirmed = true;
+
 		if(n->mtuprobes > 30) {
 			if(n->minmtu)
 				n->mtuprobes = 30;
@@ -209,7 +212,7 @@ static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t l
 		return -1;
 #endif
 	}
-	
+
 	return -1;
 }
 
@@ -291,7 +294,7 @@ static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
 
 	if(digest_active(&n->indigest)) {
 		inpkt->len -= n->indigest.maclength;
- 		if(!digest_verify(&n->indigest, &inpkt->seqno, inpkt->len, (const char *)&inpkt->seqno + inpkt->len)) {
+		if(!digest_verify(&n->indigest, &inpkt->seqno, inpkt->len, (const char *)&inpkt->seqno + inpkt->len)) {
 			logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got unauthenticated packet from %s (%s)", n->name, n->hostname);
 			return;
 		}
@@ -306,7 +309,7 @@ static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
 			logger(DEBUG_TRAFFIC, LOG_DEBUG, "Error decrypting packet from %s (%s)", n->name, n->hostname);
 			return;
 		}
-		
+
 		outpkt->len = outlen;
 		inpkt = outpkt;
 	}
@@ -325,12 +328,12 @@ static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
 					return;
 				}
 				logger(DEBUG_ALWAYS, LOG_WARNING, "Lost %d packets from %s (%s)",
-					   	inpkt->seqno - n->received_seqno - 1, n->name, n->hostname);
+						inpkt->seqno - n->received_seqno - 1, n->name, n->hostname);
 				memset(n->late, 0, replaywin);
 			} else if (inpkt->seqno <= n->received_seqno) {
 				if((n->received_seqno >= replaywin * 8 && inpkt->seqno <= n->received_seqno - replaywin * 8) || !(n->late[(inpkt->seqno / 8) % replaywin] & (1 << inpkt->seqno % 8))) {
 					logger(DEBUG_ALWAYS, LOG_WARNING, "Got late or replayed packet from %s (%s), seqno %d, last received %d",
-					   	n->name, n->hostname, inpkt->seqno, n->received_seqno);
+						n->name, n->hostname, inpkt->seqno, n->received_seqno);
 					return;
 				}
 			} else {
@@ -345,7 +348,7 @@ static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
 
 	if(inpkt->seqno > n->received_seqno)
 		n->received_seqno = inpkt->seqno;
-			
+
 	if(n->received_seqno > MAX_SEQNO)
 		regenerate_key();
 
@@ -358,7 +361,7 @@ static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
 
 		if((outpkt->len = uncompress_packet(outpkt->data, inpkt->data, inpkt->len, n->incompression)) < 0) {
 			logger(DEBUG_TRAFFIC, LOG_ERR, "Error while uncompressing packet from %s (%s)",
-				  		 n->name, n->hostname);
+						 n->name, n->hostname);
 			return;
 		}
 
@@ -389,39 +392,49 @@ void receive_tcppacket(connection_t *c, const char *buffer, int len) {
 }
 
 static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
-	if(n->status.sptps) {
-		uint8_t type = 0;
-		int offset = 0;
-
-		if(!(origpkt->data[12] | origpkt->data[13])) {
-			sptps_send_record(&n->sptps, PKT_PROBE, (char *)origpkt->data, origpkt->len);
-			return;
+	if(!n->status.validkey) {
+		logger(DEBUG_TRAFFIC, LOG_INFO, "No valid key known yet for %s (%s)", n->name, n->hostname);
+		if(!n->status.waitingforkey)
+			send_req_key(n);
+		else if(n->last_req_key + 10 < time(NULL)) {
+			sptps_stop(&n->sptps);
+			n->status.waitingforkey = false;
+			send_req_key(n);
 		}
+		return;
+	}
 
-		if(routing_mode == RMODE_ROUTER)
-			offset = 14;
-		else
-			type = PKT_MAC;
-
-		if(origpkt->len < offset)
-			return;
+	uint8_t type = 0;
+	int offset = 0;
 
-		vpn_packet_t outpkt;
+	if(!(origpkt->data[12] | origpkt->data[13])) {
+		sptps_send_record(&n->sptps, PKT_PROBE, (char *)origpkt->data, origpkt->len);
+		return;
+	}
 
-		if(n->outcompression) {
-			int len = compress_packet(outpkt.data + offset, origpkt->data + offset, origpkt->len - offset, n->outcompression);
-			if(len < 0) {
-				logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
-			} else if(len < origpkt->len - offset) {
-				outpkt.len = len + offset;
-				origpkt = &outpkt;
-				type |= PKT_COMPRESSED;
-			}
-		}
+	if(routing_mode == RMODE_ROUTER)
+		offset = 14;
+	else
+		type = PKT_MAC;
 
-		sptps_send_record(&n->sptps, type, (char *)origpkt->data + offset, origpkt->len - offset);
+	if(origpkt->len < offset)
 		return;
+
+	vpn_packet_t outpkt;
+
+	if(n->outcompression) {
+		int len = compress_packet(outpkt.data + offset, origpkt->data + offset, origpkt->len - offset, n->outcompression);
+		if(len < 0) {
+			logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
+		} else if(len < origpkt->len - offset) {
+			outpkt.len = len + offset;
+			origpkt = &outpkt;
+			type |= PKT_COMPRESSED;
+		}
 	}
+
+	sptps_send_record(&n->sptps, type, (char *)origpkt->data + offset, origpkt->len - offset);
+	return;
 }
 
 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
@@ -518,53 +531,90 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
 		inpkt->len += digest_length(&n->outdigest);
 	}
 
-	/* Determine which socket we have to use */
-
-	if(n->address.sa.sa_family != listen_socket[n->sock].sa.sa.sa_family) {
-		for(int sock = 0; sock < listen_sockets; sock++) {
-			if(n->address.sa.sa_family == listen_socket[sock].sa.sa.sa_family) {
-				n->sock = sock;
-				break;
-			}
-		}
-	}
-
 	/* Send the packet */
 
-	struct sockaddr *sa;
-	socklen_t sl;
+	sockaddr_t *sa;
 	int sock;
 
 	/* Overloaded use of priority field: -1 means local broadcast */
 
 	if(origpriority == -1 && n->prevedge) {
-		struct sockaddr_in in;
-		in.sin_family = AF_INET;
-		in.sin_addr.s_addr = -1;
-		in.sin_port = n->prevedge->address.in.sin_port;
-		sa = (struct sockaddr *)&in;
-		sl = sizeof in;
+		sockaddr_t broadcast;
+		broadcast.in.sin_family = AF_INET;
+		broadcast.in.sin_addr.s_addr = -1;
+		broadcast.in.sin_port = n->prevedge->address.in.sin_port;
+		sa = &broadcast;
 		sock = 0;
 	} else {
 		if(origpriority == -1)
 			origpriority = 0;
 
-		sa = &(n->address.sa);
-		sl = SALEN(n->address.sa);
-		sock = n->sock;
+		if(n->status.udp_confirmed) {
+			/* Address of this node is confirmed, so use it. */
+			sa = &n->address;
+			sock = n->sock;
+		} else {
+			/* Otherwise, go through the list of known addresses of
+			   this node. The first address we try is always the
+			   one in n->address; that could be set to the node's
+			   reflexive UDP address discovered during key
+			   exchange. The other known addresses are those found
+			   in edges to this node. */
+
+			static unsigned int i;
+			int j = 0;
+			edge_t *candidate = NULL;
+
+			if(i) {
+				for splay_each(edge_t, e, edge_weight_tree) {
+					if(e->to != n)
+						continue;
+					j++;
+					if(!candidate || j == i)
+						candidate = e;
+				}
+			}
+
+			if(!candidate) {
+				sa = &n->address;
+				sock = n->sock;
+			} else {
+				sa = &candidate->address;
+				sock = rand() % listen_sockets;
+			}
+
+			if(i++)
+				if(i > j)
+					i = 0;
+		}
 	}
 
+	/* Determine which socket we have to use */
+
+	if(sa->sa.sa_family != listen_socket[sock].sa.sa.sa_family)
+		for(sock = 0; sock < listen_sockets; sock++)
+			if(sa->sa.sa_family == listen_socket[sock].sa.sa.sa_family)
+				break;
+
+	if(sock >= listen_sockets)
+		sock = 0;
+
+	if(!n->status.udp_confirmed)
+		n->sock = sock;
+
 #if defined(SOL_IP) && defined(IP_TOS)
 	if(priorityinheritance && origpriority != priority
 	   && listen_socket[n->sock].sa.sa.sa_family == AF_INET) {
 		priority = origpriority;
 		logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting outgoing packet priority to %d", priority);
-		if(setsockopt(listen_socket[n->sock].udp, SOL_IP, IP_TOS, &priority, sizeof(priority)))	/* SO_PRIORITY doesn't seem to work */
+		if(setsockopt(listen_socket[n->sock].udp, SOL_IP, IP_TOS, &priority, sizeof(priority))) /* SO_PRIORITY doesn't seem to work */
 			logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", strerror(errno));
 	}
 #endif
 
-	if(sendto(listen_socket[sock].udp, (char *) &inpkt->seqno, inpkt->len, 0, sa, sl) < 0 && !sockwouldblock(sockerrno)) {
+	socklen_t sl = SALEN(n->address.sa);
+
+	if(sendto(listen_socket[sock].udp, (char *) &inpkt->seqno, inpkt->len, 0, &sa->sa, sl) < 0 && !sockwouldblock(sockerrno)) {
 		if(sockmsgsize(sockerrno)) {
 			if(n->maxmtu >= origlen)
 				n->maxmtu = origlen - 1;
@@ -581,13 +631,15 @@ end:
 bool send_sptps_data(void *handle, uint8_t type, const char *data, size_t len) {
 	node_t *to = handle;
 
-	if(type >= SPTPS_HANDSHAKE || ((myself->options | to->options) & OPTION_TCPONLY)) {
+	if(type >= SPTPS_HANDSHAKE
+			|| ((myself->options | to->options) & OPTION_TCPONLY)
+			|| (type != PKT_PROBE && len > to->minmtu)) {
 		char buf[len * 4 / 3 + 5];
 		b64encode(data, buf, len);
 		if(!to->status.validkey)
 			return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, myself->name, to->name, buf, myself->incompression);
 		else
-			return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, to->name, REQ_SPTPS, buf);
+			return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, to->name, type >= SPTPS_HANDSHAKE ? REQ_SPTPS : REQ_PACKET, buf);
 	}
 
 	/* Send the packet */
@@ -620,6 +672,7 @@ bool receive_sptps_record(void *handle, uint8_t type, const char *data, uint16_t
 
 	if(type == SPTPS_HANDSHAKE) {
 		from->status.validkey = true;
+		from->status.waitingforkey = false;
 		logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) succesful", from->name, from->hostname);
 		return true;
 	}
@@ -737,16 +790,12 @@ void send_packet(node_t *n, vpn_packet_t *packet) {
 /* Broadcast a packet using the minimum spanning tree */
 
 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
-	splay_node_t *node;
-	connection_t *c;
-	node_t *n;
-
 	// Always give ourself a copy of the packet.
 	if(from != myself)
 		send_packet(myself, packet);
 
 	// In TunnelServer mode, do not forward broadcast packets.
-        // The MST might not be valid and create loops.
+	// The MST might not be valid and create loops.
 	if(tunnelserver || broadcast_mode == BMODE_NONE)
 		return;
 
@@ -758,27 +807,21 @@ void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
 		// This guarantees all nodes receive the broadcast packet, and
 		// usually distributes the sending of broadcast packets over all nodes.
 		case BMODE_MST:
-			for(node = connection_tree->head; node; node = node->next) {
-				c = node->data;
-
+			for list_each(connection_t, c, connection_list)
 				if(c->status.active && c->status.mst && c != from->nexthop->connection)
 					send_packet(c->node, packet);
-			}
 			break;
 
 		// In direct mode, we send copies to each node we know of.
-	        // However, this only reaches nodes that can be reached in a single hop.
+		// However, this only reaches nodes that can be reached in a single hop.
 		// We don't have enough information to forward broadcast packets in this case.
 		case BMODE_DIRECT:
 			if(from != myself)
 				break;
 
-			for(node = node_tree->head; node; node = node->next) {
-				n = node->data;
-
+			for splay_each(node_t, n, node_tree)
 				if(n->status.reachable && ((n->via == myself && n->nexthop == n) || n->via == n))
 					send_packet(n, packet);
-			}
 			break;
 
 		default:
@@ -787,16 +830,12 @@ void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
 }
 
 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
-	splay_node_t *node;
-	edge_t *e;
 	node_t *n = NULL;
 	bool hard = false;
 	static time_t last_hard_try = 0;
 	time_t now = time(NULL);
 
-	for(node = edge_weight_tree->head; node; node = node->next) {
-		e = node->data;
-
+	for splay_each(edge_t, e, edge_weight_tree) {
 		if(!e->to->status.reachable || e->to == myself)
 			continue;
 
@@ -838,7 +877,7 @@ void handle_incoming_vpn_data(int sock, short events, void *data) {
 
 	pkt.len = len;
 
-	sockaddrunmap(&from);		/* Some braindead IPv6 implementations do stupid things. */
+	sockaddrunmap(&from); /* Some braindead IPv6 implementations do stupid things. */
 
 	n = lookup_node_udp(&from);