Logic simplification, cleanup, and memory use improvements in Membership. Also fix an issue that may cause network instability in some cases.

controller/EmbeddedNetworkController.cpp

@@ -665,7 +665,7 @@ unsigned int EmbeddedNetworkController::handleControlPlaneHttpPOST(
 								// Member is being de-authorized, so spray Revocation objects to all online members
 								if (!newAuth) {
 									_clearNetworkMemberInfoCache(nwid);
-									Revocation rev(_node->prng(),nwid,0,now,ZT_REVOCATION_FLAG_FAST_PROPAGATE,Address(address),Revocation::CREDENTIAL_TYPE_COM);
+									Revocation rev((uint32_t)_node->prng(),nwid,0,now,ZT_REVOCATION_FLAG_FAST_PROPAGATE,Address(address),Revocation::CREDENTIAL_TYPE_COM);
 									rev.sign(_signingId);
 									Mutex::Lock _l(_lastRequestTime_m);
 									for(std::map< std::pair<uint64_t,uint64_t>,uint64_t >::iterator i(_lastRequestTime.begin());i!=_lastRequestTime.end();++i) {

node/Capability.hpp

@@ -24,6 +24,7 @@
 #include <string.h>
 
 #include "Constants.hpp"
+#include "Credential.hpp"
 #include "Address.hpp"
 #include "C25519.hpp"
 #include "Utils.hpp"
@@ -58,9 +59,11 @@ class RuntimeEnvironment;
  * handed off between nodes. Limited transferrability of capabilities is
  * a feature of true capability based security.
  */
-class Capability
+class Capability : public Credential
 {
 public:
+	static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_CAPABILITY; }
+
 	Capability()
 	{
 		memset(this,0,sizeof(Capability));

node/CertificateOfMembership.hpp

@@ -27,6 +27,7 @@
 #include <algorithm>
 
 #include "Constants.hpp"
+#include "Credential.hpp"
 #include "Buffer.hpp"
 #include "Address.hpp"
 #include "C25519.hpp"
@@ -68,9 +69,11 @@ class RuntimeEnvironment;
  * This is a memcpy()'able structure and is safe (in a crash sense) to modify
  * without locks.
  */
-class CertificateOfMembership
+class CertificateOfMembership : public Credential
 {
 public:
+	static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_COM; }
+
 	/**
 	 * Reserved qualifier IDs
 	 *
@@ -155,18 +158,23 @@ public:
 	/**
 	 * @return True if there's something here
 	 */
-	inline operator bool() const throw() { return (_qualifierCount != 0); }
+	inline operator bool() const { return (_qualifierCount != 0); }
+
+	/**
+	 * @return Credential ID, always 0 for COMs
+	 */
+	inline uint32_t id() const { return 0; }
 
 	/**
 	 * @return Timestamp for this cert and maximum delta for timestamp
 	 */
-	inline std::pair<uint64_t,uint64_t> timestamp() const
+	inline uint64_t timestamp() const
 	{
 		for(unsigned int i=0;i<_qualifierCount;++i) {
 			if (_qualifiers[i].id == COM_RESERVED_ID_TIMESTAMP)
-				return std::pair<uint64_t,uint64_t>(_qualifiers[i].value,_qualifiers[i].maxDelta);
+				return _qualifiers[i].value;
 		}
-		return std::pair<uint64_t,uint64_t>(0ULL,0ULL);
+		return 0;
 	}
 
 	/**
@@ -258,12 +266,12 @@ public:
 	/**
 	 * @return True if signed
 	 */
-	inline bool isSigned() const throw() { return (_signedBy); }
+	inline bool isSigned() const { return (_signedBy); }
 
 	/**
 	 * @return Address that signed this certificate or null address if none
 	 */
-	inline const Address &signedBy() const throw() { return _signedBy; }
+	inline const Address &signedBy() const { return _signedBy; }
 
 	template<unsigned int C>
 	inline void serialize(Buffer<C> &b) const
@@ -321,7 +329,6 @@ public:
 	}
 
 	inline bool operator==(const CertificateOfMembership &c) const
-		throw()
 	{
 		if (_signedBy != c._signedBy)
 			return false;
@@ -335,7 +342,7 @@ public:
 		}
 		return (_signature == c._signature);
 	}
-	inline bool operator!=(const CertificateOfMembership &c) const throw() { return (!(*this == c)); }
+	inline bool operator!=(const CertificateOfMembership &c) const { return (!(*this == c)); }
 
 private:
 	struct _Qualifier

node/CertificateOfOwnership.hpp

@@ -25,6 +25,7 @@
 #include <string.h>
 
 #include "Constants.hpp"
+#include "Credential.hpp"
 #include "C25519.hpp"
 #include "Address.hpp"
 #include "Identity.hpp"
@@ -45,9 +46,11 @@ class RuntimeEnvironment;
 /**
  * Certificate indicating ownership of a network identifier
  */
-class CertificateOfOwnership
+class CertificateOfOwnership : public Credential
 {
 public:
+	static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_COO; }
+
 	enum Thing
 	{
 		THING_NULL = 0,

node/CertificateOfRepresentation.hpp

@@ -20,6 +20,7 @@
 #define ZT_CERTIFICATEOFREPRESENTATION_HPP
 
 #include "Constants.hpp"
+#include "Credential.hpp"
 #include "Address.hpp"
 #include "C25519.hpp"
 #include "Identity.hpp"
@@ -47,14 +48,17 @@ namespace ZeroTier {
  * roots can shield nodes entirely and p2p connectivity behind them can
  * be disabled. This will be desirable for a number of use cases.
  */
-class CertificateOfRepresentation
+class CertificateOfRepresentation : public Credential
 {
 public:
+	static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_COR; }
+
 	CertificateOfRepresentation()
 	{
 		memset(this,0,sizeof(CertificateOfRepresentation));
 	}
 
+	inline uint32_t id() const { return 0; }
 	inline uint64_t timestamp() const { return _timestamp; }
 	inline const Address &representative(const unsigned int i) const { return _reps[i]; }
 	inline unsigned int repCount() const { return _repCount; }

node/Membership.cpp

@@ -39,6 +39,7 @@ Membership::Membership() :
 	_remoteCaps(4),
 	_remoteCoos(4)
 {
+	resetPushState();
 }
 
 void Membership::pushCredentials(const RuntimeEnvironment *RR,void *tPtr,const uint64_t now,const Address &peerAddress,const NetworkConfig &nconf,int localCapabilityIndex,const bool force)
@@ -48,18 +49,16 @@ void Membership::pushCredentials(const RuntimeEnvironment *RR,void *tPtr,const u
 	const Capability *sendCap;
 	if (localCapabilityIndex >= 0) {
 		sendCap = &(nconf.capabilities[localCapabilityIndex]);
-		if ( (_localCaps[localCapabilityIndex].id != sendCap->id()) || ((now - _localCaps[localCapabilityIndex].lastPushed) >= ZT_CREDENTIAL_PUSH_EVERY) || (force) ) {
+		if ( ((now - _localCredLastPushed.cap[localCapabilityIndex]) >= ZT_CREDENTIAL_PUSH_EVERY) || (force) )
-			_localCaps[localCapabilityIndex].lastPushed = now;
+			_localCredLastPushed.cap[localCapabilityIndex] = now;
-			_localCaps[localCapabilityIndex].id = sendCap->id();
+		else sendCap = (const Capability *)0;
-		} else sendCap = (const Capability *)0;
 	} else sendCap = (const Capability *)0;
 
 	const Tag *sendTags[ZT_MAX_NETWORK_TAGS];
 	unsigned int sendTagCount = 0;
 	for(unsigned int t=0;t<nconf.tagCount;++t) {
-		if ( (_localTags[t].id != nconf.tags[t].id()) || ((now - _localTags[t].lastPushed) >= ZT_CREDENTIAL_PUSH_EVERY) || (force) ) {
+		if ( ((now - _localCredLastPushed.tag[t]) >= ZT_CREDENTIAL_PUSH_EVERY) || (force) ) {
-			_localTags[t].lastPushed = now;
+			_localCredLastPushed.tag[t] = now;
-			_localTags[t].id = nconf.tags[t].id();
 			sendTags[sendTagCount++] = &(nconf.tags[t]);
 		}
 	}
@@ -67,9 +66,8 @@ void Membership::pushCredentials(const RuntimeEnvironment *RR,void *tPtr,const u
 	const CertificateOfOwnership *sendCoos[ZT_MAX_CERTIFICATES_OF_OWNERSHIP];
 	unsigned int sendCooCount = 0;
 	for(unsigned int c=0;c<nconf.certificateOfOwnershipCount;++c) {
-		if ( (_localCoos[c].id != nconf.certificatesOfOwnership[c].id()) || ((now - _localCoos[c].lastPushed) >= ZT_CREDENTIAL_PUSH_EVERY) || (force) ) {
+		if ( ((now - _localCredLastPushed.coo[c]) >= ZT_CREDENTIAL_PUSH_EVERY) || (force) ) {
-			_localCoos[c].lastPushed = now;
+			_localCredLastPushed.coo[c] = now;
-			_localCoos[c].id = nconf.certificatesOfOwnership[c].id();
 			sendCoos[sendCooCount++] = &(nconf.certificatesOfOwnership[c]);
 		}
 	}
@@ -149,7 +147,7 @@ Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironme
 	}
 }
 
-// Template out addCredential() for most cred types to avoid copypasta
+// Template out addCredential() for many cred types to avoid copypasta
 template<typename C>
 static Membership::AddCredentialResult _addCredImpl(Hashtable<uint32_t,C> &remoteCreds,const Hashtable<uint64_t,uint64_t> &revocations,const RuntimeEnvironment *RR,void *tPtr,const NetworkConfig &nconf,const C &cred)
 {
@@ -165,7 +163,7 @@ static Membership::AddCredentialResult _addCredImpl(Hashtable<uint32_t,C> &remot
 		}
 	}
 
-	const uint64_t *rt = revocations.get(Membership::revocationKey(C::credentialType(),cred.id()));
+	const uint64_t *const rt = revocations.get(Membership::credentialKey(C::credentialType(),cred.id()));
 	if ((rt)&&(*rt >= cred.timestamp())) {
 		TRACE("addCredential(type==%d) for %s on %.16llx REJECTED (timestamp below revocation threshold)",(int)C::credentialType(),cred.issuedTo().toString().c_str(),cred.networkId());
 		return Membership::ADD_REJECTED;
@@ -186,20 +184,9 @@ static Membership::AddCredentialResult _addCredImpl(Hashtable<uint32_t,C> &remot
 	}
 }
 
-Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironment *RR,void *tPtr,const NetworkConfig &nconf,const Tag &tag)
+Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironment *RR,void *tPtr,const NetworkConfig &nconf,const Tag &tag) { return _addCredImpl<Tag>(_remoteTags,_revocations,RR,tPtr,nconf,tag); }
-{
+Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironment *RR,void *tPtr,const NetworkConfig &nconf,const Capability &cap) { return _addCredImpl<Capability>(_remoteCaps,_revocations,RR,tPtr,nconf,cap); }
-	return _addCredImpl<Tag>(_remoteTags,_revocations,RR,tPtr,nconf,tag);
+Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironment *RR,void *tPtr,const NetworkConfig &nconf,const CertificateOfOwnership &coo) { return _addCredImpl<CertificateOfOwnership>(_remoteCoos,_revocations,RR,tPtr,nconf,coo); }
-}
-
-Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironment *RR,void *tPtr,const NetworkConfig &nconf,const Capability &cap)
-{
-	return _addCredImpl<Capability>(_remoteCaps,_revocations,RR,tPtr,nconf,cap);
-}
-
-Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironment *RR,void *tPtr,const NetworkConfig &nconf,const CertificateOfOwnership &coo)
-{
-	return _addCredImpl<CertificateOfOwnership>(_remoteCoos,_revocations,RR,tPtr,nconf,coo);
-}
 
 Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironment *RR,void *tPtr,const NetworkConfig &nconf,const Revocation &rev)
 {
@@ -219,7 +206,7 @@ Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironme
 				case Credential::CREDENTIAL_TYPE_CAPABILITY:
 				case Credential::CREDENTIAL_TYPE_TAG:
 				case Credential::CREDENTIAL_TYPE_COO:
-					rt = &(_revocations[revocationKey(ct,rev.credentialId())]);
+					rt = &(_revocations[credentialKey(ct,rev.credentialId())]);
 					if (*rt < rev.threshold()) {
 						*rt = rev.threshold();
 						return ADD_ACCEPTED_NEW;
@@ -234,4 +221,11 @@ Membership::AddCredentialResult Membership::addCredential(const RuntimeEnvironme
 	}
 }
 
+void Membership::clean(const uint64_t now,const NetworkConfig &nconf)
+{
+	_cleanCredImpl<Tag>(nconf,_remoteTags);
+	_cleanCredImpl<Capability>(nconf,_remoteCaps);
+	_cleanCredImpl<CertificateOfOwnership>(nconf,_remoteCoos);
+}
+
 } // namespace ZeroTier

node/Membership.hpp

@@ -47,23 +47,6 @@ class Network;
  */
 class Membership
 {
-private:
-	template<typename T>
-	struct _RemoteCredential
-	{
-		_RemoteCredential() : lastReceived(0),revocationThreshold(0),credential() {}
-		uint64_t lastReceived; // last time we got this credential
-		uint64_t revocationThreshold; // credentials before this time are invalid
-		T credential;
-	};
-
-	struct _LocalCredentialPushState
-	{
-		_LocalCredentialPushState() : lastPushed(0),id(0) {}
-		uint64_t lastPushed; // last time we sent our own copy of this credential
-		uint32_t id;
-	};
-
 public:
 	enum AddCredentialResult
 	{
@@ -92,19 +75,19 @@ public:
 	void pushCredentials(const RuntimeEnvironment *RR,void *tPtr,const uint64_t now,const Address &peerAddress,const NetworkConfig &nconf,int localCapabilityIndex,const bool force);
 
 	/**
-	 * Check whether we should push MULTICAST_LIKEs to this peer
+	 * Check whether we should push MULTICAST_LIKEs to this peer, and update last sent time if true
 	 *
 	 * @param now Current time
 	 * @return True if we should update multicasts
 	 */
-	inline bool shouldLikeMulticasts(const uint64_t now) const { return ((now - _lastUpdatedMulticast) >= ZT_MULTICAST_ANNOUNCE_PERIOD); }
+	inline bool multicastLikeGate(const uint64_t now)
-
+	{
-	/**
+		if ((now - _lastUpdatedMulticast) >= ZT_MULTICAST_ANNOUNCE_PERIOD) {
-	 * Set time we last updated multicasts for this peer
+			_lastUpdatedMulticast = now;
-	 *
+			return true;
-	 * @param now Current time
+		}
-	 */
+		return false;
-	inline void likingMulticasts(const uint64_t now) { _lastUpdatedMulticast = now; }
+	}
 
 	/**
 	 * Check whether the peer represented by this Membership should be allowed on this network at all
@@ -128,11 +111,11 @@ public:
 	 * @return True if this peer has a certificate of ownership for the given resource
 	 */
 	template<typename T>
-	inline bool hasCertificateOfOwnershipFor(const NetworkConfig &nconf,const T &r)
+	inline bool hasCertificateOfOwnershipFor(const NetworkConfig &nconf,const T &r) const
 	{
 		uint32_t *k = (uint32_t *)0;
 		CertificateOfOwnership *v = (CertificateOfOwnership *)0;
-		Hashtable< uint32_t,CertificateOfOwnership >::Iterator i(_remoteCoos);
+		Hashtable< uint32_t,CertificateOfOwnership >::Iterator i(*(const_cast< Hashtable< uint32_t,CertificateOfOwnership> *>(&_remoteCoos)));
 		while (i.next(k,v)) {
 			if (_isCredentialTimestampValid(nconf,*v)&&(v->owns(r)))
 				return true;
@@ -179,13 +162,28 @@ public:
 	AddCredentialResult addCredential(const RuntimeEnvironment *RR,void *tPtr,const NetworkConfig &nconf,const Revocation &rev);
 
 	/**
-	 * Generates a key for the internal revocation tracking hash table
+	 * Clean internal databases of stale entries
 	 *
-	 * @param t Credential type
+	 * @param now Current time
-	 * @param i Credential ID
+	 * @param nconf Current network configuration
-	 * @return Key for tracking revocations of this credential
 	 */
-	static uint64_t revocationKey(const Credential::Type &t,const uint32_t i) { return (((uint64_t)t << 32) | (uint64_t)i); }
+	void clean(const uint64_t now,const NetworkConfig &nconf);
+
+	/**
+	 * Reset last pushed time for local credentials
+	 *
+	 * This is done when we update our network configuration and our credentials have changed
+	 */
+	inline void resetPushState()
+	{
+		_lastPushedCom = 0;
+		memset(&_localCredLastPushed,0,sizeof(_localCredLastPushed));
+	}
+
+	/**
+	 * Generates a key for the internal use in indexing credentials by type and credential ID
+	 */
+	static uint64_t credentialKey(const Credential::Type &t,const uint32_t i) { return (((uint64_t)t << 32) | (uint64_t)i); }
 
 private:
 	template<typename C>
@@ -193,12 +191,24 @@ private:
 	{
 		const uint64_t ts = remoteCredential.timestamp();
 		if (((ts >= nconf.timestamp) ? (ts - nconf.timestamp) : (nconf.timestamp - ts)) <= nconf.credentialTimeMaxDelta) {
-			const uint64_t *threshold = _revocations.get(revocationKey(C::credentialType(),remoteCredential.id()));
+			const uint64_t *threshold = _revocations.get(credentialKey(C::credentialType(),remoteCredential.id()));
 			return ((!threshold)||(ts > *threshold));
 		}
 		return false;
 	}
 
+	template<typename C>
+	void _cleanCredImpl(const NetworkConfig &nconf,Hashtable<uint32_t,C> &remoteCreds)
+	{
+		uint32_t *k = (uint32_t *)0;
+		C *v = (C *)0;
+		typename Hashtable<uint32_t,C>::Iterator i(remoteCreds);
+		while (i.next(k,v)) {
+			if (!_isCredentialTimestampValid(nconf,*v))
+				remoteCreds.erase(*k);
+		}
+	}
+
 	// Last time we pushed MULTICAST_LIKE(s)
 	uint64_t _lastUpdatedMulticast;
 
@@ -211,18 +221,46 @@ private:
 	// Remote member's latest network COM
 	CertificateOfMembership _com;
 
-	// Revocations
+	// Revocations by credentialKey()
 	Hashtable< uint64_t,uint64_t > _revocations;
 
-	// Remote credentials and credential state
+	// Remote credentials that we have received from this member (and that are valid)
 	Hashtable< uint32_t,Tag > _remoteTags;
 	Hashtable< uint32_t,Capability > _remoteCaps;
 	Hashtable< uint32_t,CertificateOfOwnership > _remoteCoos;
 
-	// Local credential push state tracking
+	// Time we last pushed our local credentials to this member
-	_LocalCredentialPushState _localTags[ZT_MAX_NETWORK_TAGS];
+	struct {
-	_LocalCredentialPushState _localCaps[ZT_MAX_NETWORK_CAPABILITIES];
+		uint64_t tag[ZT_MAX_NETWORK_TAGS];
-	_LocalCredentialPushState _localCoos[ZT_MAX_CERTIFICATES_OF_OWNERSHIP];
+		uint64_t cap[ZT_MAX_NETWORK_CAPABILITIES];
+		uint64_t coo[ZT_MAX_CERTIFICATES_OF_OWNERSHIP];
+	} _localCredLastPushed;
+
+public:
+	class CapabilityIterator
+	{
+	public:
+		CapabilityIterator(Membership &m,const NetworkConfig &nconf) :
+			_hti(m._remoteCaps),
+			_k((uint32_t *)0),
+			_c((Capability *)0),
+			_nconf(nconf)
+		{
+		}
+
+		inline Capability *next()
+		{
+			if (_hti.next(_k,_c))
+				return _c;
+			else return (Capability *)0;
+		}
+
+	private:
+		Hashtable< uint32_t,Capability >::Iterator _hti;
+		uint32_t *_k;
+		Capability *_c;
+		const NetworkConfig &_nconf;
+	};
 };
 
 } // namespace ZeroTier

node/Network.cpp

@@ -534,9 +534,9 @@ static _doZtFilterResult _doZtFilter(
 					}
 					if (inbound) {
 						if (membership) {
-							if ((src)&&(membership->hasCertificateOfOwnershipFor(nconf,src)))
+							if ((src)&&(membership->hasCertificateOfOwnershipFor<InetAddress>(nconf,src)))
 								ownershipVerificationMask |= ZT_RULE_PACKET_CHARACTERISTICS_SENDER_IP_AUTHENTICATED;
-							if (membership->hasCertificateOfOwnershipFor(nconf,macSource))
+							if (membership->hasCertificateOfOwnershipFor<MAC>(nconf,macSource))
 								ownershipVerificationMask |= ZT_RULE_PACKET_CHARACTERISTICS_SENDER_MAC_AUTHENTICATED;
 						}
 					} else {
@@ -1143,21 +1143,31 @@ int Network::setConfiguration(void *tPtr,const NetworkConfig &nconf,bool saveToD
 	// _lock is NOT locked when this is called
 	try {
 		if ((nconf.issuedTo != RR->identity.address())||(nconf.networkId != _id))
-			return 0;
+			return 0; // invalid config that is not for us or not for this network
 		if (_config == nconf)
 			return 1; // OK config, but duplicate of what we already have
 
 		ZT_VirtualNetworkConfig ctmp;
 		bool oldPortInitialized;
-		{
+		{	// do things that require lock here, but unlock before calling callbacks
 			Mutex::Lock _l(_lock);
+
 			_config = nconf;
 			_lastConfigUpdate = RR->node->now();
 			_netconfFailure = NETCONF_FAILURE_NONE;
+
 			oldPortInitialized = _portInitialized;
 			_portInitialized = true;
+
 			_externalConfig(&ctmp);
+
+			Address *a = (Address *)0;
+			Membership *m = (Membership *)0;
+			Hashtable<Address,Membership>::Iterator i(_memberships);
+			while (i.next(a,m))
+				m->resetPushState();
 		}
+
 		_portError = RR->node->configureVirtualNetworkPort(tPtr,_id,&_uPtr,(oldPortInitialized) ? ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE : ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_UP,&ctmp);
 
 		if (saveToDisk) {
@@ -1299,10 +1309,9 @@ bool Network::gate(void *tPtr,const SharedPtr<Peer> &peer)
 			if ( (_config.isPublic()) || ((m)&&(m->isAllowedOnNetwork(_config))) ) {
 				if (!m)
 					m = &(_membership(peer->address()));
-				if (m->shouldLikeMulticasts(now)) {
+				if (m->multicastLikeGate(now)) {
 					m->pushCredentials(RR,tPtr,now,peer->address(),_config,-1,false);
 					_announceMulticastGroupsTo(tPtr,peer->address(),_allMulticastGroups());
-					m->likingMulticasts(now);
 				}
 				return true;
 			}
@@ -1338,6 +1347,7 @@ void Network::clean()
 		while (i.next(a,m)) {
 			if (!RR->topology->getPeerNoCache(*a))
 				_memberships.erase(*a);
+			else m->clean(now,_config);
 		}
 	}
 }
@@ -1546,8 +1556,7 @@ void Network::_sendUpdatesToMembers(void *tPtr,const MulticastGroup *const newMu
 	}
 
 	// Make sure that all "network anchors" have Membership records so we will
-	// push multicasts to them. Note that _membership() also does this but in a
+	// push multicasts to them.
-	// piecemeal on-demand fashion.
 	const std::vector<Address> anchors(_config.anchors());
 	for(std::vector<Address>::const_iterator a(anchors.begin());a!=anchors.end();++a)
 		_membership(*a);
@@ -1559,11 +1568,8 @@ void Network::_sendUpdatesToMembers(void *tPtr,const MulticastGroup *const newMu
 		Hashtable<Address,Membership>::Iterator i(_memberships);
 		while (i.next(a,m)) {
 			m->pushCredentials(RR,tPtr,now,*a,_config,-1,false);
-			if ( ((newMulticastGroup)||(m->shouldLikeMulticasts(now))) && (m->isAllowedOnNetwork(_config)) ) {
+			if ( ( m->multicastLikeGate(now) || (newMulticastGroup) ) && (m->isAllowedOnNetwork(_config)) )
-				if (!newMulticastGroup)
-					m->likingMulticasts(now);
 				_announceMulticastGroupsTo(tPtr,*a,groups);
-			}
 		}
 	}
 }

node/Revocation.hpp

@@ -26,6 +26,7 @@
 
 #include "Constants.hpp"
 #include "../include/ZeroTierOne.h"
+#include "Credential.hpp"
 #include "Address.hpp"
 #include "C25519.hpp"
 #include "Utils.hpp"
@@ -44,20 +45,10 @@ class RuntimeEnvironment;
 /**
  * Revocation certificate to instantaneously revoke a COM, capability, or tag
  */
-class Revocation
+class Revocation : public Credential
 {
 public:
-	/**
+	static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_REVOCATION; }
-	 * Credential type being revoked
-	 */
-	enum CredentialType
-	{
-		CREDENTIAL_TYPE_NULL = 0,
-		CREDENTIAL_TYPE_COM = 1, // CertificateOfMembership
-		CREDENTIAL_TYPE_CAPABILITY = 2,
-		CREDENTIAL_TYPE_TAG = 3,
-		CREDENTIAL_TYPE_COO = 4 // CertificateOfOwnership
-	};
 
 	Revocation()
 	{
@@ -73,23 +64,23 @@ public:
 	 * @param tgt Target node whose credential(s) are being revoked
 	 * @param ct Credential type being revoked
 	 */
-	Revocation(const uint64_t i,const uint64_t nwid,const uint64_t cid,const uint64_t thr,const uint64_t fl,const Address &tgt,const CredentialType ct) :
+	Revocation(const uint32_t i,const uint64_t nwid,const uint32_t cid,const uint64_t thr,const uint64_t fl,const Address &tgt,const Credential::Type ct) :
 		_id(i),
-		_networkId(nwid),
 		_credentialId(cid),
+		_networkId(nwid),
 		_threshold(thr),
 		_flags(fl),
 		_target(tgt),
 		_signedBy(),
 		_type(ct) {}
 
-	inline uint64_t id() const { return _id; }
+	inline uint32_t id() const { return _id; }
+	inline uint32_t credentialId() const { return _credentialId; }
 	inline uint64_t networkId() const { return _networkId; }
-	inline uint64_t credentialId() const { return _credentialId; }
 	inline uint64_t threshold() const { return _threshold; }
 	inline const Address &target() const { return _target; }
 	inline const Address &signer() const { return _signedBy; }
-	inline CredentialType type() const { return _type; }
+	inline Credential::Type type() const { return _type; }
 
 	inline bool fastPropagate() const { return ((_flags & ZT_REVOCATION_FLAG_FAST_PROPAGATE) != 0); }
 
@@ -123,8 +114,10 @@ public:
 	{
 		if (forSign) b.append((uint64_t)0x7f7f7f7f7f7f7f7fULL);
 
+		b.append((uint32_t)0); // 4 unused bytes, currently set to 0
 		b.append(_id);
 		b.append(_networkId);
+		b.append((uint32_t)0); // 4 unused bytes, currently set to 0
 		b.append(_credentialId);
 		b.append(_threshold);
 		b.append(_flags);
@@ -151,14 +144,16 @@ public:
 
 		unsigned int p = startAt;
 
-		_id = b.template at<uint64_t>(p); p += 8;
+		p += 4; // 4 bytes, currently unused
+		_id = b.template at<uint32_t>(p); p += 4;
 		_networkId = b.template at<uint64_t>(p); p += 8;
-		_credentialId = b.template at<uint64_t>(p); p += 8;
+		p += 4; // 4 bytes, currently unused
+		_credentialId = b.template at<uint32_t>(p); p += 4;
 		_threshold = b.template at<uint64_t>(p); p += 8;
 		_flags = b.template at<uint64_t>(p); p += 8;
 		_target.setTo(b.field(p,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); p += ZT_ADDRESS_LENGTH;
 		_signedBy.setTo(b.field(p,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); p += ZT_ADDRESS_LENGTH;
-		_type = (CredentialType)b[p++];
+		_type = (Credential::Type)b[p++];
 
 		if (b[p++] == 1) {
 			if (b.template at<uint16_t>(p) == ZT_C25519_SIGNATURE_LEN) {
@@ -178,14 +173,14 @@ public:
 	}
 
 private:
-	uint64_t _id;
+	uint32_t _id;
+	uint32_t _credentialId;
 	uint64_t _networkId;
-	uint64_t _credentialId;
 	uint64_t _threshold;
 	uint64_t _flags;
 	Address _target;
 	Address _signedBy;
-	CredentialType _type;
+	Credential::Type _type;
 	C25519::Signature _signature;
 };
 

node/Tag.hpp

@@ -25,6 +25,7 @@
 #include <string.h>
 
 #include "Constants.hpp"
+#include "Credential.hpp"
 #include "C25519.hpp"
 #include "Address.hpp"
 #include "Identity.hpp"
@@ -51,9 +52,11 @@ class RuntimeEnvironment;
  * Unlike capabilities tags are signed only by the issuer and are never
  * transferrable.
  */
-class Tag
+class Tag : public Credential
 {
 public:
+	static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_TAG; }
+
 	Tag()
 	{
 		memset(this,0,sizeof(Tag));
@@ -67,19 +70,19 @@ public:
 	 * @param value Tag value
 	 */
 	Tag(const uint64_t nwid,const uint64_t ts,const Address &issuedTo,const uint32_t id,const uint32_t value) :
-		_networkId(nwid),
-		_ts(ts),
 		_id(id),
 		_value(value),
+		_networkId(nwid),
+		_ts(ts),
 		_issuedTo(issuedTo),
 		_signedBy()
 	{
 	}
 
-	inline uint64_t networkId() const { return _networkId; }
-	inline uint64_t timestamp() const { return _ts; }
 	inline uint32_t id() const { return _id; }
 	inline const uint32_t &value() const { return _value; }
+	inline uint64_t networkId() const { return _networkId; }
+	inline uint64_t timestamp() const { return _ts; }
 	inline const Address &issuedTo() const { return _issuedTo; }
 	inline const Address &signedBy() const { return _signedBy; }
 
@@ -115,11 +118,9 @@ public:
 	{
 		if (forSign) b.append((uint64_t)0x7f7f7f7f7f7f7f7fULL);
 
-		// These are the same between Tag and Capability
 		b.append(_networkId);
 		b.append(_ts);
 		b.append(_id);
-
 		b.append(_value);
 
 		_issuedTo.appendTo(b);
@@ -187,10 +188,10 @@ public:
 	};
 
 private:
-	uint64_t _networkId;
-	uint64_t _ts;
 	uint32_t _id;
 	uint32_t _value;
+	uint64_t _networkId;
+	uint64_t _ts;
 	Address _issuedTo;
 	Address _signedBy;
 	C25519::Signature _signature;