X-Git-Url: https://www.tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Fnet_packet.c;h=c61bc60a898e9d55f613c860af0f0a63b9e79df0;hb=44a24f63acc70d19904e5540986b8301b3c9b882;hp=843926934df62b6d0befd10dab6782d9e4af2014;hpb=c2a9ed9e98e3dc4218c74fff774ddfe654adfd72;p=tinc

diff --git a/src/net_packet.c b/src/net_packet.c
index 84392693..c61bc60a 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;
 		}
 
@@ -394,6 +397,7 @@ static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
 		if(!n->status.waitingforkey)
 			send_req_key(n);
 		else if(n->last_req_key + 10 < time(NULL)) {
+			logger(DEBUG_ALWAYS, LOG_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
 			sptps_stop(&n->sptps);
 			n->status.waitingforkey = false;
 			send_req_key(n);
@@ -528,53 +532,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;
@@ -591,18 +632,20 @@ 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)
-			|| (type != PKT_PROBE && len > to->minmtu)) {
+	/* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
+
+	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 no valid key is known yet, send the packets using ANS_KEY requests,
+		   to ensure we get to learn the reflexive UDP address. */
 		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, type >= SPTPS_HANDSHAKE ? REQ_SPTPS : REQ_PACKET, buf);
+			return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, to->name, REQ_SPTPS, buf);
 	}
 
-	/* Send the packet */
+	/* Otherwise, send the packet via UDP */
 
 	struct sockaddr *sa;
 	socklen_t sl;
@@ -750,16 +793,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;
 
@@ -771,27 +810,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:
@@ -800,16 +833,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;
 
@@ -851,7 +880,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);