Tear out old "link quality" stuff since it is not currently used and will be done differently.

8 files changed, 37 insertions, 112 deletions

diff --git a/node/IncomingPacket.cpp b/node/IncomingPacket.cpp
index d44e3b54..38fd3aa0 100644
--- a/node/IncomingPacket.cpp
+++ b/node/IncomingPacket.cpp
@@ -241,7 +241,7 @@ bool IncomingPacket::_doHELLO(const RuntimeEnvironment *RR,void *tPtr,const bool
 						outp.append((uint8_t)Packet::VERB_HELLO);
 						outp.append((uint64_t)pid);
 						outp.append((uint8_t)Packet::ERROR_IDENTITY_COLLISION);
-						outp.armor(key,true,_path->nextOutgoingCounter());
+						outp.armor(key,true);
 						_path->send(RR,tPtr,outp.data(),outp.size(),RR->node->now());
 					} else {
 						RR->t->incomingPacketMessageAuthenticationFailure(tPtr,_path,pid,fromAddress,hops(),"invalid MAC");
@@ -391,7 +391,7 @@ bool IncomingPacket::_doHELLO(const RuntimeEnvironment *RR,void *tPtr,const bool
 	}
 	outp.setAt<uint16_t>(worldUpdateSizeAt,(uint16_t)(outp.size() - (worldUpdateSizeAt + 2)));
 
-	outp.armor(peer->key(),true,_path->nextOutgoingCounter());
+	outp.armor(peer->key(),true);
 	_path->send(RR,tPtr,outp.data(),outp.size(),now);
 
 	peer->setRemoteVersion(protoVersion,vMajor,vMinor,vRevision); // important for this to go first so received() knows the version
@@ -538,7 +538,7 @@ bool IncomingPacket::_doWHOIS(const RuntimeEnvironment *RR,void *tPtr,const Shar
 	}
 
 	if (count > 0) {
-		outp.armor(peer->key(),true,_path->nextOutgoingCounter());
+		outp.armor(peer->key(),true);
 		_path->send(RR,tPtr,outp.data(),outp.size(),RR->node->now());
 	}
 
@@ -560,7 +560,7 @@ bool IncomingPacket::_doRENDEZVOUS(const RuntimeEnvironment *RR,void *tPtr,const
 				if (RR->node->shouldUsePathForZeroTierTraffic(tPtr,with,_path->localSocket(),atAddr)) {
 					const uint64_t junk = RR->node->prng();
 					RR->node->putPacket(tPtr,_path->localSocket(),atAddr,&junk,4,2); // send low-TTL junk packet to 'open' local NAT(s) and stateful firewalls
-					rendezvousWith->attemptToContactAt(tPtr,_path->localSocket(),atAddr,RR->node->now(),false,0);
+					rendezvousWith->attemptToContactAt(tPtr,_path->localSocket(),atAddr,RR->node->now(),false);
 				}
 			}
 		}
@@ -669,7 +669,7 @@ bool IncomingPacket::_doEXT_FRAME(const RuntimeEnvironment *RR,void *tPtr,const
 			outp.append((uint8_t)Packet::VERB_EXT_FRAME);
 			outp.append((uint64_t)packetId());
 			outp.append((uint64_t)nwid);
-			outp.armor(peer->key(),true,_path->nextOutgoingCounter());
+			outp.armor(peer->key(),true);
 			_path->send(RR,tPtr,outp.data(),outp.size(),RR->node->now());
 		}
 
@@ -692,7 +692,7 @@ bool IncomingPacket::_doECHO(const RuntimeEnvironment *RR,void *tPtr,const Share
 	outp.append((uint64_t)pid);
 	if (size() > ZT_PACKET_IDX_PAYLOAD)
 		outp.append(reinterpret_cast<const unsigned char *>(data()) + ZT_PACKET_IDX_PAYLOAD,size() - ZT_PACKET_IDX_PAYLOAD);
-	outp.armor(peer->key(),true,_path->nextOutgoingCounter());
+	outp.armor(peer->key(),true);
 	_path->send(RR,tPtr,outp.data(),outp.size(),RR->node->now());
 
 	peer->received(tPtr,_path,hops(),pid,Packet::VERB_ECHO,0,Packet::VERB_NOP,false,0);
@@ -885,7 +885,7 @@ bool IncomingPacket::_doNETWORK_CONFIG_REQUEST(const RuntimeEnvironment *RR,void
 		outp.append(requestPacketId);
 		outp.append((unsigned char)Packet::ERROR_UNSUPPORTED_OPERATION);
 		outp.append(nwid);
-		outp.armor(peer->key(),true,_path->nextOutgoingCounter());
+		outp.armor(peer->key(),true);
 		_path->send(RR,tPtr,outp.data(),outp.size(),RR->node->now());
 	}
 
@@ -905,7 +905,7 @@ bool IncomingPacket::_doNETWORK_CONFIG(const RuntimeEnvironment *RR,void *tPtr,c
 			outp.append((uint64_t)packetId());
 			outp.append((uint64_t)network->id());
 			outp.append((uint64_t)configUpdateId);
-			outp.armor(peer->key(),true,_path->nextOutgoingCounter());
+			outp.armor(peer->key(),true);
 			_path->send(RR,tPtr,outp.data(),outp.size(),RR->node->now());
 		}
 	}
@@ -948,7 +948,7 @@ bool IncomingPacket::_doMULTICAST_GATHER(const RuntimeEnvironment *RR,void *tPtr
 		outp.append((uint32_t)mg.adi());
 		const unsigned int gatheredLocally = RR->mc->gather(peer->address(),nwid,mg,outp,gatherLimit);
 		if (gatheredLocally > 0) {
-			outp.armor(peer->key(),true,_path->nextOutgoingCounter());
+			outp.armor(peer->key(),true);
 			_path->send(RR,tPtr,outp.data(),outp.size(),RR->node->now());
 		}
 	}
@@ -1043,7 +1043,7 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *RR,void *tPtr,
 			outp.append((uint32_t)to.adi());
 			outp.append((unsigned char)0x02); // flag 0x02 = contains gather results
 			if (RR->mc->gather(peer->address(),nwid,to,outp,gatherLimit)) {
-				outp.armor(peer->key(),true,_path->nextOutgoingCounter());
+				outp.armor(peer->key(),true);
 				_path->send(RR,tPtr,outp.data(),outp.size(),RR->node->now());
 			}
 		}
@@ -1094,7 +1094,7 @@ bool IncomingPacket::_doPUSH_DIRECT_PATHS(const RuntimeEnvironment *RR,void *tPt
 					if ((flags & ZT_PUSH_DIRECT_PATHS_FLAG_CLUSTER_REDIRECT) != 0) {
 						peer->clusterRedirect(tPtr,_path,a,now);
 					} else if (++countPerScope[(int)a.ipScope()][0] <= ZT_PUSH_DIRECT_PATHS_MAX_PER_SCOPE_AND_FAMILY) {
-						peer->attemptToContactAt(tPtr,InetAddress(),a,now,false,0);
+						peer->attemptToContactAt(tPtr,InetAddress(),a,now,false);
 					}
 				}
 			}	break;
@@ -1108,7 +1108,7 @@ bool IncomingPacket::_doPUSH_DIRECT_PATHS(const RuntimeEnvironment *RR,void *tPt
 					if ((flags & ZT_PUSH_DIRECT_PATHS_FLAG_CLUSTER_REDIRECT) != 0) {
 						peer->clusterRedirect(tPtr,_path,a,now);
 					} else if (++countPerScope[(int)a.ipScope()][1] <= ZT_PUSH_DIRECT_PATHS_MAX_PER_SCOPE_AND_FAMILY) {
-						peer->attemptToContactAt(tPtr,InetAddress(),a,now,false,0);
+						peer->attemptToContactAt(tPtr,InetAddress(),a,now,false);
 					}
 				}
 			}	break;
@@ -1170,7 +1170,7 @@ void IncomingPacket::_sendErrorNeedCredentials(const RuntimeEnvironment *RR,void
 		outp.append(packetId());
 		outp.append((uint8_t)Packet::ERROR_NEED_MEMBERSHIP_CERTIFICATE);
 		outp.append(nwid);
-		outp.armor(peer->key(),true,_path->nextOutgoingCounter());
+		outp.armor(peer->key(),true);
 		_path->send(RR,tPtr,outp.data(),outp.size(),now);
 	}
 }
diff --git a/node/Node.cpp b/node/Node.cpp
index 8d8f5ca0..d4b69689 100644
--- a/node/Node.cpp
+++ b/node/Node.cpp
@@ -202,7 +202,7 @@ public:
 				for(unsigned long k=0,ptr=(unsigned long)RR->node->prng();k<(unsigned long)upstreamStableEndpoints->size();++k) {
 					const InetAddress &addr = (*upstreamStableEndpoints)[ptr++ % upstreamStableEndpoints->size()];
 					if (addr.ss_family == AF_INET) {
-						p->sendHELLO(_tPtr,-1,addr,_now,0);
+						p->sendHELLO(_tPtr,-1,addr,_now);
 						contacted = true;
 						break;
 					}
@@ -213,7 +213,7 @@ public:
 				for(unsigned long k=0,ptr=(unsigned long)RR->node->prng();k<(unsigned long)upstreamStableEndpoints->size();++k) {
 					const InetAddress &addr = (*upstreamStableEndpoints)[ptr++ % upstreamStableEndpoints->size()];
 					if (addr.ss_family == AF_INET6) {
-						p->sendHELLO(_tPtr,-1,addr,_now,0);
+						p->sendHELLO(_tPtr,-1,addr,_now);
 						contacted = true;
 						break;
 					}
@@ -225,7 +225,7 @@ public:
 			if ((!contacted)&&(_bestCurrentUpstream)) {
 				const SharedPtr<Path> up(_bestCurrentUpstream->getBestPath(_now,true));
 				if (up)
-					p->sendHELLO(_tPtr,up->localSocket(),up->address(),_now,up->nextOutgoingCounter());
+					p->sendHELLO(_tPtr,up->localSocket(),up->address(),_now);
 			}
 
 			lastReceiveFromUpstream = std::max(p->lastReceive(),lastReceiveFromUpstream);
@@ -445,7 +445,6 @@ ZT_PeerList *Node::peers() const
 			p->paths[p->pathCount].lastSend = (*path)->lastOut();
 			p->paths[p->pathCount].lastReceive = (*path)->lastIn();
 			p->paths[p->pathCount].trustedPathId = RR->topology->getOutboundPathTrust((*path)->address());
-			p->paths[p->pathCount].linkQuality = (int)(*path)->linkQuality();
 			p->paths[p->pathCount].expired = 0;
 			p->paths[p->pathCount].preferred = ((*path) == bestp) ? 1 : 0;
 			++p->pathCount;
diff --git a/node/Packet.cpp b/node/Packet.cpp
index af42cda5..cb9e1e0f 100644
--- a/node/Packet.cpp
+++ b/node/Packet.cpp
@@ -1061,18 +1061,16 @@ static inline int LZ4_decompress_safe(const char* source, char* dest, int compre
 
 const unsigned char Packet::ZERO_KEY[32] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
 
-void Packet::armor(const void *key,bool encryptPayload,unsigned int counter)
+void Packet::armor(const void *key,bool encryptPayload)
 {
 	uint8_t mangledKey[32];
 	uint8_t *const data = reinterpret_cast<uint8_t *>(unsafeData());
 
-	// Mask least significant 3 bits of packet ID with counter to embed packet send counter for QoS use
-	data[7] = (data[7] & 0xf8) | (uint8_t)(counter & 0x07);
-
 	// Set flag now, since it affects key mangle function
 	setCipher(encryptPayload ? ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012 : ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_NONE);
 
 	_salsa20MangleKey((const unsigned char *)key,mangledKey);
+
 	if (ZT_HAS_FAST_CRYPTO()) {
 		const unsigned int encryptLen = (encryptPayload) ? (size() - ZT_PACKET_IDX_VERB) : 0;
 		uint64_t keyStream[(ZT_PROTO_MAX_PACKET_LENGTH + 64 + 8) / 8];
diff --git a/node/Packet.hpp b/node/Packet.hpp
index cc055347..8cfb5492 100644
--- a/node/Packet.hpp
+++ b/node/Packet.hpp
@@ -68,7 +68,6 @@
  *   + Tags and Capabilities
  *   + Inline push of CertificateOfMembership deprecated
  * 9 - 1.2.0 ... CURRENT
- *   + In-band encoding of packet counter for link quality measurement
  */
 #define ZT_PROTO_VERSION 9
 
@@ -1203,11 +1202,6 @@ public:
 	inline uint64_t packetId() const { return at<uint64_t>(ZT_PACKET_IDX_IV); }
 
 	/**
-	 * @return Value of link quality counter extracted from this packet's ID, range 0 to 7 (3 bits)
-	 */
-	inline unsigned int linkQualityCounter() const { return (unsigned int)(reinterpret_cast<const uint8_t *>(data())[7] & 0x07); }
-
-	/**
 	 * Set packet verb
 	 *
 	 * This also has the side-effect of clearing any verb flags, such as
@@ -1237,9 +1231,8 @@ public:
 	 *
 	 * @param key 32-byte key
 	 * @param encryptPayload If true, encrypt packet payload, else just MAC
-	 * @param counter Packet send counter for destination peer -- only least significant 3 bits are used
 	 */
-	void armor(const void *key,bool encryptPayload,unsigned int counter);
+	void armor(const void *key,bool encryptPayload);
 
 	/**
 	 * Verify and (if encrypted) decrypt packet
diff --git a/node/Path.hpp b/node/Path.hpp
index 008b05c5..6b4b9915 100644
--- a/node/Path.hpp
+++ b/node/Path.hpp
@@ -94,36 +94,22 @@ public:
 		_lastOut(0),
 		_lastIn(0),
 		_lastTrustEstablishedPacketReceived(0),
-		_incomingLinkQualityFastLog(0xffffffffffffffffULL),
 		_localSocket(-1),
-		_incomingLinkQualitySlowLogPtr(0),
-		_incomingLinkQualitySlowLogCounter(-64), // discard first fast log
-		_incomingLinkQualityPreviousPacketCounter(0),
-		_outgoingPacketCounter(0),
 		_latency(0xffff),
 		_addr(),
 		_ipScope(InetAddress::IP_SCOPE_NONE)
 	{
-		for(int i=0;i<(int)sizeof(_incomingLinkQualitySlowLog);++i)
-			_incomingLinkQualitySlowLog[i] = ZT_PATH_LINK_QUALITY_MAX;
 	}
 
 	Path(const int64_t localSocket,const InetAddress &addr) :
 		_lastOut(0),
 		_lastIn(0),
 		_lastTrustEstablishedPacketReceived(0),
-		_incomingLinkQualityFastLog(0xffffffffffffffffULL),
 		_localSocket(localSocket),
-		_incomingLinkQualitySlowLogPtr(0),
-		_incomingLinkQualitySlowLogCounter(-64), // discard first fast log
-		_incomingLinkQualityPreviousPacketCounter(0),
-		_outgoingPacketCounter(0),
 		_latency(0xffff),
 		_addr(addr),
 		_ipScope(addr.ipScope())
 	{
-		for(int i=0;i<(int)sizeof(_incomingLinkQualitySlowLog);++i)
-			_incomingLinkQualitySlowLog[i] = ZT_PATH_LINK_QUALITY_MAX;
 	}
 
 	/**
@@ -134,39 +120,6 @@ public:
 	inline void received(const uint64_t t) { _lastIn = t; }
 
 	/**
-	 * Update link quality using a counter from an incoming packet (or packet head in fragmented case)
-	 *
-	 * @param counter Packet link quality counter (range 0 to 7, must not have other bits set)
-	 */
-	inline void updateLinkQuality(const unsigned int counter)
-	{
-		const unsigned int prev = _incomingLinkQualityPreviousPacketCounter;
-		_incomingLinkQualityPreviousPacketCounter = counter;
-		const uint64_t fl = (_incomingLinkQualityFastLog = ((_incomingLinkQualityFastLog << 1) | (uint64_t)(prev == ((counter - 1) & 0x7))));
-		if (++_incomingLinkQualitySlowLogCounter >= 64) {
-			_incomingLinkQualitySlowLogCounter = 0;
-			_incomingLinkQualitySlowLog[_incomingLinkQualitySlowLogPtr++ % sizeof(_incomingLinkQualitySlowLog)] = (uint8_t)Utils::countBits(fl);
-		}
-	}
-
-	/**
-	 * @return Link quality from 0 (min) to 255 (max)
-	 */
-	inline unsigned int linkQuality() const
-	{
-		unsigned long slsize = _incomingLinkQualitySlowLogPtr;
-		if (slsize > (unsigned long)sizeof(_incomingLinkQualitySlowLog))
-			slsize = (unsigned long)sizeof(_incomingLinkQualitySlowLog);
-		else if (!slsize)
-			return 255; // ZT_PATH_LINK_QUALITY_MAX
-		unsigned long lq = 0;
-		for(unsigned long i=0;i<slsize;++i)
-			lq += (unsigned long)_incomingLinkQualitySlowLog[i] * 4;
-		lq /= slsize;
-		return (unsigned int)((lq >= 255) ? 255 : lq);
-	}
-
-	/**
 	 * Set time last trusted packet was received (done in Peer::received())
 	 */
 	inline void trustedPacketReceived(const uint64_t t) { _lastTrustEstablishedPacketReceived = t; }
@@ -313,27 +266,14 @@ public:
 	 */
 	inline int64_t lastTrustEstablishedPacketReceived() const { return _lastTrustEstablishedPacketReceived; }
 
-	/**
-	 * Return and increment outgoing packet counter (used with Packet::armor())
-	 *
-	 * @return Next value that should be used for outgoing packet counter (only least significant 3 bits are used)
-	 */
-	inline unsigned int nextOutgoingCounter() { return _outgoingPacketCounter++; }
-
 private:
 	volatile int64_t _lastOut;
 	volatile int64_t _lastIn;
 	volatile int64_t _lastTrustEstablishedPacketReceived;
-	volatile uint64_t _incomingLinkQualityFastLog;
 	int64_t _localSocket;
-	volatile unsigned long _incomingLinkQualitySlowLogPtr;
-	volatile signed int _incomingLinkQualitySlowLogCounter;
-	volatile unsigned int _incomingLinkQualityPreviousPacketCounter;
-	volatile unsigned int _outgoingPacketCounter;
 	volatile unsigned int _latency;
 	InetAddress _addr;
 	InetAddress::IpScope _ipScope; // memoize this since it's a computed value checked often
-	volatile uint8_t _incomingLinkQualitySlowLog[32];
 	AtomicCounter __refCount;
 };
 
diff --git a/node/Peer.cpp b/node/Peer.cpp
index fceef94f..6e46089f 100644
--- a/node/Peer.cpp
+++ b/node/Peer.cpp
@@ -95,9 +95,6 @@ void Peer::received(
 		path->trustedPacketReceived(now);
 	}
 
-	if (_vProto >= 9)
-		path->updateLinkQuality((unsigned int)(packetId & 7));
-
 	if (hops == 0) {
 		// If this is a direct packet (no hops), update existing paths or learn new ones
 
@@ -161,7 +158,7 @@ void Peer::received(
 		}
 
 		if (attemptToContact) {
-			attemptToContactAt(tPtr,path->localSocket(),path->address(),now,true,path->nextOutgoingCounter());
+			attemptToContactAt(tPtr,path->localSocket(),path->address(),now,true);
 			path->sent(now);
 			RR->t->peerConfirmingUnknownPath(tPtr,networkId,*this,path,packetId,verb);
 		}
@@ -226,7 +223,7 @@ void Peer::received(
 
 					if (count) {
 						outp.setAt(ZT_PACKET_IDX_PAYLOAD,(uint16_t)count);
-						outp.armor(_key,true,path->nextOutgoingCounter());
+						outp.armor(_key,true);
 						path->send(RR,tPtr,outp.data(),outp.size(),now);
 					}
 				}
@@ -357,7 +354,7 @@ void Peer::introduce(void *const tPtr,const int64_t now,const SharedPtr<Peer> &o
 					outp.append((uint8_t)4);
 					outp.append(other->_paths[theirs].p->address().rawIpData(),4);
 				}
-				outp.armor(_key,true,_paths[mine].p->nextOutgoingCounter());
+				outp.armor(_key,true);
 				_paths[mine].p->send(RR,tPtr,outp.data(),outp.size(),now);
 			} else {
 				Packet outp(other->_id.address(),RR->identity.address(),Packet::VERB_RENDEZVOUS);
@@ -371,7 +368,7 @@ void Peer::introduce(void *const tPtr,const int64_t now,const SharedPtr<Peer> &o
 					outp.append((uint8_t)4);
 					outp.append(_paths[mine].p->address().rawIpData(),4);
 				}
-				outp.armor(other->_key,true,other->_paths[theirs].p->nextOutgoingCounter());
+				outp.armor(other->_key,true);
 				other->_paths[theirs].p->send(RR,tPtr,outp.data(),outp.size(),now);
 			}
 			++alt;
@@ -379,7 +376,7 @@ void Peer::introduce(void *const tPtr,const int64_t now,const SharedPtr<Peer> &o
 	}
 }
 
-void Peer::sendHELLO(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now,unsigned int counter)
+void Peer::sendHELLO(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now)
 {
 	Packet outp(_id.address(),RR->identity.address(),Packet::VERB_HELLO);
 
@@ -415,22 +412,22 @@ void Peer::sendHELLO(void *tPtr,const int64_t localSocket,const InetAddress &atA
 	RR->node->expectReplyTo(outp.packetId());
 
 	if (atAddress) {
-		outp.armor(_key,false,counter); // false == don't encrypt full payload, but add MAC
+		outp.armor(_key,false); // false == don't encrypt full payload, but add MAC
 		RR->node->putPacket(tPtr,localSocket,atAddress,outp.data(),outp.size());
 	} else {
 		RR->sw->send(tPtr,outp,false); // false == don't encrypt full payload, but add MAC
 	}
 }
 
-void Peer::attemptToContactAt(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now,bool sendFullHello,unsigned int counter)
+void Peer::attemptToContactAt(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now,bool sendFullHello)
 {
 	if ( (!sendFullHello) && (_vProto >= 5) && (!((_vMajor == 1)&&(_vMinor == 1)&&(_vRevision == 0))) ) {
 		Packet outp(_id.address(),RR->identity.address(),Packet::VERB_ECHO);
 		RR->node->expectReplyTo(outp.packetId());
-		outp.armor(_key,true,counter);
+		outp.armor(_key,true);
 		RR->node->putPacket(tPtr,localSocket,atAddress,outp.data(),outp.size());
 	} else {
-		sendHELLO(tPtr,localSocket,atAddress,now,counter);
+		sendHELLO(tPtr,localSocket,atAddress,now);
 	}
 }
 
@@ -440,7 +437,7 @@ void Peer::tryMemorizedPath(void *tPtr,int64_t now)
 		_lastTriedMemorizedPath = now;
 		InetAddress mp;
 		if (RR->node->externalPathLookup(tPtr,_id.address(),-1,mp))
-			attemptToContactAt(tPtr,-1,mp,now,true,0);
+			attemptToContactAt(tPtr,-1,mp,now,true);
 	}
 }
 
@@ -470,7 +467,7 @@ unsigned int Peer::doPingAndKeepalive(void *tPtr,int64_t now)
 			// Clean expired and reduced priority paths
 			if ( ((now - _paths[i].lr) < ZT_PEER_PATH_EXPIRATION) && (_paths[i].priority == maxPriority) ) {
 				if ((sendFullHello)||(_paths[i].p->needsHeartbeat(now))) {
-					attemptToContactAt(tPtr,_paths[i].p->localSocket(),_paths[i].p->address(),now,sendFullHello,_paths[i].p->nextOutgoingCounter());
+					attemptToContactAt(tPtr,_paths[i].p->localSocket(),_paths[i].p->address(),now,sendFullHello);
 					_paths[i].p->sent(now);
 					sent |= (_paths[i].p->address().ss_family == AF_INET) ? 0x1 : 0x2;
 				}
@@ -495,7 +492,7 @@ void Peer::clusterRedirect(void *tPtr,const SharedPtr<Path> &originatingPath,con
 	SharedPtr<Path> np(RR->topology->getPath(originatingPath->localSocket(),remoteAddress));
 	RR->t->peerRedirected(tPtr,0,*this,np);
 
-	attemptToContactAt(tPtr,originatingPath->localSocket(),remoteAddress,now,true,np->nextOutgoingCounter());
+	attemptToContactAt(tPtr,originatingPath->localSocket(),remoteAddress,now,true);
 
 	{
 		Mutex::Lock _l(_paths_m);
@@ -545,7 +542,7 @@ void Peer::resetWithinScope(void *tPtr,InetAddress::IpScope scope,int inetAddres
 	for(unsigned int i=0;i<ZT_MAX_PEER_NETWORK_PATHS;++i) {
 		if (_paths[i].p) {
 			if ((_paths[i].p->address().ss_family == inetAddressFamily)&&(_paths[i].p->ipScope() == scope)) {
-				attemptToContactAt(tPtr,_paths[i].p->localSocket(),_paths[i].p->address(),now,false,_paths[i].p->nextOutgoingCounter());
+				attemptToContactAt(tPtr,_paths[i].p->localSocket(),_paths[i].p->address(),now,false);
 				_paths[i].p->sent(now);
 				_paths[i].lr = 0; // path will not be used unless it speaks again
 			}
diff --git a/node/Peer.hpp b/node/Peer.hpp
index 53b916ab..99728736 100644
--- a/node/Peer.hpp
+++ b/node/Peer.hpp
@@ -175,9 +175,8 @@ public:
 	 * @param localSocket Local source socket
 	 * @param atAddress Destination address
 	 * @param now Current time
-	 * @param counter Outgoing packet counter
 	 */
-	void sendHELLO(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now,unsigned int counter);
+	void sendHELLO(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now);
 
 	/**
 	 * Send ECHO (or HELLO for older peers) to this peer at the given address
@@ -189,9 +188,8 @@ public:
 	 * @param atAddress Destination address
 	 * @param now Current time
 	 * @param sendFullHello If true, always send a full HELLO instead of just an ECHO
-	 * @param counter Outgoing packet counter
 	 */
-	void attemptToContactAt(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now,bool sendFullHello,unsigned int counter);
+	void attemptToContactAt(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now,bool sendFullHello);
 
 	/**
 	 * Try a memorized or statically defined path if any are known
@@ -480,7 +478,7 @@ public:
 				try {
 					ptr += inaddr.deserialize(b,ptr);
 					if (inaddr)
-						p->attemptToContactAt(tPtr,-1,inaddr,now,true,0);
+						p->attemptToContactAt(tPtr,-1,inaddr,now,true);
 				} catch ( ... ) {
 					break;
 				}
diff --git a/node/Switch.cpp b/node/Switch.cpp
index 1958c43e..b2cab1d0 100644
--- a/node/Switch.cpp
+++ b/node/Switch.cpp
@@ -78,7 +78,7 @@ void Switch::onRemotePacket(void *tPtr,const int64_t localSocket,const InetAddre
 				if ((now - _lastBeaconResponse) >= 2500) { // limit rate of responses
 					_lastBeaconResponse = now;
 					Packet outp(peer->address(),RR->identity.address(),Packet::VERB_NOP);
-					outp.armor(peer->key(),true,path->nextOutgoingCounter());
+					outp.armor(peer->key(),true);
 					path->send(RR,tPtr,outp.data(),outp.size(),now);
 				}
 			}
@@ -670,7 +670,7 @@ bool Switch::_trySend(void *tPtr,Packet &packet,bool encrypt)
 	if (trustedPathId) {
 		packet.setTrusted(trustedPathId);
 	} else {
-		packet.armor(peer->key(),encrypt,viaPath->nextOutgoingCounter());
+		packet.armor(peer->key(),encrypt);
 	}
 
 	if (viaPath->send(RR,tPtr,packet.data(),chunkSize,now)) {