Significant simplification to path logic.

1 files changed, 106 insertions, 167 deletions

diff --git a/node/Peer.cpp b/node/Peer.cpp
index 0795a6ea..2711dd19 100644
--- a/node/Peer.cpp
+++ b/node/Peer.cpp
@@ -27,14 +27,6 @@
 #include "Cluster.hpp"
 #include "Packet.hpp"
 
-#ifndef AF_MAX
-#if AF_INET > AF_INET6
-#define AF_MAX AF_INET
-#else
-#define AF_MAX AF_INET6
-#endif
-#endif
-
 namespace ZeroTier {
 
 Peer::Peer(const RuntimeEnvironment *renv,const Identity &myIdentity,const Identity &peerIdentity) :
@@ -51,18 +43,15 @@ Peer::Peer(const RuntimeEnvironment *renv,const Identity &myIdentity,const Ident
 	_lastComRequestSent(0),
 	_lastCredentialsReceived(0),
 	_lastTrustEstablishedPacketReceived(0),
-	_remoteClusterOptimal4(0),
 	_vProto(0),
 	_vMajor(0),
 	_vMinor(0),
 	_vRevision(0),
 	_id(peerIdentity),
-	_numPaths(0),
 	_latency(0),
 	_directPathPushCutoffCount(0),
 	_credentialsCutoffCount(0)
 {
-	memset(_remoteClusterOptimal6,0,sizeof(_remoteClusterOptimal6));
 	if (!myIdentity.agree(peerIdentity,_key,ZT_PEER_SECRET_KEY_LENGTH))
 		throw std::runtime_error("new peer identity key agreement failed");
 }
@@ -80,7 +69,7 @@ void Peer::received(
 	const uint64_t now = RR->node->now();
 
 #ifdef ZT_ENABLE_CLUSTER
-	bool suboptimalPath = false;
+	bool isClusterSuboptimalPath = false;
 	if ((RR->cluster)&&(hops == 0)) {
 		// Note: findBetterEndpoint() is first since we still want to check
 		// for a better endpoint even if we don't actually send a redirect.
@@ -146,65 +135,60 @@ void Peer::received(
 		path->updateLinkQuality((unsigned int)(packetId & 7));
 
 	if (hops == 0) {
-		bool pathIsConfirmed = false;
+		bool pathAlreadyKnown = false;
 		{
 			Mutex::Lock _l(_paths_m);
-			for(unsigned int p=0;p<_numPaths;++p) {
-				if (_paths[p].path->address() == path->address()) {
-					_paths[p].lastReceive = now;
-					_paths[p].path = path; // local address may have changed!
+			if ((path->address().ss_family == AF_INET)&&(_v4Path.p)) {
+				const struct sockaddr_in *const r = reinterpret_cast<const struct sockaddr_in *>(&(path->address()));
+				const struct sockaddr_in *const l = reinterpret_cast<const struct sockaddr_in *>(&(_v4Path.p->address()));
+				const struct sockaddr_in *const rl = reinterpret_cast<const struct sockaddr_in *>(&(path->localAddress()));
+				const struct sockaddr_in *const ll = reinterpret_cast<const struct sockaddr_in *>(&(_v4Path.p->localAddress()));
+				if ((r->sin_addr.s_addr == l->sin_addr.s_addr)&&(r->sin_port == l->sin_port)&&(rl->sin_addr.s_addr == ll->sin_addr.s_addr)&&(rl->sin_port == ll->sin_port)) {
+					_v4Path.lr = now;
 #ifdef ZT_ENABLE_CLUSTER
-					_paths[p].localClusterSuboptimal = suboptimalPath;
+					_v4Path.localClusterSuboptimal = isClusterSuboptimalPath;
 #endif
-					pathIsConfirmed = true;
-					break;
+					pathAlreadyKnown = true;
+				}
+			} else if ((path->address().ss_family == AF_INET6)&&(_v6Path.p)) {
+				const struct sockaddr_in6 *const r = reinterpret_cast<const struct sockaddr_in6 *>(&(path->address()));
+				const struct sockaddr_in6 *const l = reinterpret_cast<const struct sockaddr_in6 *>(&(_v6Path.p->address()));
+				const struct sockaddr_in6 *const rl = reinterpret_cast<const struct sockaddr_in6 *>(&(path->localAddress()));
+				const struct sockaddr_in6 *const ll = reinterpret_cast<const struct sockaddr_in6 *>(&(_v6Path.p->localAddress()));
+				if ((!memcmp(r->sin6_addr.s6_addr,l->sin6_addr.s6_addr,16))&&(r->sin6_port == l->sin6_port)&&(!memcmp(rl->sin6_addr.s6_addr,ll->sin6_addr.s6_addr,16))&&(rl->sin6_port == ll->sin6_port)) {
+					_v6Path.lr = now;
+#ifdef ZT_ENABLE_CLUSTER
+					_v6Path.localClusterSuboptimal = isClusterSuboptimalPath;
+#endif
+					pathAlreadyKnown = true;
 				}
 			}
 		}
 
-		if ( (!pathIsConfirmed) && (RR->node->shouldUsePathForZeroTierTraffic(tPtr,_id.address(),path->localAddress(),path->address())) ) {
+		if ( (!pathAlreadyKnown) && (RR->node->shouldUsePathForZeroTierTraffic(tPtr,_id.address(),path->localAddress(),path->address())) ) {
 			if (verb == Packet::VERB_OK) {
 				Mutex::Lock _l(_paths_m);
-
-				// Since this is a new path, figure out where to put it (possibly replacing an old/dead one)
-				unsigned int slot;
-				if (_numPaths < ZT_MAX_PEER_NETWORK_PATHS) {
-					slot = _numPaths++;
-				} else {
-					// First try to replace the worst within the same address family, if possible
-					int worstSlot = -1;
-					uint64_t worstScore = 0xffffffffffffffffULL;
-					for(unsigned int p=0;p<_numPaths;++p) {
-						if (_paths[p].path->address().ss_family == path->address().ss_family) {
-							const uint64_t s = _pathScore(p,now);
-							if (s < worstScore) {
-								worstScore = s;
-								worstSlot = (int)p;
-							}
-						}
-					}
-					if (worstSlot >= 0) {
-						slot = (unsigned int)worstSlot;
-					} else {
-						// If we can't find one with the same family, replace the worst of any family
-						slot = ZT_MAX_PEER_NETWORK_PATHS - 1;
-						for(unsigned int p=0;p<_numPaths;++p) {
-							const uint64_t s = _pathScore(p,now);
-							if (s < worstScore) {
-								worstScore = s;
-								slot = p;
-							}
-						}
+				if (path->address().ss_family == AF_INET) {
+					if ((!_v4Path.p)||(!_v4Path.p->alive(now))||(path->preferenceRank() >= _v4Path.p->preferenceRank())) {
+						_v4Path.lr = now;
+						_v4Path.p = path;
+#ifdef ZT_ENABLE_CLUSTER
+						_v4Path.localClusterSuboptimal = isClusterSuboptimalPath;
+						if (RR->cluster)
+							RR->cluster->broadcastHavePeer(_id);
+#endif
 					}
-				}
-
-				_paths[slot].lastReceive = now;
-				_paths[slot].path = path;
+				} else if (path->address().ss_family == AF_INET6) {
+					if ((!_v6Path.p)||(!_v6Path.p->alive(now))||(path->preferenceRank() >= _v6Path.p->preferenceRank())) {
+						_v6Path.lr = now;
+						_v6Path.p = path;
 #ifdef ZT_ENABLE_CLUSTER
-				_paths[slot].localClusterSuboptimal = suboptimalPath;
-				if (RR->cluster)
-					RR->cluster->broadcastHavePeer(_id);
+						_v6Path.localClusterSuboptimal = isClusterSuboptimalPath;
+						if (RR->cluster)
+							RR->cluster->broadcastHavePeer(_id);
 #endif
+					}
+				}
 			} else {
 				TRACE("got %s via unknown path %s(%s), confirming...",Packet::verbString(verb),_id.address().toString().c_str(),path->address().toString().c_str());
 				attemptToContactAt(tPtr,path->localAddress(),path->address(),now,true,path->nextOutgoingCounter());
@@ -214,10 +198,10 @@ void Peer::received(
 	} else if (this->trustEstablished(now)) {
 		// Send PUSH_DIRECT_PATHS if hops>0 (relayed) and we have a trust relationship (common network membership)
 #ifdef ZT_ENABLE_CLUSTER
-			// Cluster mode disables normal PUSH_DIRECT_PATHS in favor of cluster-based peer redirection
-			const bool haveCluster = (RR->cluster);
+		// Cluster mode disables normal PUSH_DIRECT_PATHS in favor of cluster-based peer redirection
+		const bool haveCluster = (RR->cluster);
 #else
-			const bool haveCluster = false;
+		const bool haveCluster = false;
 #endif
 		if ( ((now - _lastDirectPathPushSent) >= ZT_DIRECT_PATH_PUSH_INTERVAL) && (!haveCluster) ) {
 			_lastDirectPathPushSent = now;
@@ -290,60 +274,50 @@ void Peer::received(
 	}
 }
 
-bool Peer::hasActivePathTo(uint64_t now,const InetAddress &addr) const
-{
-	Mutex::Lock _l(_paths_m);
-	for(unsigned int p=0;p<_numPaths;++p) {
-		if ( (_paths[p].path->address() == addr) && ((now - _paths[p].lastReceive) <= ZT_PEER_PATH_EXPIRATION) && (_paths[p].path->alive(now)) )
-			return true; 
-	}
-	return false;
-}
-
-bool Peer::sendDirect(void *tPtr,const void *data,unsigned int len,uint64_t now,bool forceEvenIfDead)
+bool Peer::sendDirect(void *tPtr,const void *data,unsigned int len,uint64_t now,bool force)
 {
 	Mutex::Lock _l(_paths_m);
 
-	int bestp = -1;
-	uint64_t best = 0ULL;
-	for(unsigned int p=0;p<_numPaths;++p) {
-		if ( ((now - _paths[p].lastReceive) <= ZT_PEER_PATH_EXPIRATION) && (_paths[p].path->alive(now)||(forceEvenIfDead)) ) {
-			const uint64_t s = _pathScore(p,now);
-			if (s >= best) {
-				best = s;
-				bestp = (int)p;
-			}
+	uint64_t v6lr = 0;
+	if ( ((now - _v6Path.lr) < ZT_PEER_PATH_EXPIRATION) && (_v6Path.p) )
+		v6lr = _v6Path.p->lastIn();
+	uint64_t v4lr = 0;
+	if ( ((now - _v4Path.lr) < ZT_PEER_PATH_EXPIRATION) && (_v4Path.p) )
+		v4lr = _v4Path.p->lastIn();
+
+	if ( (v6lr > v4lr) && ((now - v6lr) < ZT_PATH_ALIVE_TIMEOUT) ) {
+		return _v6Path.p->send(RR,tPtr,data,len,now);
+	} else if ((now - v4lr) < ZT_PATH_ALIVE_TIMEOUT) {
+		return _v4Path.p->send(RR,tPtr,data,len,now);
+	} else if (force) {
+		if (v6lr > v4lr) {
+			return _v6Path.p->send(RR,tPtr,data,len,now);
+		} else if (v4lr) {
+			return _v4Path.p->send(RR,tPtr,data,len,now);
 		}
 	}
 
-	if (bestp >= 0) {
-		return _paths[bestp].path->send(RR,tPtr,data,len,now);
-	} else {
-		return false;
-	}
+	return false;
 }
 
 SharedPtr<Path> Peer::getBestPath(uint64_t now,bool includeExpired)
 {
 	Mutex::Lock _l(_paths_m);
 
-	int bestp = -1;
-	uint64_t best = 0ULL;
-	for(unsigned int p=0;p<_numPaths;++p) {
-		if ( ((now - _paths[p].lastReceive) <= ZT_PEER_PATH_EXPIRATION) || (includeExpired) ) {
-			const uint64_t s = _pathScore(p,now);
-			if (s >= best) {
-				best = s;
-				bestp = (int)p;
-			}
-		}
+	uint64_t v6lr = 0;
+	if ( ( includeExpired || ((now - _v6Path.lr) < ZT_PEER_PATH_EXPIRATION) ) && (_v6Path.p) )
+		v6lr = _v6Path.p->lastIn();
+	uint64_t v4lr = 0;
+	if ( ( includeExpired || ((now - _v4Path.lr) < ZT_PEER_PATH_EXPIRATION) ) && (_v4Path.p) )
+		v4lr = _v4Path.p->lastIn();
+
+	if (v6lr > v4lr) {
+		return _v6Path.p;
+	} else if (v4lr) {
+		return _v4Path.p;
 	}
 
-	if (bestp >= 0) {
-		return _paths[bestp].path;
-	} else {
-		return SharedPtr<Path>();
-	}
+	return SharedPtr<Path>();
 }
 
 void Peer::sendHELLO(void *tPtr,const InetAddress &localAddr,const InetAddress &atAddress,uint64_t now,unsigned int counter)
@@ -420,79 +394,44 @@ bool Peer::doPingAndKeepalive(void *tPtr,uint64_t now,int inetAddressFamily)
 {
 	Mutex::Lock _l(_paths_m);
 
-	int bestp = -1;
-	uint64_t best = 0ULL;
-	for(unsigned int p=0;p<_numPaths;++p) {
-		if ( ((now - _paths[p].lastReceive) <= ZT_PEER_PATH_EXPIRATION) && ((inetAddressFamily < 0)||((int)_paths[p].path->address().ss_family == inetAddressFamily)) ) {
-			const uint64_t s = _pathScore(p,now);
-			if (s >= best) {
-				best = s;
-				bestp = (int)p;
+	if (inetAddressFamily < 0) {
+		uint64_t v6lr = 0;
+		if ( ((now - _v6Path.lr) < ZT_PEER_PATH_EXPIRATION) && (_v6Path.p) )
+			v6lr = _v6Path.p->lastIn();
+		uint64_t v4lr = 0;
+		if ( ((now - _v4Path.lr) < ZT_PEER_PATH_EXPIRATION) && (_v4Path.p) )
+			v4lr = _v4Path.p->lastIn();
+
+		if (v6lr > v4lr) {
+			if ( ((now - _v6Path.lr) >= ZT_PEER_PING_PERIOD) || (_v6Path.p->needsHeartbeat(now)) ) {
+				attemptToContactAt(tPtr,_v6Path.p->localAddress(),_v6Path.p->address(),now,false,_v6Path.p->nextOutgoingCounter());
+				_v6Path.p->sent(now);
+				return true;
+			}
+		} else if (v4lr) {
+			if ( ((now - _v4Path.lr) >= ZT_PEER_PING_PERIOD) || (_v4Path.p->needsHeartbeat(now)) ) {
+				attemptToContactAt(tPtr,_v4Path.p->localAddress(),_v4Path.p->address(),now,false,_v4Path.p->nextOutgoingCounter());
+				_v4Path.p->sent(now);
+				return true;
 			}
 		}
-	}
-
-	if (bestp >= 0) {
-		if ( ((now - _paths[bestp].lastReceive) >= ZT_PEER_PING_PERIOD) || (_paths[bestp].path->needsHeartbeat(now)) ) {
-			attemptToContactAt(tPtr,_paths[bestp].path->localAddress(),_paths[bestp].path->address(),now,false,_paths[bestp].path->nextOutgoingCounter());
-			_paths[bestp].path->sent(now);
-		}
-		return true;
 	} else {
-		return false;
-	}
-}
-
-bool Peer::hasActiveDirectPath(uint64_t now) const
-{
-	Mutex::Lock _l(_paths_m);
-	for(unsigned int p=0;p<_numPaths;++p) {
-		if (((now - _paths[p].lastReceive) <= ZT_PEER_PATH_EXPIRATION)&&(_paths[p].path->alive(now)))
-			return true;
-	}
-	return false;
-}
-
-void Peer::resetWithinScope(void *tPtr,InetAddress::IpScope scope,int inetAddressFamily,uint64_t now)
-{
-	Mutex::Lock _l(_paths_m);
-	for(unsigned int p=0;p<_numPaths;++p) {
-		if ( (_paths[p].path->address().ss_family == inetAddressFamily) && (_paths[p].path->address().ipScope() == scope) ) {
-			attemptToContactAt(tPtr,_paths[p].path->localAddress(),_paths[p].path->address(),now,false,_paths[p].path->nextOutgoingCounter());
-			_paths[p].path->sent(now);
-			_paths[p].lastReceive = 0; // path will not be used unless it speaks again
-		}
-	}
-}
-
-void Peer::getRendezvousAddresses(uint64_t now,InetAddress &v4,InetAddress &v6) const
-{
-	Mutex::Lock _l(_paths_m);
-
-	int bestp4 = -1,bestp6 = -1;
-	uint64_t best4 = 0ULL,best6 = 0ULL;
-	for(unsigned int p=0;p<_numPaths;++p) {
-		if ( ((now - _paths[p].lastReceive) <= ZT_PEER_PATH_EXPIRATION) && (_paths[p].path->alive(now)) ) {
-			if (_paths[p].path->address().ss_family == AF_INET) {
-				const uint64_t s = _pathScore(p,now);
-				if (s >= best4) {
-					best4 = s;
-					bestp4 = (int)p;
-				}
-			} else if (_paths[p].path->address().ss_family == AF_INET6) {
-				const uint64_t s = _pathScore(p,now);
-				if (s >= best6) {
-					best6 = s;
-					bestp6 = (int)p;
-				}
+		if ( (inetAddressFamily == AF_INET) && ((now - _v4Path.lr) < ZT_PEER_PATH_EXPIRATION) ) {
+			if ( ((now - _v4Path.lr) >= ZT_PEER_PING_PERIOD) || (_v4Path.p->needsHeartbeat(now)) ) {
+				attemptToContactAt(tPtr,_v4Path.p->localAddress(),_v4Path.p->address(),now,false,_v4Path.p->nextOutgoingCounter());
+				_v4Path.p->sent(now);
+				return true;
+			}
+		} else if ( (inetAddressFamily == AF_INET6) && ((now - _v6Path.lr) < ZT_PEER_PATH_EXPIRATION) ) {
+			if ( ((now - _v6Path.lr) >= ZT_PEER_PING_PERIOD) || (_v6Path.p->needsHeartbeat(now)) ) {
+				attemptToContactAt(tPtr,_v6Path.p->localAddress(),_v6Path.p->address(),now,false,_v6Path.p->nextOutgoingCounter());
+				_v6Path.p->sent(now);
+				return true;
 			}
 		}
 	}
 
-	if (bestp4 >= 0)
-		v4 = _paths[bestp4].path->address();
-	if (bestp6 >= 0)
-		v6 = _paths[bestp6].path->address();
+	return false;
 }
 
 } // namespace ZeroTier