Rename the ubiquitous _r pointer to RuntimeEnvironment to RR just to be a little more consistent about using _ to denote private member variables.

node/IncomingPacket.cpp

@@ -45,28 +45,28 @@
 
 namespace ZeroTier {
 
-bool IncomingPacket::tryDecode(const RuntimeEnvironment *_r)
+bool IncomingPacket::tryDecode(const RuntimeEnvironment *RR)
 {
 	if ((!encrypted())&&(verb() == Packet::VERB_HELLO)) {
 		// Unencrypted HELLOs are handled here since they are used to
 		// populate our identity cache in the first place. _doHELLO() is special
 		// in that it contains its own authentication logic.
 		//TRACE("<< HELLO from %s(%s) (normal unencrypted HELLO)",source().toString().c_str(),_remoteAddress.toString().c_str());
-		return _doHELLO(_r);
+		return _doHELLO(RR);
 	}
 
-	SharedPtr<Peer> peer = _r->topology->getPeer(source());
+	SharedPtr<Peer> peer = RR->topology->getPeer(source());
 	if (peer) {
 		// Resume saved intermediate decode state?
 		if (_step == DECODE_WAITING_FOR_MULTICAST_FRAME_ORIGINAL_SENDER_LOOKUP) {
 			// In this state we have already authenticated and decrypted the
 			// packet and are waiting for the lookup of the original sender
 			// for a multicast frame. So check to see if we've got it.
-			return _doMULTICAST_FRAME(_r,peer);
+			return _doP5_MULTICAST_FRAME(RR,peer);
 		} else if (_step == DECODE_WAITING_FOR_NETWORK_MEMBERSHIP_CERTIFICATE_SIGNER_LOOKUP) {
 			// In this state we have already authenticated and decoded the
 			// packet and we're waiting for the identity of the cert's signer.
-			return _doNETWORK_MEMBERSHIP_CERTIFICATE(_r,peer);
+			return _doNETWORK_MEMBERSHIP_CERTIFICATE(RR,peer);
 		} // else this is the initial decode pass, so validate packet et. al.
 
 		if (!dearmor(peer->key())) {
@@ -83,41 +83,41 @@ bool IncomingPacket::tryDecode(const RuntimeEnvironment *_r)
 		switch(verb()) {
 			//case Packet::VERB_NOP:
 			default: // ignore unknown verbs, but if they pass auth check they are still valid
-				peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),verb(),0,Packet::VERB_NOP,Utils::now());
+				peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),verb(),0,Packet::VERB_NOP,Utils::now());
 				return true;
 			case Packet::VERB_HELLO:
-				return _doHELLO(_r);
+				return _doHELLO(RR);
 			case Packet::VERB_ERROR:
-				return _doERROR(_r,peer);
+				return _doERROR(RR,peer);
 			case Packet::VERB_OK:
-				return _doOK(_r,peer);
+				return _doOK(RR,peer);
 			case Packet::VERB_WHOIS:
-				return _doWHOIS(_r,peer);
+				return _doWHOIS(RR,peer);
 			case Packet::VERB_RENDEZVOUS:
-				return _doRENDEZVOUS(_r,peer);
+				return _doRENDEZVOUS(RR,peer);
 			case Packet::VERB_FRAME:
-				return _doFRAME(_r,peer);
+				return _doFRAME(RR,peer);
 			case Packet::VERB_EXT_FRAME:
-				return _doEXT_FRAME(_r,peer);
+				return _doEXT_FRAME(RR,peer);
 			case Packet::VERB_P5_MULTICAST_FRAME:
-				return _doP5_MULTICAST_FRAME(_r,peer);
+				return _doP5_MULTICAST_FRAME(RR,peer);
 			case Packet::VERB_MULTICAST_LIKE:
-				return _doMULTICAST_LIKE(_r,peer);
+				return _doMULTICAST_LIKE(RR,peer);
 			case Packet::VERB_NETWORK_MEMBERSHIP_CERTIFICATE:
-				return _doNETWORK_MEMBERSHIP_CERTIFICATE(_r,peer);
+				return _doNETWORK_MEMBERSHIP_CERTIFICATE(RR,peer);
 			case Packet::VERB_NETWORK_CONFIG_REQUEST:
-				return _doNETWORK_CONFIG_REQUEST(_r,peer);
+				return _doNETWORK_CONFIG_REQUEST(RR,peer);
 			case Packet::VERB_NETWORK_CONFIG_REFRESH:
-				return _doNETWORK_CONFIG_REFRESH(_r,peer);
+				return _doNETWORK_CONFIG_REFRESH(RR,peer);
 		}
 	} else {
 		_step = DECODE_WAITING_FOR_SENDER_LOOKUP; // should already be this...
-		_r->sw->requestWhois(source());
+		RR->sw->requestWhois(source());
 		return false;
 	}
 }
 
-bool IncomingPacket::_doERROR(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doERROR(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
 		Packet::Verb inReVerb = (Packet::Verb)(*this)[ZT_PROTO_VERB_ERROR_IDX_IN_RE_VERB];
@@ -129,25 +129,25 @@ bool IncomingPacket::_doERROR(const RuntimeEnvironment *_r,const SharedPtr<Peer>
 		switch(errorCode) {
 			case Packet::ERROR_OBJ_NOT_FOUND:
 				if (inReVerb == Packet::VERB_WHOIS) {
-					if (_r->topology->isSupernode(source()))
-						_r->sw->cancelWhoisRequest(Address(field(ZT_PROTO_VERB_ERROR_IDX_PAYLOAD,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH));
+					if (RR->topology->isSupernode(source()))
+						RR->sw->cancelWhoisRequest(Address(field(ZT_PROTO_VERB_ERROR_IDX_PAYLOAD,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH));
 				} else if (inReVerb == Packet::VERB_NETWORK_CONFIG_REQUEST) {
-					SharedPtr<Network> network(_r->nc->network(at<uint64_t>(ZT_PROTO_VERB_ERROR_IDX_PAYLOAD)));
+					SharedPtr<Network> network(RR->nc->network(at<uint64_t>(ZT_PROTO_VERB_ERROR_IDX_PAYLOAD)));
 					if ((network)&&(network->controller() == source()))
 						network->setNotFound();
 				}
 				break;
 			case Packet::ERROR_IDENTITY_COLLISION:
 				// TODO: if it comes from a supernode, regenerate a new identity
-				// if (_r->topology->isSupernode(source())) {}
+				// if (RR->topology->isSupernode(source())) {}
 				break;
 			case Packet::ERROR_NEED_MEMBERSHIP_CERTIFICATE: {
-				SharedPtr<Network> network(_r->nc->network(at<uint64_t>(ZT_PROTO_VERB_ERROR_IDX_PAYLOAD)));
+				SharedPtr<Network> network(RR->nc->network(at<uint64_t>(ZT_PROTO_VERB_ERROR_IDX_PAYLOAD)));
 				if (network)
 					network->pushMembershipCertificate(source(),true,Utils::now());
 			}	break;
 			case Packet::ERROR_NETWORK_ACCESS_DENIED_: {
-				SharedPtr<Network> network(_r->nc->network(at<uint64_t>(ZT_PROTO_VERB_ERROR_IDX_PAYLOAD)));
+				SharedPtr<Network> network(RR->nc->network(at<uint64_t>(ZT_PROTO_VERB_ERROR_IDX_PAYLOAD)));
 				if ((network)&&(network->controller() == source()))
 					network->setAccessDenied();
 			}	break;
@@ -155,7 +155,7 @@ bool IncomingPacket::_doERROR(const RuntimeEnvironment *_r,const SharedPtr<Peer>
 				break;
 		}
 
-		peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_ERROR,inRePacketId,inReVerb,Utils::now());
+		peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_ERROR,inRePacketId,inReVerb,Utils::now());
 	} catch (std::exception &ex) {
 		TRACE("dropped ERROR from %s(%s): unexpected exception: %s",source().toString().c_str(),_remoteAddress.toString().c_str(),ex.what());
 	} catch ( ... ) {
@@ -164,7 +164,7 @@ bool IncomingPacket::_doERROR(const RuntimeEnvironment *_r,const SharedPtr<Peer>
 	return true;
 }
 
-bool IncomingPacket::_doHELLO(const RuntimeEnvironment *_r)
+bool IncomingPacket::_doHELLO(const RuntimeEnvironment *RR)
 {
 	try {
 		unsigned int protoVersion = (*this)[ZT_PROTO_VERB_HELLO_IDX_PROTOCOL_VERSION];
@@ -184,17 +184,17 @@ bool IncomingPacket::_doHELLO(const RuntimeEnvironment *_r)
 		}
 
 		// Do we already have this peer?
-		SharedPtr<Peer> peer(_r->topology->getPeer(id.address()));
+		SharedPtr<Peer> peer(RR->topology->getPeer(id.address()));
 		if (peer) {
 			// Check to make sure this isn't a colliding identity (different key,
 			// but same address). The odds are spectacularly low but it could happen.
 			// Could also be a sign of someone doing something nasty.
 			if (peer->identity() != id) {
 				unsigned char key[ZT_PEER_SECRET_KEY_LENGTH];
-				if (_r->identity.agree(id,key,ZT_PEER_SECRET_KEY_LENGTH)) {
+				if (RR->identity.agree(id,key,ZT_PEER_SECRET_KEY_LENGTH)) {
 					if (dearmor(key)) { // ensure packet is authentic, otherwise drop
 						LOG("rejected HELLO from %s(%s): address already claimed",source().toString().c_str(),_remoteAddress.toString().c_str());
-						Packet outp(source(),_r->identity.address(),Packet::VERB_ERROR);
+						Packet outp(source(),RR->identity.address(),Packet::VERB_ERROR);
 						outp.append((unsigned char)Packet::VERB_HELLO);
 						outp.append(packetId());
 						outp.append((unsigned char)Packet::ERROR_IDENTITY_COLLISION);
@@ -215,13 +215,13 @@ bool IncomingPacket::_doHELLO(const RuntimeEnvironment *_r)
 			// If we don't have a peer record on file, check the identity cache (if
 			// we have one) to see if we have a cached identity. Then check that for
 			// collision before adding a new peer.
-			Identity alreadyHaveCachedId(_r->topology->getIdentity(id.address()));
+			Identity alreadyHaveCachedId(RR->topology->getIdentity(id.address()));
 			if ((alreadyHaveCachedId)&&(id != alreadyHaveCachedId)) {
 				unsigned char key[ZT_PEER_SECRET_KEY_LENGTH];
-				if (_r->identity.agree(id,key,ZT_PEER_SECRET_KEY_LENGTH)) {
+				if (RR->identity.agree(id,key,ZT_PEER_SECRET_KEY_LENGTH)) {
 					if (dearmor(key)) { // ensure packet is authentic, otherwise drop
 						LOG("rejected HELLO from %s(%s): address already claimed",source().toString().c_str(),_remoteAddress.toString().c_str());
-						Packet outp(source(),_r->identity.address(),Packet::VERB_ERROR);
+						Packet outp(source(),RR->identity.address(),Packet::VERB_ERROR);
 						outp.append((unsigned char)Packet::VERB_HELLO);
 						outp.append(packetId());
 						outp.append((unsigned char)Packet::ERROR_IDENTITY_COLLISION);
@@ -237,23 +237,23 @@ bool IncomingPacket::_doHELLO(const RuntimeEnvironment *_r)
 			} // else continue since identity is already known and matches
 
 			// If this is a new peer, learn it
-			SharedPtr<Peer> newPeer(new Peer(_r->identity,id));
+			SharedPtr<Peer> newPeer(new Peer(RR->identity,id));
 			if (!dearmor(newPeer->key())) {
 				LOG("rejected HELLO from %s(%s): packet failed authentication",source().toString().c_str(),_remoteAddress.toString().c_str());
 				return true;
 			}
-			peer = _r->topology->addPeer(newPeer);
+			peer = RR->topology->addPeer(newPeer);
 		}
 
-		peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_HELLO,0,Packet::VERB_NOP,Utils::now());
+		peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_HELLO,0,Packet::VERB_NOP,Utils::now());
 		peer->setRemoteVersion(vMajor,vMinor,vRevision);
 
 		// If a supernode has a version higher than ours, this causes a software
 		// update check to run now.
-		if ((_r->updater)&&(_r->topology->isSupernode(peer->address())))
-			_r->updater->sawRemoteVersion(vMajor,vMinor,vRevision);
+		if ((RR->updater)&&(RR->topology->isSupernode(peer->address())))
+			RR->updater->sawRemoteVersion(vMajor,vMinor,vRevision);
 
-		Packet outp(source(),_r->identity.address(),Packet::VERB_OK);
+		Packet outp(source(),RR->identity.address(),Packet::VERB_OK);
 		outp.append((unsigned char)Packet::VERB_HELLO);
 		outp.append(packetId());
 		outp.append(timestamp);
@@ -271,7 +271,7 @@ bool IncomingPacket::_doHELLO(const RuntimeEnvironment *_r)
 	return true;
 }
 
-bool IncomingPacket::_doOK(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doOK(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
 		Packet::Verb inReVerb = (Packet::Verb)(*this)[ZT_PROTO_VERB_OK_IDX_IN_RE_VERB];
@@ -293,21 +293,21 @@ bool IncomingPacket::_doOK(const RuntimeEnvironment *_r,const SharedPtr<Peer> &p
 				// update check to run now. This might bum-rush download.zerotier.com, but
 				// it's hosted on S3 so hopefully it can take it. This should cause updates
 				// to propagate out very quickly.
-				if ((_r->updater)&&(_r->topology->isSupernode(peer->address())))
-					_r->updater->sawRemoteVersion(vMajor,vMinor,vRevision);
+				if ((RR->updater)&&(RR->topology->isSupernode(peer->address())))
+					RR->updater->sawRemoteVersion(vMajor,vMinor,vRevision);
 			}	break;
 			case Packet::VERB_WHOIS: {
 				// Right now only supernodes are allowed to send OK(WHOIS) to prevent
 				// poisoning attacks. Further decentralization will require some other
 				// kind of trust mechanism.
-				if (_r->topology->isSupernode(source())) {
+				if (RR->topology->isSupernode(source())) {
 					Identity id(*this,ZT_PROTO_VERB_WHOIS__OK__IDX_IDENTITY);
 					if (id.locallyValidate())
-						_r->sw->doAnythingWaitingForPeer(_r->topology->addPeer(SharedPtr<Peer>(new Peer(_r->identity,id))));
+						RR->sw->doAnythingWaitingForPeer(RR->topology->addPeer(SharedPtr<Peer>(new Peer(RR->identity,id))));
 				}
 			} break;
 			case Packet::VERB_NETWORK_CONFIG_REQUEST: {
-				SharedPtr<Network> nw(_r->nc->network(at<uint64_t>(ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST__OK__IDX_NETWORK_ID)));
+				SharedPtr<Network> nw(RR->nc->network(at<uint64_t>(ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST__OK__IDX_NETWORK_ID)));
 				if ((nw)&&(nw->controller() == source())) {
 					// OK(NETWORK_CONFIG_REQUEST) is only accepted from a network's
 					// controller.
@@ -323,7 +323,7 @@ bool IncomingPacket::_doOK(const RuntimeEnvironment *_r,const SharedPtr<Peer> &p
 				break;
 		}
 
-		peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_OK,inRePacketId,inReVerb,Utils::now());
+		peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_OK,inRePacketId,inReVerb,Utils::now());
 	} catch (std::exception &ex) {
 		TRACE("dropped OK from %s(%s): unexpected exception: %s",source().toString().c_str(),_remoteAddress.toString().c_str(),ex.what());
 	} catch ( ... ) {
@@ -332,13 +332,13 @@ bool IncomingPacket::_doOK(const RuntimeEnvironment *_r,const SharedPtr<Peer> &p
 	return true;
 }
 
-bool IncomingPacket::_doWHOIS(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doWHOIS(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
 		if (payloadLength() == ZT_ADDRESS_LENGTH) {
-			Identity id(_r->topology->getIdentity(Address(payload(),ZT_ADDRESS_LENGTH)));
+			Identity id(RR->topology->getIdentity(Address(payload(),ZT_ADDRESS_LENGTH)));
 			if (id) {
-				Packet outp(source(),_r->identity.address(),Packet::VERB_OK);
+				Packet outp(source(),RR->identity.address(),Packet::VERB_OK);
 				outp.append((unsigned char)Packet::VERB_WHOIS);
 				outp.append(packetId());
 				id.serialize(outp,false);
@@ -346,7 +346,7 @@ bool IncomingPacket::_doWHOIS(const RuntimeEnvironment *_r,const SharedPtr<Peer>
 				_fromSock->send(_remoteAddress,outp.data(),outp.size());
 				//TRACE("sent WHOIS response to %s for %s",source().toString().c_str(),Address(payload(),ZT_ADDRESS_LENGTH).toString().c_str());
 			} else {
-				Packet outp(source(),_r->identity.address(),Packet::VERB_ERROR);
+				Packet outp(source(),RR->identity.address(),Packet::VERB_ERROR);
 				outp.append((unsigned char)Packet::VERB_WHOIS);
 				outp.append(packetId());
 				outp.append((unsigned char)Packet::ERROR_OBJ_NOT_FOUND);
@@ -359,14 +359,14 @@ bool IncomingPacket::_doWHOIS(const RuntimeEnvironment *_r,const SharedPtr<Peer>
 			TRACE("dropped WHOIS from %s(%s): missing or invalid address",source().toString().c_str(),_remoteAddress.toString().c_str());
 		}
 
-		peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_WHOIS,0,Packet::VERB_NOP,Utils::now());
+		peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_WHOIS,0,Packet::VERB_NOP,Utils::now());
 	} catch ( ... ) {
 		TRACE("dropped WHOIS from %s(%s): unexpected exception",source().toString().c_str(),_remoteAddress.toString().c_str());
 	}
 	return true;
 }
 
-bool IncomingPacket::_doRENDEZVOUS(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doRENDEZVOUS(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
 		/*
@@ -382,17 +382,17 @@ bool IncomingPacket::_doRENDEZVOUS(const RuntimeEnvironment *_r,const SharedPtr<
 		 * So if we diversify relays, we'll need some way of deciding whether the
 		 * sender is someone we should trust with a RENDEZVOUS hint.
 		 */
-		if (_r->topology->isSupernode(source())) {
+		if (RR->topology->isSupernode(source())) {
 			Address with(field(ZT_PROTO_VERB_RENDEZVOUS_IDX_ZTADDRESS,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH);
-			SharedPtr<Peer> withPeer(_r->topology->getPeer(with));
+			SharedPtr<Peer> withPeer(RR->topology->getPeer(with));
 			if (withPeer) {
 				unsigned int port = at<uint16_t>(ZT_PROTO_VERB_RENDEZVOUS_IDX_PORT);
 				unsigned int addrlen = (*this)[ZT_PROTO_VERB_RENDEZVOUS_IDX_ADDRLEN];
 				if ((port > 0)&&((addrlen == 4)||(addrlen == 16))) {
 					InetAddress atAddr(field(ZT_PROTO_VERB_RENDEZVOUS_IDX_ADDRESS,addrlen),addrlen,port);
 					TRACE("RENDEZVOUS from %s says %s might be at %s, starting NAT-t",source().toString().c_str(),with.toString().c_str(),atAddr.toString().c_str());
-					peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_RENDEZVOUS,0,Packet::VERB_NOP,Utils::now());
-					_r->sw->contact(withPeer,atAddr);
+					peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_RENDEZVOUS,0,Packet::VERB_NOP,Utils::now());
+					RR->sw->contact(withPeer,atAddr);
 				} else {
 					TRACE("dropped corrupt RENDEZVOUS from %s(%s) (bad address or port)",source().toString().c_str(),_remoteAddress.toString().c_str());
 				}
@@ -410,15 +410,15 @@ bool IncomingPacket::_doRENDEZVOUS(const RuntimeEnvironment *_r,const SharedPtr<
 	return true;
 }
 
-bool IncomingPacket::_doFRAME(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doFRAME(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
-		SharedPtr<Network> network(_r->nc->network(at<uint64_t>(ZT_PROTO_VERB_FRAME_IDX_NETWORK_ID)));
+		SharedPtr<Network> network(RR->nc->network(at<uint64_t>(ZT_PROTO_VERB_FRAME_IDX_NETWORK_ID)));
 		if (network) {
 			if (size() > ZT_PROTO_VERB_FRAME_IDX_PAYLOAD) {
 				if (!network->isAllowed(peer->address())) {
 					TRACE("dropped FRAME from %s(%s): not a member of private network %.16llx",peer->address().toString().c_str(),_remoteAddress.toString().c_str(),(unsigned long long)network->id());
-					_sendErrorNeedCertificate(_r,peer,network->id());
+					_sendErrorNeedCertificate(RR,peer,network->id());
 					return true;
 				}
 
@@ -433,9 +433,9 @@ bool IncomingPacket::_doFRAME(const RuntimeEnvironment *_r,const SharedPtr<Peer>
 				/* Source moves "closer" to us in multicast propagation priority when
 				 * we receive unicast frames from it. This is called "implicit social
 				 * ordering" in other docs. */
-				_r->mc->bringCloser(network->id(),peer->address());
+				RR->mc->bringCloser(network->id(),peer->address());
 
-				peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_FRAME,0,Packet::VERB_NOP,Utils::now());
+				peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_FRAME,0,Packet::VERB_NOP,Utils::now());
 				return true;
 			}
 		} else {
@@ -449,10 +449,10 @@ bool IncomingPacket::_doFRAME(const RuntimeEnvironment *_r,const SharedPtr<Peer>
 	return true;
 }
 
-bool IncomingPacket::_doEXT_FRAME(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doEXT_FRAME(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
-		SharedPtr<Network> network(_r->nc->network(at<uint64_t>(ZT_PROTO_VERB_EXT_FRAME_IDX_NETWORK_ID)));
+		SharedPtr<Network> network(RR->nc->network(at<uint64_t>(ZT_PROTO_VERB_EXT_FRAME_IDX_NETWORK_ID)));
 		if (network) {
 			if (size() > ZT_PROTO_VERB_EXT_FRAME_IDX_PAYLOAD) {
 				if ((*this)[ZT_PROTO_VERB_EXT_FRAME_IDX_FLAGS] != 0) {
@@ -462,7 +462,7 @@ bool IncomingPacket::_doEXT_FRAME(const RuntimeEnvironment *_r,const SharedPtr<P
 
 				if (!network->isAllowed(peer->address())) {
 					TRACE("dropped EXT_FRAME from %s(%s): not a member of private network %.16llx",peer->address().toString().c_str(),_remoteAddress.toString().c_str(),network->id());
-					_sendErrorNeedCertificate(_r,peer,network->id());
+					_sendErrorNeedCertificate(RR,peer,network->id());
 					return true;
 				}
 
@@ -492,7 +492,7 @@ bool IncomingPacket::_doEXT_FRAME(const RuntimeEnvironment *_r,const SharedPtr<P
 
 				// If it's not to us, we must be allowed to bridge into this network
 				if (to != network->mac()) {
-					if (!network->permitsBridging(_r->identity.address())) {
+					if (!network->permitsBridging(RR->identity.address())) {
 						TRACE("dropped EXT_FRAME from %s@%s(%s) to %s: I cannot bridge to %.16llx or bridging disabled on network",from.toString().c_str(),peer->address().toString().c_str(),_remoteAddress.toString().c_str(),to.toString().c_str(),network->id());
 						return true;
 					}
@@ -503,9 +503,9 @@ bool IncomingPacket::_doEXT_FRAME(const RuntimeEnvironment *_r,const SharedPtr<P
 				/* Source moves "closer" to us in multicast propagation priority when
 				 * we receive unicast frames from it. This is called "implicit social
 				 * ordering" in other docs. */
-				_r->mc->bringCloser(network->id(),peer->address());
+				RR->mc->bringCloser(network->id(),peer->address());
 
-				peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_EXT_FRAME,0,Packet::VERB_NOP,Utils::now());
+				peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_EXT_FRAME,0,Packet::VERB_NOP,Utils::now());
 			}
 		} else {
 			TRACE("dropped EXT_FRAME from %s(%s): we are not connected to network %.16llx",source().toString().c_str(),_remoteAddress.toString().c_str(),at<uint64_t>(ZT_PROTO_VERB_FRAME_IDX_NETWORK_ID));
@@ -518,14 +518,14 @@ bool IncomingPacket::_doEXT_FRAME(const RuntimeEnvironment *_r,const SharedPtr<P
 	return true;
 }
 
-bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
 		Address origin(Address(field(ZT_PROTO_VERB_MULTICAST_FRAME_IDX_ORIGIN,ZT_PROTO_VERB_MULTICAST_FRAME_LEN_ORIGIN),ZT_ADDRESS_LENGTH));
-		SharedPtr<Peer> originPeer(_r->topology->getPeer(origin));
+		SharedPtr<Peer> originPeer(RR->topology->getPeer(origin));
 		if (!originPeer) {
 			// We must have the origin's identity in order to authenticate a multicast
-			_r->sw->requestWhois(origin);
+			RR->sw->requestWhois(origin);
 			_step = DECODE_WAITING_FOR_MULTICAST_FRAME_ORIGINAL_SENDER_LOOKUP; // causes processing to come back here
 			return false;
 		}
@@ -555,7 +555,7 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const Share
 			return true;
 		}
 
-		SharedPtr<Network> network(_r->nc->network(nwid));
+		SharedPtr<Network> network(RR->nc->network(nwid));
 		SharedPtr<NetworkConfig> nconf;
 		if (network)
 			nconf = network->config2();
@@ -571,12 +571,12 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const Share
 			CertificateOfMembership originCom(*this,ZT_PROTO_VERB_MULTICAST_FRAME_IDX_FRAME + frameLen + 2 + signatureLen);
 			Address comSignedBy(originCom.signedBy());
 			if ((originCom.networkId() == nwid)&&(comSignedBy == network->controller())) {
-				SharedPtr<Peer> comSigningPeer(_r->topology->getPeer(comSignedBy));
+				SharedPtr<Peer> comSigningPeer(RR->topology->getPeer(comSignedBy));
 				if (!comSigningPeer) {
 					// Technically this should never happen because the COM should be signed by
 					// the master for this network (in current usage) and we ought to already have
 					// that cached. But handle it anyway.
-					_r->sw->requestWhois(comSignedBy);
+					RR->sw->requestWhois(comSignedBy);
 					_step = DECODE_WAITING_FOR_MULTICAST_FRAME_ORIGINAL_SENDER_LOOKUP; // causes processing to come back here
 					return false;
 				} else if (originCom.verify(comSigningPeer->identity())) {
@@ -614,16 +614,16 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const Share
 		}
 
 		// At this point the frame is basically valid, so we can call it a receive
-		peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_MULTICAST_FRAME,0,Packet::VERB_NOP,Utils::now());
+		peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_MULTICAST_FRAME,0,Packet::VERB_NOP,Utils::now());
 
 		// This gets updated later in most cases but start with the global limit.
 		unsigned int maxDepth = ZT_MULTICAST_GLOBAL_MAX_DEPTH;
 
-		if ((origin == _r->identity.address())||(_r->mc->deduplicate(nwid,guid))) {
+		if ((origin == RR->identity.address())||(RR->mc->deduplicate(nwid,guid))) {
 			// This is a boomerang or a duplicate of a multicast we've already seen. Ordinary
 			// nodes drop these, while supernodes will keep propagating them since they can
 			// act as bridges between sparse multicast networks more than once.
-			if (!_r->topology->amSupernode()) {
+			if (!RR->topology->amSupernode()) {
 				TRACE("dropped MULTICAST_FRAME from %s(%s): duplicate",source().toString().c_str(),_remoteAddress.toString().c_str());
 				return true;
 			}
@@ -640,7 +640,7 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const Share
 
 				if (!network->isAllowed(origin)) {
 					// Papers, please...
-					Packet outp(source(),_r->identity.address(),Packet::VERB_ERROR);
+					Packet outp(source(),RR->identity.address(),Packet::VERB_ERROR);
 					outp.append((unsigned char)Packet::VERB_MULTICAST_FRAME);
 					outp.append(packetId());
 					outp.append((unsigned char)Packet::ERROR_NEED_MEMBERSHIP_CERTIFICATE);
@@ -720,7 +720,7 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const Share
 			origin,
 			prefixBits,
 			prefix,
-			_r->topology,
+			RR->topology,
 			Utils::now());
 		if (nconf) {
 			for(std::set<Address>::const_iterator ab(nconf->activeBridges().begin());ab!=nconf->activeBridges().end();++ab) {
@@ -728,7 +728,7 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const Share
 					break;
 			}
 		}
-		_r->mc->getNextHops(nwid,dest,appender);
+		RR->mc->getNextHops(nwid,dest,appender);
 
 		// Zero-terminate new FIFO if not completely full. We pad the remainder with
 		// zeroes because this improves data compression ratios.
@@ -737,12 +737,12 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const Share
 
 		// First element in newFifo[] is next hop
 		Address nextHop(newFifo,ZT_ADDRESS_LENGTH);
-		if ((!nextHop)&&(!_r->topology->amSupernode())) {
-			SharedPtr<Peer> supernode(_r->topology->getBestSupernode(&origin,1,true));
+		if ((!nextHop)&&(!RR->topology->amSupernode())) {
+			SharedPtr<Peer> supernode(RR->topology->getBestSupernode(&origin,1,true));
 			if (supernode)
 				nextHop = supernode->address();
 		}
-		if ((!nextHop)||(nextHop == _r->identity.address())) { // check against our addr is a sanity check
+		if ((!nextHop)||(nextHop == RR->identity.address())) { // check against our addr is a sanity check
 			//TRACE("not forwarding MULTICAST_FRAME from %s(%s): no next hop",source().toString().c_str(),_remoteAddress.toString().c_str());
 			return true;
 		}
@@ -753,9 +753,9 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const Share
 		// Send to next hop, reusing this packet as scratch space
 		newInitializationVector();
 		setDestination(nextHop);
-		setSource(_r->identity.address());
+		setSource(RR->identity.address());
 		compress(); // note: bloom filters and empty FIFOs are highly compressable!
-		_r->sw->send(*this,true);
+		RR->sw->send(*this,true);
 
 		return true;
 	} catch (std::exception &ex) {
@@ -767,7 +767,7 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *_r,const Share
 	return true;
 }
 
-bool IncomingPacket::_doMULTICAST_LIKE(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doMULTICAST_LIKE(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
 		Address src(source());
@@ -776,15 +776,15 @@ bool IncomingPacket::_doMULTICAST_LIKE(const RuntimeEnvironment *_r,const Shared
 		// Iterate through 18-byte network,MAC,ADI tuples
 		for(unsigned int ptr=ZT_PACKET_IDX_PAYLOAD;ptr<size();ptr+=18) {
 			uint64_t nwid = at<uint64_t>(ptr);
-			SharedPtr<Network> network(_r->nc->network(nwid));
-			if ((_r->topology->amSupernode())||((network)&&(network->isAllowed(peer->address())))) {
-				_r->mc->likesGroup(nwid,src,MulticastGroup(MAC(field(ptr + 8,6),6),at<uint32_t>(ptr + 14)),now);
+			SharedPtr<Network> network(RR->nc->network(nwid));
+			if ((RR->topology->amSupernode())||((network)&&(network->isAllowed(peer->address())))) {
+				RR->mc->likesGroup(nwid,src,MulticastGroup(MAC(field(ptr + 8,6),6),at<uint32_t>(ptr + 14)),now);
 				if (network)
 					network->pushMembershipCertificate(peer->address(),false,now);
 			}
 		}
 
-		peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_MULTICAST_LIKE,0,Packet::VERB_NOP,now);
+		peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_MULTICAST_LIKE,0,Packet::VERB_NOP,now);
 	} catch (std::exception &ex) {
 		TRACE("dropped MULTICAST_LIKE from %s(%s): unexpected exception: %s",source().toString().c_str(),_remoteAddress.toString().c_str(),ex.what());
 	} catch ( ... ) {
@@ -793,7 +793,7 @@ bool IncomingPacket::_doMULTICAST_LIKE(const RuntimeEnvironment *_r,const Shared
 	return true;
 }
 
-bool IncomingPacket::_doNETWORK_MEMBERSHIP_CERTIFICATE(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doNETWORK_MEMBERSHIP_CERTIFICATE(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
 		CertificateOfMembership com;
@@ -802,25 +802,25 @@ bool IncomingPacket::_doNETWORK_MEMBERSHIP_CERTIFICATE(const RuntimeEnvironment
 		while (ptr < size()) {
 			ptr += com.deserialize(*this,ptr);
 			if ((com.hasRequiredFields())&&(com.signedBy())) {
-				SharedPtr<Peer> signer(_r->topology->getPeer(com.signedBy()));
+				SharedPtr<Peer> signer(RR->topology->getPeer(com.signedBy()));
 				if (signer) {
 					if (com.verify(signer->identity())) {
 						uint64_t nwid = com.networkId();
-						SharedPtr<Network> network(_r->nc->network(nwid));
+						SharedPtr<Network> network(RR->nc->network(nwid));
 						if (network) {
 							if (network->controller() == signer)
 								network->addMembershipCertificate(com);
 						}
 					}
 				} else {
-					_r->sw->requestWhois(com.signedBy());
+					RR->sw->requestWhois(com.signedBy());
 					_step = DECODE_WAITING_FOR_NETWORK_MEMBERSHIP_CERTIFICATE_SIGNER_LOOKUP;
 					return false;
 				}
 			}
 		}
 
-		peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_NETWORK_MEMBERSHIP_CERTIFICATE,0,Packet::VERB_NOP,Utils::now());
+		peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_NETWORK_MEMBERSHIP_CERTIFICATE,0,Packet::VERB_NOP,Utils::now());
 	} catch (std::exception &ex) {
 		TRACE("dropped NETWORK_MEMBERSHIP_CERTIFICATE from %s(%s): unexpected exception: %s",source().toString().c_str(),_remoteAddress.toString().c_str(),ex.what());
 	} catch ( ... ) {
@@ -829,12 +829,12 @@ bool IncomingPacket::_doNETWORK_MEMBERSHIP_CERTIFICATE(const RuntimeEnvironment
 	return true;
 }
 
-bool IncomingPacket::_doNETWORK_CONFIG_REQUEST(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doNETWORK_CONFIG_REQUEST(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
 		uint64_t nwid = at<uint64_t>(ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST_IDX_NETWORK_ID);
 #ifndef __WINDOWS__
-		if (_r->netconfService) {
+		if (RR->netconfService) {
 			char tmp[128];
 			unsigned int dictLen = at<uint16_t>(ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST_IDX_DICT_LEN);
 
@@ -850,10 +850,10 @@ bool IncomingPacket::_doNETWORK_CONFIG_REQUEST(const RuntimeEnvironment *_r,cons
 			if (!hops())
 				request["from"] = _remoteAddress.toString();
 			//TRACE("to netconf:\n%s",request.toString().c_str());
-			_r->netconfService->send(request);
+			RR->netconfService->send(request);
 		} else {
 #endif // !__WINDOWS__
-			Packet outp(source(),_r->identity.address(),Packet::VERB_ERROR);
+			Packet outp(source(),RR->identity.address(),Packet::VERB_ERROR);
 			outp.append((unsigned char)Packet::VERB_NETWORK_CONFIG_REQUEST);
 			outp.append(packetId());
 			outp.append((unsigned char)Packet::ERROR_UNSUPPORTED_OPERATION);
@@ -863,7 +863,7 @@ bool IncomingPacket::_doNETWORK_CONFIG_REQUEST(const RuntimeEnvironment *_r,cons
 #ifndef __WINDOWS__
 		}
 #endif // !__WINDOWS__
-		peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_NETWORK_CONFIG_REQUEST,0,Packet::VERB_NOP,Utils::now());
+		peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_NETWORK_CONFIG_REQUEST,0,Packet::VERB_NOP,Utils::now());
 	} catch (std::exception &exc) {
 		TRACE("dropped NETWORK_CONFIG_REQUEST from %s(%s): unexpected exception: %s",source().toString().c_str(),_remoteAddress.toString().c_str(),exc.what());
 	} catch ( ... ) {
@@ -872,19 +872,19 @@ bool IncomingPacket::_doNETWORK_CONFIG_REQUEST(const RuntimeEnvironment *_r,cons
 	return true;
 }
 
-bool IncomingPacket::_doNETWORK_CONFIG_REFRESH(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer)
+bool IncomingPacket::_doNETWORK_CONFIG_REFRESH(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer)
 {
 	try {
 		unsigned int ptr = ZT_PACKET_IDX_PAYLOAD;
 		while ((ptr + sizeof(uint64_t)) <= size()) {
 			uint64_t nwid = at<uint64_t>(ptr); ptr += sizeof(uint64_t);
-			SharedPtr<Network> nw(_r->nc->network(nwid));
+			SharedPtr<Network> nw(RR->nc->network(nwid));
 			if ((nw)&&(source() == nw->controller())) { // only respond to requests from controller
 				TRACE("NETWORK_CONFIG_REFRESH from %s, refreshing network %.16llx",source().toString().c_str(),nwid);
 				nw->requestConfiguration();
 			}
 		}
-		peer->receive(_r,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_NETWORK_CONFIG_REFRESH,0,Packet::VERB_NOP,Utils::now());
+		peer->receive(RR,_fromSock,_remoteAddress,hops(),packetId(),Packet::VERB_NETWORK_CONFIG_REFRESH,0,Packet::VERB_NOP,Utils::now());
 	} catch (std::exception &exc) {
 		TRACE("dropped NETWORK_CONFIG_REFRESH from %s(%s): unexpected exception: %s",source().toString().c_str(),_remoteAddress.toString().c_str(),exc.what());
 	} catch ( ... ) {
@@ -893,9 +893,9 @@ bool IncomingPacket::_doNETWORK_CONFIG_REFRESH(const RuntimeEnvironment *_r,cons
 	return true;
 }
 
-void IncomingPacket::_sendErrorNeedCertificate(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer,uint64_t nwid)
+void IncomingPacket::_sendErrorNeedCertificate(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer,uint64_t nwid)
 {
-	Packet outp(source(),_r->identity.address(),Packet::VERB_ERROR);
+	Packet outp(source(),RR->identity.address(),Packet::VERB_ERROR);
 	outp.append((unsigned char)verb());
 	outp.append(packetId());
 	outp.append((unsigned char)Packet::ERROR_NEED_MEMBERSHIP_CERTIFICATE);

node/IncomingPacket.hpp

@@ -102,7 +102,7 @@ public:
 	 * @throws std::out_of_range Range error processing packet (should be discarded)
 	 * @throws std::runtime_error Other error processing packet (should be discarded)
 	 */
-	bool tryDecode(const RuntimeEnvironment *_r);
+	bool tryDecode(const RuntimeEnvironment *RR);
 
 	/**
 	 * @return Time of packet receipt / start of decode
@@ -112,20 +112,20 @@ public:
 private:
 	// These are called internally to handle packet contents once it has
 	// been authenticated, decrypted, decompressed, and classified.
-	bool _doERROR(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doHELLO(const RuntimeEnvironment *_r);
-	bool _doOK(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doWHOIS(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doRENDEZVOUS(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doFRAME(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doEXT_FRAME(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doP5_MULTICAST_FRAME(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doMULTICAST_LIKE(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doNETWORK_MEMBERSHIP_CERTIFICATE(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doNETWORK_CONFIG_REQUEST(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-	bool _doNETWORK_CONFIG_REFRESH(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer);
-
-	void _sendErrorNeedCertificate(const RuntimeEnvironment *_r,const SharedPtr<Peer> &peer,uint64_t nwid);
+	bool _doERROR(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doHELLO(const RuntimeEnvironment *RR);
+	bool _doOK(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doWHOIS(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doRENDEZVOUS(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doFRAME(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doEXT_FRAME(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doP5_MULTICAST_FRAME(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doMULTICAST_LIKE(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doNETWORK_MEMBERSHIP_CERTIFICATE(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doNETWORK_CONFIG_REQUEST(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+	bool _doNETWORK_CONFIG_REFRESH(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer);
+
+	void _sendErrorNeedCertificate(const RuntimeEnvironment *RR,const SharedPtr<Peer> &peer,uint64_t nwid);
 
 	uint64_t _receiveTime;
 	SharedPtr<Socket> _fromSock;

node/Logger.hpp

@@ -37,11 +37,11 @@
 #include "Mutex.hpp"
 
 #undef LOG
-#define LOG(f,...) if (_r->log) _r->log->log(f,##__VA_ARGS__)
+#define LOG(f,...) if (RR->log) RR->log->log(f,##__VA_ARGS__)
 
 #undef TRACE
 #ifdef ZT_TRACE
-#define TRACE(f,...) if (_r->log) _r->log->trace(__FILE__,__LINE__,f,##__VA_ARGS__)
+#define TRACE(f,...) if (RR->log) RR->log->trace(__FILE__,__LINE__,f,##__VA_ARGS__)
 #else
 #define TRACE(f,...) {}
 #endif

node/Network.cpp

@@ -73,12 +73,12 @@ Network::~Network()
 	{
 		Mutex::Lock _l(_lock);
 		if (_tap)
-			_r->tapFactory->close(_tap,_destroyed);
+			RR->tapFactory->close(_tap,_destroyed);
 	}
 
 	if (_destroyed) {
-		Utils::rm(std::string(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".conf"));
-		Utils::rm(std::string(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".mcerts"));
+		Utils::rm(std::string(RR->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".conf"));
+		Utils::rm(std::string(RR->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".mcerts"));
 	} else {
 		clean();
 		_dumpMulticastCerts();
@@ -149,7 +149,7 @@ bool Network::setConfiguration(const Dictionary &conf,bool saveToDisk)
 
 	try {
 		SharedPtr<NetworkConfig> newConfig(new NetworkConfig(conf)); // throws if invalid
-		if ((newConfig->networkId() == _id)&&(newConfig->issuedTo() == _r->identity.address())) {
+		if ((newConfig->networkId() == _id)&&(newConfig->issuedTo() == RR->identity.address())) {
 			std::set<InetAddress> oldStaticIps;
 			if (_config)
 				oldStaticIps = _config->staticIps();
@@ -160,7 +160,7 @@ bool Network::setConfiguration(const Dictionary &conf,bool saveToDisk)
 			_netconfFailure = NETCONF_FAILURE_NONE;
 
 			if (saveToDisk) {
-				std::string confPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".conf");
+				std::string confPath(RR->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".conf");
 				if (!Utils::writeFile(confPath.c_str(),conf.toString())) {
 					LOG("error: unable to write network configuration file at: %s",confPath.c_str());
 				} else {
@@ -226,17 +226,17 @@ bool Network::setConfiguration(const Dictionary &conf,bool saveToDisk)
 
 void Network::requestConfiguration()
 {
-	if (controller() == _r->identity.address()) {
+	if (controller() == RR->identity.address()) {
 		// netconf master cannot be a member of its own nets
 		LOG("unable to request network configuration for network %.16llx: I am the network master, cannot query self",(unsigned long long)_id);
 		return;
 	}
 
 	TRACE("requesting netconf for network %.16llx from netconf master %s",(unsigned long long)_id,controller().toString().c_str());
-	Packet outp(controller(),_r->identity.address(),Packet::VERB_NETWORK_CONFIG_REQUEST);
+	Packet outp(controller(),RR->identity.address(),Packet::VERB_NETWORK_CONFIG_REQUEST);
 	outp.append((uint64_t)_id);
 	outp.append((uint16_t)0); // no meta-data
-	_r->sw->send(outp,true);
+	RR->sw->send(outp,true);
 }
 
 void Network::addMembershipCertificate(const CertificateOfMembership &cert)
@@ -318,7 +318,7 @@ void Network::clean()
 		}
 	}
 	{
-		_multicastTopology.clean(now,*(_r->topology),(_config) ? _config->multicastLimit() : (unsigned int)ZT_DEFAULT_MULTICAST_LIMIT);
+		_multicastTopology.clean(now,*(RR->topology),(_config) ? _config->multicastLimit() : (unsigned int)ZT_DEFAULT_MULTICAST_LIMIT);
 	}
 }
 
@@ -343,12 +343,12 @@ void Network::_CBhandleTapData(void *arg,const MAC &from,const MAC &to,unsigned
 	if ((!((Network *)arg)->_enabled)||(((Network *)arg)->status() != NETWORK_OK))
 		return;
 
-	const RuntimeEnvironment *_r = ((Network *)arg)->_r;
-	if (_r->shutdownInProgress)
+	const RuntimeEnvironment *RR = ((Network *)arg)->_r;
+	if (RR->shutdownInProgress)
 		return;
 
 	try {
-		_r->sw->onLocalEthernet(SharedPtr<Network>((Network *)arg),from,to,etherType,data);
+		RR->sw->onLocalEthernet(SharedPtr<Network>((Network *)arg),from,to,etherType,data);
 	} catch (std::exception &exc) {
 		TRACE("unexpected exception handling local packet: %s",exc.what());
 	} catch ( ... ) {
@@ -369,9 +369,9 @@ void Network::_pushMembershipCertificate(const Address &peer,bool force,uint64_t
 		lastPushed = now;
 		TRACE("pushing membership cert for %.16llx to %s",(unsigned long long)_id,peer.toString().c_str());
 
-		Packet outp(peer,_r->identity.address(),Packet::VERB_NETWORK_MEMBERSHIP_CERTIFICATE);
+		Packet outp(peer,RR->identity.address(),Packet::VERB_NETWORK_MEMBERSHIP_CERTIFICATE);
 		_config->com().serialize(outp);
-		_r->sw->send(outp,true);
+		RR->sw->send(outp,true);
 	}
 }
 
@@ -388,7 +388,7 @@ void Network::threadMain()
 		std::string desiredDevice(_nc->getLocalConfig(lcentry));
 		_mkNetworkFriendlyName(fname,sizeof(fname));
 
-		t = _r->tapFactory->open(_mac,ZT_IF_MTU,ZT_DEFAULT_IF_METRIC,_id,(desiredDevice.length() > 0) ? desiredDevice.c_str() : (const char *)0,fname,_CBhandleTapData,this);
+		t = RR->tapFactory->open(_mac,ZT_IF_MTU,ZT_DEFAULT_IF_METRIC,_id,(desiredDevice.length() > 0) ? desiredDevice.c_str() : (const char *)0,fname,_CBhandleTapData,this);
 
 		std::string dn(t->deviceName());
 		if ((dn.length())&&(dn != desiredDevice))
@@ -408,7 +408,7 @@ void Network::threadMain()
 	{
 		Mutex::Lock _l(_lock);
 		if (_tap) // the tap creation thread can technically be re-launched, though this isn't done right now
-			_r->tapFactory->close(_tap,false);
+			RR->tapFactory->close(_tap,false);
 		_tap = t;
 		if (t) {
 			if (_config) {
@@ -465,7 +465,7 @@ void Network::destroy()
 	_setupThread = Thread();
 
 	if (_tap)
-		_r->tapFactory->close(_tap,true);
+		RR->tapFactory->close(_tap,true);
 	_tap = (EthernetTap *)0;
 }
 
@@ -474,8 +474,8 @@ void Network::_restoreState()
 	Buffer<ZT_NETWORK_CERT_WRITE_BUF_SIZE> buf;
 
 	std::string idstr(idString());
-	std::string confPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idstr + ".conf");
-	std::string mcdbPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idstr + ".mcerts");
+	std::string confPath(RR->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idstr + ".conf");
+	std::string mcdbPath(RR->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idstr + ".mcerts");
 
 	// Read configuration file containing last config from netconf master
 	{
@@ -540,7 +540,7 @@ void Network::_restoreState()
 void Network::_dumpMulticastCerts()
 {
 	Buffer<ZT_NETWORK_CERT_WRITE_BUF_SIZE> buf;
-	std::string mcdbPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".mcerts");
+	std::string mcdbPath(RR->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".mcerts");
 	Mutex::Lock _l(_lock);
 
 	if (!_config)

node/Network.hpp

@@ -446,7 +446,7 @@ private:
 	uint64_t _id;
 	NodeConfig *_nc; // parent NodeConfig object
 	MAC _mac; // local MAC address
-	const RuntimeEnvironment *_r;
+	const RuntimeEnvironment *RR;
 	EthernetTap *volatile _tap; // tap device or NULL if not initialized yet
 	volatile bool _enabled;
 

node/Node.cpp

@@ -96,7 +96,7 @@ struct _NodeImpl
 	// This function performs final node tear-down
 	inline Node::ReasonForTermination terminate()
 	{
-		RuntimeEnvironment *_r = &renv;
+		RuntimeEnvironment *RR = &renv;
 		LOG("terminating: %s",reasonForTerminationStr.c_str());
 
 		renv.shutdownInProgress = true;
@@ -133,7 +133,7 @@ static void _netconfServiceMessageHandler(void *renv,Service &svc,const Dictiona
 {
 	if (!renv)
 		return; // sanity check
-	const RuntimeEnvironment *_r = (const RuntimeEnvironment *)renv;
+	const RuntimeEnvironment *RR = (const RuntimeEnvironment *)renv;
 
 	try {
 		//TRACE("from netconf:\n%s",msg.toString().c_str());
@@ -142,8 +142,8 @@ static void _netconfServiceMessageHandler(void *renv,Service &svc,const Dictiona
 			LOG("received 'ready' from netconf.service, sending netconf-init with identity information...");
 			Dictionary initMessage;
 			initMessage["type"] = "netconf-init";
-			initMessage["netconfId"] = _r->identity.toString(true);
-			_r->netconfService->send(initMessage);
+			initMessage["netconfId"] = RR->identity.toString(true);
+			RR->netconfService->send(initMessage);
 		} else if (type == "netconf-response") {
 			uint64_t inRePacketId = strtoull(msg.get("requestId").c_str(),(char **)0,16);
 			uint64_t nwid = strtoull(msg.get("nwid").c_str(),(char **)0,16);
@@ -158,23 +158,23 @@ static void _netconfServiceMessageHandler(void *renv,Service &svc,const Dictiona
 					else if (err == "ACCESS_DENIED")
 						errCode = Packet::ERROR_NETWORK_ACCESS_DENIED_;
 
-					Packet outp(peerAddress,_r->identity.address(),Packet::VERB_ERROR);
+					Packet outp(peerAddress,RR->identity.address(),Packet::VERB_ERROR);
 					outp.append((unsigned char)Packet::VERB_NETWORK_CONFIG_REQUEST);
 					outp.append(inRePacketId);
 					outp.append((unsigned char)errCode);
 					outp.append(nwid);
-					_r->sw->send(outp,true);
+					RR->sw->send(outp,true);
 				} else if (msg.contains("netconf")) {
 					const std::string &netconf = msg.get("netconf");
 					if (netconf.length() < 2048) { // sanity check
-						Packet outp(peerAddress,_r->identity.address(),Packet::VERB_OK);
+						Packet outp(peerAddress,RR->identity.address(),Packet::VERB_OK);
 						outp.append((unsigned char)Packet::VERB_NETWORK_CONFIG_REQUEST);
 						outp.append(inRePacketId);
 						outp.append(nwid);
 						outp.append((uint16_t)netconf.length());
 						outp.append(netconf.data(),netconf.length());
 						outp.compress();
-						_r->sw->send(outp,true);
+						RR->sw->send(outp,true);
 					}
 				}
 			}
@@ -184,7 +184,7 @@ static void _netconfServiceMessageHandler(void *renv,Service &svc,const Dictiona
 				for(Dictionary::iterator t(to.begin());t!=to.end();++t) {
 					Address ztaddr(t->first);
 					if (ztaddr) {
-						Packet outp(ztaddr,_r->identity.address(),Packet::VERB_NETWORK_CONFIG_REFRESH);
+						Packet outp(ztaddr,RR->identity.address(),Packet::VERB_NETWORK_CONFIG_REFRESH);
 
 						char *saveptr = (char *)0;
 						// Note: this loop trashes t->second, which is quasi-legal C++ but
@@ -194,15 +194,15 @@ static void _netconfServiceMessageHandler(void *renv,Service &svc,const Dictiona
 							uint64_t nwid = Utils::hexStrToU64(p);
 							if (nwid) {
 								if ((outp.size() + sizeof(uint64_t)) >= ZT_UDP_DEFAULT_PAYLOAD_MTU) {
-									_r->sw->send(outp,true);
-									outp.reset(ztaddr,_r->identity.address(),Packet::VERB_NETWORK_CONFIG_REFRESH);
+									RR->sw->send(outp,true);
+									outp.reset(ztaddr,RR->identity.address(),Packet::VERB_NETWORK_CONFIG_REFRESH);
 								}
 								outp.append(nwid);
 							}
 						}
 
 						if (outp.payloadLength())
-							_r->sw->send(outp,true);
+							RR->sw->send(outp,true);
 					}
 				}
 			}
@@ -268,15 +268,15 @@ Node::~Node()
 
 static void _CBztTraffic(const SharedPtr<Socket> &fromSock,void *arg,const InetAddress &from,Buffer<ZT_SOCKET_MAX_MESSAGE_LEN> &data)
 {
-	const RuntimeEnvironment *_r = (const RuntimeEnvironment *)arg;
-	if ((_r->sw)&&(!_r->shutdownInProgress))
-		_r->sw->onRemotePacket(fromSock,from,data);
+	const RuntimeEnvironment *RR = (const RuntimeEnvironment *)arg;
+	if ((RR->sw)&&(!RR->shutdownInProgress))
+		RR->sw->onRemotePacket(fromSock,from,data);
 }
 
 static void _cbHandleGetRootTopology(void *arg,int code,const std::string &url,const std::string &body)
 {
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)arg;
-	if (_r->shutdownInProgress)
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)arg;
+	if (RR->shutdownInProgress)
 		return;
 
 	if ((code != 200)||(body.length() == 0)) {
@@ -292,7 +292,7 @@ static void _cbHandleGetRootTopology(void *arg,int code,const std::string &url,c
 		}
 
 		{
-			std::string rootTopologyPath(_r->homePath + ZT_PATH_SEPARATOR_S + "root-topology");
+			std::string rootTopologyPath(RR->homePath + ZT_PATH_SEPARATOR_S + "root-topology");
 			std::string rootTopology;
 			if (Utils::readFile(rootTopologyPath.c_str(),rootTopology)) {
 				Dictionary alreadyHave(rootTopology);
@@ -307,7 +307,7 @@ static void _cbHandleGetRootTopology(void *arg,int code,const std::string &url,c
 			Utils::writeFile(rootTopologyPath.c_str(),body);
 		}
 
-		_r->topology->setSupernodes(Dictionary(rt.get("supernodes")));
+		RR->topology->setSupernodes(Dictionary(rt.get("supernodes")));
 	} catch ( ... ) {
 		LOG("discarded invalid root topology update from %s (format invalid)",url.c_str());
 		return;
@@ -318,50 +318,50 @@ Node::ReasonForTermination Node::run()
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
 
 	impl->started = true;
 	impl->running = true;
 
 	try {
 #ifdef ZT_LOG_STDOUT
-		_r->log = new Logger((const char *)0,(const char *)0,0);
+		RR->log = new Logger((const char *)0,(const char *)0,0);
 #else
-		_r->log = new Logger((_r->homePath + ZT_PATH_SEPARATOR_S + "node.log").c_str(),(const char *)0,131072);
+		RR->log = new Logger((RR->homePath + ZT_PATH_SEPARATOR_S + "node.log").c_str(),(const char *)0,131072);
 #endif
 
 		LOG("starting version %s",versionString());
 
 		// Create non-crypto PRNG right away in case other code in init wants to use it
-		_r->prng = new CMWC4096();
+		RR->prng = new CMWC4096();
 
 		// Read identity public and secret, generating if not present
 		{
 			bool gotId = false;
-			std::string identitySecretPath(_r->homePath + ZT_PATH_SEPARATOR_S + "identity.secret");
-			std::string identityPublicPath(_r->homePath + ZT_PATH_SEPARATOR_S + "identity.public");
+			std::string identitySecretPath(RR->homePath + ZT_PATH_SEPARATOR_S + "identity.secret");
+			std::string identityPublicPath(RR->homePath + ZT_PATH_SEPARATOR_S + "identity.public");
 			std::string idser;
 			if (Utils::readFile(identitySecretPath.c_str(),idser))
-				gotId = _r->identity.fromString(idser);
-			if ((gotId)&&(!_r->identity.locallyValidate()))
+				gotId = RR->identity.fromString(idser);
+			if ((gotId)&&(!RR->identity.locallyValidate()))
 				gotId = false;
 			if (gotId) {
 				// Make sure identity.public matches identity.secret
 				idser = std::string();
 				Utils::readFile(identityPublicPath.c_str(),idser);
-				std::string pubid(_r->identity.toString(false));
+				std::string pubid(RR->identity.toString(false));
 				if (idser != pubid) {
 					if (!Utils::writeFile(identityPublicPath.c_str(),pubid))
 						return impl->terminateBecause(Node::NODE_UNRECOVERABLE_ERROR,"could not write identity.public (home path not writable?)");
 				}
 			} else {
 				LOG("no identity found or identity invalid, generating one... this might take a few seconds...");
-				_r->identity.generate();
-				LOG("generated new identity: %s",_r->identity.address().toString().c_str());
-				idser = _r->identity.toString(true);
+				RR->identity.generate();
+				LOG("generated new identity: %s",RR->identity.address().toString().c_str());
+				idser = RR->identity.toString(true);
 				if (!Utils::writeFile(identitySecretPath.c_str(),idser))
 					return impl->terminateBecause(Node::NODE_UNRECOVERABLE_ERROR,"could not write identity.secret (home path not writable?)");
-				idser = _r->identity.toString(false);
+				idser = RR->identity.toString(false);
 				if (!Utils::writeFile(identityPublicPath.c_str(),idser))
 					return impl->terminateBecause(Node::NODE_UNRECOVERABLE_ERROR,"could not write identity.public (home path not writable?)");
 			}
@@ -370,7 +370,7 @@ Node::ReasonForTermination Node::run()
 
 		// Make sure networks.d exists
 		{
-			std::string networksDotD(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d");
+			std::string networksDotD(RR->homePath + ZT_PATH_SEPARATOR_S + "networks.d");
 #ifdef __WINDOWS__
 			CreateDirectoryA(networksDotD.c_str(),NULL);
 #else
@@ -378,22 +378,22 @@ Node::ReasonForTermination Node::run()
 #endif
 		}
 
-		_r->http = new HttpClient();
-		_r->antiRec = new AntiRecursion();
-		_r->sw = new Switch(_r);
-		_r->sm = new SocketManager(impl->udpPort,impl->tcpPort,&_CBztTraffic,_r);
-		_r->topology = new Topology(_r,Utils::fileExists((_r->homePath + ZT_PATH_SEPARATOR_S + "iddb.d").c_str()));
+		RR->http = new HttpClient();
+		RR->antiRec = new AntiRecursion();
+		RR->sw = new Switch(_r);
+		RR->sm = new SocketManager(impl->udpPort,impl->tcpPort,&_CBztTraffic,_r);
+		RR->topology = new Topology(RR,Utils::fileExists((RR->homePath + ZT_PATH_SEPARATOR_S + "iddb.d").c_str()));
 		try {
-			_r->nc = new NodeConfig(_r);
+			RR->nc = new NodeConfig(_r);
 		} catch (std::exception &exc) {
 			return impl->terminateBecause(Node::NODE_UNRECOVERABLE_ERROR,"unable to initialize IPC socket: is ZeroTier One already running?");
 		}
-		_r->node = this;
+		RR->node = this;
 
 #ifdef ZT_AUTO_UPDATE
 		if (ZT_DEFAULTS.updateLatestNfoURL.length()) {
-			_r->updater = new SoftwareUpdater(_r);
-			_r->updater->cleanOldUpdates(); // clean out updates.d on startup
+			RR->updater = new SoftwareUpdater(_r);
+			RR->updater->cleanOldUpdates(); // clean out updates.d on startup
 		} else {
 			LOG("WARNING: unable to enable software updates: latest .nfo URL from ZT_DEFAULTS is empty (does this platform actually support software updates?)");
 		}
@@ -401,7 +401,7 @@ Node::ReasonForTermination Node::run()
 
 		// Initialize root topology from defaults or root-toplogy file in home path on disk
 		{
-			std::string rootTopologyPath(_r->homePath + ZT_PATH_SEPARATOR_S + "root-topology");
+			std::string rootTopologyPath(RR->homePath + ZT_PATH_SEPARATOR_S + "root-topology");
 			std::string rootTopology;
 			if (!Utils::readFile(rootTopologyPath.c_str(),rootTopology))
 				rootTopology = ZT_DEFAULTS.defaultRootTopology;
@@ -410,7 +410,7 @@ Node::ReasonForTermination Node::run()
 
 				if (Topology::authenticateRootTopology(rt)) {
 					// Set supernodes if root topology signature is valid
-					_r->topology->setSupernodes(Dictionary(rt.get("supernodes",""))); // set supernodes from root-topology
+					RR->topology->setSupernodes(Dictionary(rt.get("supernodes",""))); // set supernodes from root-topology
 
 					// If root-topology contains noupdate=1, disable further updates and only use what was on disk
 					impl->disableRootTopologyUpdates = (Utils::strToInt(rt.get("noupdate","0").c_str()) > 0);
@@ -418,7 +418,7 @@ Node::ReasonForTermination Node::run()
 					// Revert to built-in defaults if root topology fails signature check
 					LOG("%s failed signature check, using built-in defaults instead",rootTopologyPath.c_str());
 					Utils::rm(rootTopologyPath.c_str());
-					_r->topology->setSupernodes(Dictionary(Dictionary(ZT_DEFAULTS.defaultRootTopology).get("supernodes","")));
+					RR->topology->setSupernodes(Dictionary(Dictionary(ZT_DEFAULTS.defaultRootTopology).get("supernodes","")));
 					impl->disableRootTopologyUpdates = false;
 				}
 			} catch ( ... ) {
@@ -437,14 +437,14 @@ Node::ReasonForTermination Node::run()
 	// right now and isn't available on Windows.
 #ifndef __WINDOWS__
 	try {
-		std::string netconfServicePath(_r->homePath + ZT_PATH_SEPARATOR_S + "services.d" + ZT_PATH_SEPARATOR_S + "netconf.service");
+		std::string netconfServicePath(RR->homePath + ZT_PATH_SEPARATOR_S + "services.d" + ZT_PATH_SEPARATOR_S + "netconf.service");
 		if (Utils::fileExists(netconfServicePath.c_str())) {
 			LOG("netconf.d/netconf.service appears to exist, starting...");
-			_r->netconfService = new Service(_r,"netconf",netconfServicePath.c_str(),&_netconfServiceMessageHandler,_r);
+			RR->netconfService = new Service(RR,"netconf",netconfServicePath.c_str(),&_netconfServiceMessageHandler,_r);
 			Dictionary initMessage;
 			initMessage["type"] = "netconf-init";
-			initMessage["netconfId"] = _r->identity.toString(true);
-			_r->netconfService->send(initMessage);
+			initMessage["netconfId"] = RR->identity.toString(true);
+			RR->netconfService->send(initMessage);
 		}
 	} catch ( ... ) {
 		LOG("unexpected exception attempting to start services");
@@ -458,7 +458,7 @@ Node::ReasonForTermination Node::run()
 		 * Info.plist file inside the ZeroTier One application. This causes the
 		 * service to die when the user throws away the app, allowing uninstallation
 		 * in the natural Mac way. */
-		std::string shutdownIfUnreadablePath(_r->homePath + ZT_PATH_SEPARATOR_S + "shutdownIfUnreadable");
+		std::string shutdownIfUnreadablePath(RR->homePath + ZT_PATH_SEPARATOR_S + "shutdownIfUnreadable");
 
 		uint64_t lastNetworkAutoconfCheck = Utils::now() - 5000ULL; // check autoconf again after 5s for startup
 		uint64_t lastPingCheck = 0;
@@ -472,10 +472,10 @@ Node::ReasonForTermination Node::run()
 		long lastDelayDelta = 0;
 
 		uint64_t networkConfigurationFingerprint = 0;
-		_r->timeOfLastResynchronize = Utils::now();
+		RR->timeOfLastResynchronize = Utils::now();
 
 		// We are up and running
-		_r->initialized = true;
+		RR->initialized = true;
 
 		while (impl->reasonForTermination == NODE_RUNNING) {
 			uint64_t now = Utils::now();
@@ -507,7 +507,7 @@ Node::ReasonForTermination Node::run()
 			// If our network environment looks like it changed, resynchronize.
 			if ((resynchronize)||((now - lastNetworkFingerprintCheck) >= ZT_NETWORK_FINGERPRINT_CHECK_DELAY)) {
 				lastNetworkFingerprintCheck = now;
-				uint64_t fp = _r->routingTable->networkEnvironmentFingerprint(_r->nc->networkTapDeviceNames());
+				uint64_t fp = RR->routingTable->networkEnvironmentFingerprint(RR->nc->networkTapDeviceNames());
 				if (fp != networkConfigurationFingerprint) {
 					LOG("netconf fingerprint change: %.16llx != %.16llx, resyncing with network",networkConfigurationFingerprint,fp);
 					networkConfigurationFingerprint = fp;
@@ -516,7 +516,7 @@ Node::ReasonForTermination Node::run()
 			}
 
 			// Supernodes do not resynchronize unless explicitly ordered via SIGHUP.
-			if ((resynchronize)&&(_r->topology->amSupernode()))
+			if ((resynchronize)&&(RR->topology->amSupernode()))
 				resynchronize = false;
 
 			// Check for SIGHUP / force resync.
@@ -527,8 +527,8 @@ Node::ReasonForTermination Node::run()
 			}
 
 			if (resynchronize) {
-				_r->tcpTunnelingEnabled = false; // turn off TCP tunneling master switch at first, will be reenabled on persistent UDP failure
-				_r->timeOfLastResynchronize = now;
+				RR->tcpTunnelingEnabled = false; // turn off TCP tunneling master switch at first, will be reenabled on persistent UDP failure
+				RR->timeOfLastResynchronize = now;
 			}
 
 			/* Supernodes are pinged separately and more aggressively. The
@@ -539,17 +539,17 @@ Node::ReasonForTermination Node::run()
 				lastSupernodePingCheck = now;
 
 				uint64_t lastReceiveFromAnySupernode = 0; // function object result paramter
-				_r->topology->eachSupernodePeer(Topology::FindMostRecentDirectReceiveTimestamp(lastReceiveFromAnySupernode));
+				RR->topology->eachSupernodePeer(Topology::FindMostRecentDirectReceiveTimestamp(lastReceiveFromAnySupernode));
 
 				// Turn on TCP tunneling master switch if we haven't heard anything since before
 				// the last resynchronize and we've been trying long enough.
-				uint64_t tlr = _r->timeOfLastResynchronize;
+				uint64_t tlr = RR->timeOfLastResynchronize;
 				if ((lastReceiveFromAnySupernode < tlr)&&((now - tlr) >= ZT_TCP_TUNNEL_FAILOVER_TIMEOUT)) {
 					TRACE("network still unreachable after %u ms, TCP TUNNELING ENABLED",(unsigned int)ZT_TCP_TUNNEL_FAILOVER_TIMEOUT);
-					_r->tcpTunnelingEnabled = true;
+					RR->tcpTunnelingEnabled = true;
 				}
 
-				_r->topology->eachSupernodePeer(Topology::PingSupernodesThatNeedPing(_r,now));
+				RR->topology->eachSupernodePeer(Topology::PingSupernodesThatNeedPing(RR,now));
 			}
 
 			if (resynchronize) {
@@ -557,8 +557,8 @@ Node::ReasonForTermination Node::run()
 				 * indirectly to regular nodes (to trigger RENDEZVOUS). Also clear
 				 * learned paths since they're likely no longer valid, and close
 				 * TCP sockets since they're also likely invalid. */
-				_r->sm->closeTcpSockets();
-				_r->topology->eachPeer(Topology::ResetActivePeers(_r,now));
+				RR->sm->closeTcpSockets();
+				RR->topology->eachPeer(Topology::ResetActivePeers(RR,now));
 			} else {
 				/* Periodically check for changes in our local multicast subscriptions
 				 * and broadcast those changes to directly connected peers. */
@@ -566,13 +566,13 @@ Node::ReasonForTermination Node::run()
 					lastMulticastCheck = now;
 					try {
 						std::map< SharedPtr<Network>,std::set<MulticastGroup> > toAnnounce;
-						std::vector< SharedPtr<Network> > networks(_r->nc->networks());
+						std::vector< SharedPtr<Network> > networks(RR->nc->networks());
 						for(std::vector< SharedPtr<Network> >::const_iterator nw(networks.begin());nw!=networks.end();++nw) {
 							if ((*nw)->updateMulticastGroups())
 								toAnnounce.insert(std::pair< SharedPtr<Network>,std::set<MulticastGroup> >(*nw,(*nw)->multicastGroups()));
 						}
 						if (toAnnounce.size())
-							_r->sw->announceMulticastGroups(toAnnounce);
+							RR->sw->announceMulticastGroups(toAnnounce);
 					} catch (std::exception &exc) {
 						LOG("unexpected exception announcing multicast groups: %s",exc.what());
 					} catch ( ... ) {
@@ -582,10 +582,10 @@ Node::ReasonForTermination Node::run()
 
 				/* Periodically ping all our non-stale direct peers unless we're a supernode.
 				 * Supernodes only ping each other (which is done above). */
-				if ((!_r->topology->amSupernode())&&((now - lastPingCheck) >= ZT_PING_CHECK_DELAY)) {
+				if ((!RR->topology->amSupernode())&&((now - lastPingCheck) >= ZT_PING_CHECK_DELAY)) {
 					lastPingCheck = now;
 					try {
-						_r->topology->eachPeer(Topology::PingPeersThatNeedPing(_r,now));
+						RR->topology->eachPeer(Topology::PingPeersThatNeedPing(RR,now));
 					} catch (std::exception &exc) {
 						LOG("unexpected exception running ping check cycle: %s",exc.what());
 					} catch ( ... ) {
@@ -597,7 +597,7 @@ Node::ReasonForTermination Node::run()
 			// Update network configurations when needed.
 			if ((resynchronize)||((now - lastNetworkAutoconfCheck) >= ZT_NETWORK_AUTOCONF_CHECK_DELAY)) {
 				lastNetworkAutoconfCheck = now;
-				std::vector< SharedPtr<Network> > nets(_r->nc->networks());
+				std::vector< SharedPtr<Network> > nets(RR->nc->networks());
 				for(std::vector< SharedPtr<Network> >::iterator n(nets.begin());n!=nets.end();++n) {
 					if ((now - (*n)->lastConfigUpdate()) >= ZT_NETWORK_AUTOCONF_DELAY)
 						(*n)->requestConfiguration();
@@ -607,11 +607,11 @@ Node::ReasonForTermination Node::run()
 			// Do periodic tasks in submodules.
 			if ((now - lastClean) >= ZT_DB_CLEAN_PERIOD) {
 				lastClean = now;
-				_r->mc->clean();
-				_r->topology->clean();
-				_r->nc->clean();
-				if (_r->updater)
-					_r->updater->checkIfMaxIntervalExceeded(now);
+				RR->mc->clean();
+				RR->topology->clean();
+				RR->nc->clean();
+				if (RR->updater)
+					RR->updater->checkIfMaxIntervalExceeded(now);
 			}
 
 			// Send beacons to physical local LANs
@@ -619,13 +619,13 @@ Node::ReasonForTermination Node::run()
 				lastBeacon = now;
 				char bcn[ZT_PROTO_BEACON_LENGTH];
 				void *bcnptr = bcn;
-				*((uint32_t *)(bcnptr)) = _r->prng->next32();
+				*((uint32_t *)(bcnptr)) = RR->prng->next32();
 				bcnptr = bcn + 4;
-				*((uint32_t *)(bcnptr)) = _r->prng->next32();
-				_r->identity.address().copyTo(bcn + ZT_PROTO_BEACON_IDX_ADDRESS,ZT_ADDRESS_LENGTH);
+				*((uint32_t *)(bcnptr)) = RR->prng->next32();
+				RR->identity.address().copyTo(bcn + ZT_PROTO_BEACON_IDX_ADDRESS,ZT_ADDRESS_LENGTH);
 				TRACE("sending LAN beacon to %s",ZT_DEFAULTS.v4Broadcast.toString().c_str());
-				_r->antiRec->logOutgoingZT(bcn,ZT_PROTO_BEACON_LENGTH);
-				_r->sm->send(ZT_DEFAULTS.v4Broadcast,false,false,bcn,ZT_PROTO_BEACON_LENGTH);
+				RR->antiRec->logOutgoingZT(bcn,ZT_PROTO_BEACON_LENGTH);
+				RR->sm->send(ZT_DEFAULTS.v4Broadcast,false,false,bcn,ZT_PROTO_BEACON_LENGTH);
 			}
 
 			// Check for updates to root topology (supernodes) periodically
@@ -633,15 +633,15 @@ Node::ReasonForTermination Node::run()
 				lastRootTopologyFetch = now;
 				if (!impl->disableRootTopologyUpdates) {
 					TRACE("fetching root topology from %s",ZT_DEFAULTS.rootTopologyUpdateURL.c_str());
-					_r->http->GET(ZT_DEFAULTS.rootTopologyUpdateURL,HttpClient::NO_HEADERS,60,&_cbHandleGetRootTopology,_r);
+					RR->http->GET(ZT_DEFAULTS.rootTopologyUpdateURL,HttpClient::NO_HEADERS,60,&_cbHandleGetRootTopology,_r);
 				}
 			}
 
 			// Sleep for loop interval or until something interesting happens.
 			try {
-				unsigned long delay = std::min((unsigned long)ZT_MAX_SERVICE_LOOP_INTERVAL,_r->sw->doTimerTasks());
+				unsigned long delay = std::min((unsigned long)ZT_MAX_SERVICE_LOOP_INTERVAL,RR->sw->doTimerTasks());
 				uint64_t start = Utils::now();
-				_r->sm->poll(delay);
+				RR->sm->poll(delay);
 				lastDelayDelta = (long)(Utils::now() - start) - (long)delay; // used to detect sleep/wake
 			} catch (std::exception &exc) {
 				LOG("unexpected exception running Switch doTimerTasks: %s",exc.what());
@@ -686,10 +686,10 @@ bool Node::online()
 	_NodeImpl *impl = (_NodeImpl *)_impl;
 	if (!impl->running)
 		return false;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
 	uint64_t now = Utils::now();
-	uint64_t since = _r->timeOfLastResynchronize;
-	std::vector< SharedPtr<Peer> > snp(_r->topology->supernodePeers());
+	uint64_t since = RR->timeOfLastResynchronize;
+	std::vector< SharedPtr<Peer> > snp(RR->topology->supernodePeers());
 	for(std::vector< SharedPtr<Peer> >::const_iterator sn(snp.begin());sn!=snp.end();++sn) {
 		uint64_t lastRec = (*sn)->lastDirectReceive();
 		if ((lastRec)&&(lastRec > since)&&((now - lastRec) < ZT_PEER_PATH_ACTIVITY_TIMEOUT))
@@ -716,34 +716,34 @@ bool Node::initialized()
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
-	return ((_r)&&(_r->initialized));
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
+	return ((_r)&&(RR->initialized));
 }
 
 uint64_t Node::address()
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
-	if ((!_r)||(!_r->initialized))
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
+	if ((!_r)||(!RR->initialized))
 		return 0;
-	return _r->identity.address().toInt();
+	return RR->identity.address().toInt();
 }
 
 void Node::join(uint64_t nwid)
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
-	_r->nc->join(nwid);
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
+	RR->nc->join(nwid);
 }
 
 void Node::leave(uint64_t nwid)
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
-	_r->nc->leave(nwid);
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
+	RR->nc->leave(nwid);
 }
 
 struct GatherPeerStatistics
@@ -763,22 +763,22 @@ void Node::status(ZT1_Node_Status *status)
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
 
 	memset(status,0,sizeof(ZT1_Node_Status));
 
-	Utils::scopy(status->publicIdentity,sizeof(status->publicIdentity),_r->identity.toString(false).c_str());
-	_r->identity.address().toString(status->address,sizeof(status->address));
-	status->rawAddress = _r->identity.address().toInt();
+	Utils::scopy(status->publicIdentity,sizeof(status->publicIdentity),RR->identity.toString(false).c_str());
+	RR->identity.address().toString(status->address,sizeof(status->address));
+	status->rawAddress = RR->identity.address().toInt();
 
 	status->knownPeers = 0;
-	status->supernodes = _r->topology->numSupernodes();
+	status->supernodes = RR->topology->numSupernodes();
 	status->directlyConnectedPeers = 0;
 	status->alivePeers = 0;
 	GatherPeerStatistics gps;
 	gps.now = Utils::now();
 	gps.status = status;
-	_r->topology->eachPeer<GatherPeerStatistics &>(gps);
+	RR->topology->eachPeer<GatherPeerStatistics &>(gps);
 
 	if (status->alivePeers > 0) {
 		double dlsr = (double)status->directlyConnectedPeers / (double)status->alivePeers;
@@ -804,10 +804,10 @@ ZT1_Node_PeerList *Node::listPeers()
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
 
 	CollectPeersAndPaths pp;
-	_r->topology->eachPeer<CollectPeersAndPaths &>(pp);
+	RR->topology->eachPeer<CollectPeersAndPaths &>(pp);
 	std::sort(pp.data.begin(),pp.data.end(),SortPeersAndPathsInAscendingAddressOrder());
 
 	unsigned int returnBufSize = sizeof(ZT1_Node_PeerList);
@@ -889,9 +889,9 @@ ZT1_Node_Network *Node::getNetworkStatus(uint64_t nwid)
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
 
-	SharedPtr<Network> network(_r->nc->network(nwid));
+	SharedPtr<Network> network(RR->nc->network(nwid));
 	if (!network)
 		return (ZT1_Node_Network *)0;
 	SharedPtr<NetworkConfig> nconf(network->config2());
@@ -929,9 +929,9 @@ ZT1_Node_NetworkList *Node::listNetworks()
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
 
-	std::vector< SharedPtr<Network> > networks(_r->nc->networks());
+	std::vector< SharedPtr<Network> > networks(RR->nc->networks());
 	std::vector< SharedPtr<NetworkConfig> > nconfs(networks.size());
 	std::vector< std::set<InetAddress> > ipsv(networks.size());
 
@@ -990,9 +990,9 @@ bool Node::updateCheck()
 	throw()
 {
 	_NodeImpl *impl = (_NodeImpl *)_impl;
-	RuntimeEnvironment *_r = (RuntimeEnvironment *)&(impl->renv);
-	if (_r->updater) {
-		_r->updater->checkNow();
+	RuntimeEnvironment *RR = (RuntimeEnvironment *)&(impl->renv);
+	if (RR->updater) {
+		RR->updater->checkNow();
 		return true;
 	}
 	return false;

node/NodeConfig.cpp

@@ -59,7 +59,7 @@ NodeConfig::NodeConfig(const RuntimeEnvironment *renv) :
 		_readLocalConfig();
 	}
 
-	std::string networksFolder(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d");
+	std::string networksFolder(RR->homePath + ZT_PATH_SEPARATOR_S + "networks.d");
 	std::map<std::string,bool> networksDotD(Utils::listDirectory(networksFolder.c_str()));
 	std::vector<uint64_t> configuredNets;
 	for(std::map<std::string,bool>::iterator d(networksDotD.begin());d!=networksDotD.end();++d) {
@@ -75,7 +75,7 @@ NodeConfig::NodeConfig(const RuntimeEnvironment *renv) :
 
 	for(std::vector<uint64_t>::iterator n(configuredNets.begin());n!=configuredNets.end();++n) {
 		try {
-			_networks[*n] = Network::newInstance(_r,this,*n);
+			_networks[*n] = Network::newInstance(RR,this,*n);
 		} catch (std::exception &exc) {
 			LOG("unable to create network %.16llx: %s",(unsigned long long)*n,exc.what());
 		} catch ( ... ) {
@@ -122,7 +122,7 @@ void NodeConfig::clean()
 void NodeConfig::_readLocalConfig()
 {
 	// assumes _localConfig_m is locked
-	std::string localDotConf(_r->homePath + ZT_PATH_SEPARATOR_S + "local.conf");
+	std::string localDotConf(RR->homePath + ZT_PATH_SEPARATOR_S + "local.conf");
 	std::string buf;
 	if (Utils::readFile(localDotConf.c_str(),buf))
 		_localConfig.fromString(buf.c_str());
@@ -131,7 +131,7 @@ void NodeConfig::_readLocalConfig()
 void NodeConfig::_writeLocalConfig()
 {
 	// assumes _localConfig_m is locked
-	Utils::writeFile(((_r->homePath + ZT_PATH_SEPARATOR_S + "local.conf")).c_str(),_localConfig.toString());
+	Utils::writeFile(((RR->homePath + ZT_PATH_SEPARATOR_S + "local.conf")).c_str(),_localConfig.toString());
 }
 
 } // namespace ZeroTier

node/NodeConfig.hpp

@@ -113,7 +113,7 @@ public:
 		SharedPtr<Network> &nw = _networks[nwid];
 		if (nw)
 			return nw;
-		else return (nw = Network::newInstance(_r,this,nwid));
+		else return (nw = Network::newInstance(RR,this,nwid));
 	}
 
 	/**
@@ -166,7 +166,7 @@ public:
 	void _readLocalConfig();
 	void _writeLocalConfig();
 
-	const RuntimeEnvironment *_r;
+	const RuntimeEnvironment *RR;
 	Dictionary _localConfig; // persisted as local.conf
 	Mutex _localConfig_m;
 	std::map< uint64_t,SharedPtr<Network> > _networks; // persisted in networks.d/

node/Peer.cpp

@@ -63,7 +63,7 @@ Peer::Peer(const Identity &myIdentity,const Identity &peerIdentity)
 }
 
 void Peer::receive(
-	const RuntimeEnvironment *_r,
+	const RuntimeEnvironment *RR,
 	const SharedPtr<Socket> &fromSock,
 	const InetAddress &remoteAddr,
 	unsigned int hops,
@@ -74,7 +74,7 @@ void Peer::receive(
 	uint64_t now)
 {
 	// Update system-wide last packet receive time
-	*((const_cast<uint64_t *>(&(_r->timeOfLastPacketReceived)))) = now;
+	*((const_cast<uint64_t *>(&(RR->timeOfLastPacketReceived)))) = now;
 
 	// Global last receive time regardless of path
 	_lastReceive = now;
@@ -114,7 +114,7 @@ void Peer::receive(
 		// Lock can't be locked here or it'll recurse and deadlock.
 		if ((now - _lastAnnouncedTo) >= ((ZT_MULTICAST_LIKE_EXPIRE / 2) - 1000)) {
 			_lastAnnouncedTo = now;
-			_r->sw->announceMulticastGroups(SharedPtr<Peer>(this));
+			RR->sw->announceMulticastGroups(SharedPtr<Peer>(this));
 		}
 	}
 
@@ -124,7 +124,7 @@ void Peer::receive(
 		_lastMulticastFrame = now;
 }
 
-Path::Type Peer::send(const RuntimeEnvironment *_r,const void *data,unsigned int len,uint64_t now)
+Path::Type Peer::send(const RuntimeEnvironment *RR,const void *data,unsigned int len,uint64_t now)
 {
 	Mutex::Lock _l(_lock);
 
@@ -155,8 +155,8 @@ Path::Type Peer::send(const RuntimeEnvironment *_r,const void *data,unsigned int
 	Path *bestPath = (Path *)0;
 	if (bestTcpOutPath) { // we have a TCP out path
 		if (bestNormalPath) { // we have both paths, decide which to use
-			if (_r->tcpTunnelingEnabled) { // TCP tunneling is enabled, so use normal path only if it looks alive
-				if ((bestNormalPathLastReceived > _r->timeOfLastResynchronize)&&((now - bestNormalPathLastReceived) < ZT_PEER_PATH_ACTIVITY_TIMEOUT))
+			if (RR->tcpTunnelingEnabled) { // TCP tunneling is enabled, so use normal path only if it looks alive
+				if ((bestNormalPathLastReceived > RR->timeOfLastResynchronize)&&((now - bestNormalPathLastReceived) < ZT_PEER_PATH_ACTIVITY_TIMEOUT))
 					bestPath = bestNormalPath;
 				else bestPath = bestTcpOutPath;
 			} else { // TCP tunneling is disabled, use normal path
@@ -171,9 +171,9 @@ Path::Type Peer::send(const RuntimeEnvironment *_r,const void *data,unsigned int
 	if (!bestPath)
 		return Path::PATH_TYPE_NULL;
 
-	_r->antiRec->logOutgoingZT(data,len);
+	RR->antiRec->logOutgoingZT(data,len);
 
-	if (_r->sm->send(bestPath->address(),bestPath->tcp(),bestPath->type() == Path::PATH_TYPE_TCP_OUT,data,len)) {
+	if (RR->sm->send(bestPath->address(),bestPath->tcp(),bestPath->type() == Path::PATH_TYPE_TCP_OUT,data,len)) {
 		bestPath->sent(now);
 		return bestPath->type();
 	}
@@ -181,7 +181,7 @@ Path::Type Peer::send(const RuntimeEnvironment *_r,const void *data,unsigned int
 	return Path::PATH_TYPE_NULL;
 }
 
-bool Peer::sendPing(const RuntimeEnvironment *_r,uint64_t now)
+bool Peer::sendPing(const RuntimeEnvironment *RR,uint64_t now)
 {
 	bool sent = false;
 	SharedPtr<Peer> self(this);
@@ -200,14 +200,14 @@ bool Peer::sendPing(const RuntimeEnvironment *_r,uint64_t now)
 			haveNormal = true;
 		}
 	}
-	const bool useTcpOut = ( (!haveNormal) || ( (_r->tcpTunnelingEnabled) && (lastNormalPingSent > _r->timeOfLastResynchronize) && (lastNormalPingSent > lastNormalReceive) && ((lastNormalPingSent - lastNormalReceive) >= ZT_TCP_TUNNEL_FAILOVER_TIMEOUT) ) );
+	const bool useTcpOut = ( (!haveNormal) || ( (RR->tcpTunnelingEnabled) && (lastNormalPingSent > RR->timeOfLastResynchronize) && (lastNormalPingSent > lastNormalReceive) && ((lastNormalPingSent - lastNormalReceive) >= ZT_TCP_TUNNEL_FAILOVER_TIMEOUT) ) );
 
 	TRACE("PING %s (useTcpOut==%d)",_id.address().toString().c_str(),(int)useTcpOut);
 
 	for(std::vector<Path>::iterator p(_paths.begin());p!=_paths.end();++p) {
 		if ((useTcpOut)||(p->type() != Path::PATH_TYPE_TCP_OUT)) {
 			p->pinged(now); // attempts to ping are logged whether they look successful or not
-			if (_r->sw->sendHELLO(self,*p)) {
+			if (RR->sw->sendHELLO(self,*p)) {
 				p->sent(now);
 				sent = true;
 			}

node/Peer.hpp

@@ -118,7 +118,7 @@ public:
 	 * @param now Current time
 	 */
 	void receive(
-		const RuntimeEnvironment *_r,
+		const RuntimeEnvironment *RR,
 		const SharedPtr<Socket> &fromSock,
 		const InetAddress &remoteAddr,
 		unsigned int hops,
@@ -140,7 +140,7 @@ public:
 	 * @param now Current time
 	 * @return Type of path used or Path::PATH_TYPE_NULL on failure
 	 */
-	Path::Type send(const RuntimeEnvironment *_r,const void *data,unsigned int len,uint64_t now);
+	Path::Type send(const RuntimeEnvironment *RR,const void *data,unsigned int len,uint64_t now);
 
 	/**
 	 * Send HELLO to a peer via all direct paths available
@@ -152,7 +152,7 @@ public:
 	 * @param now Current time
 	 * @return True if send appears successful for at least one address type
 	 */
-	bool sendPing(const RuntimeEnvironment *_r,uint64_t now);
+	bool sendPing(const RuntimeEnvironment *RR,uint64_t now);
 
 	/**
 	 * Called periodically by Topology::clean() to remove stale paths and do other cleanup

node/Service.cpp

@@ -139,9 +139,9 @@ void Service::threadMain()
 				dup2(in[0],STDIN_FILENO);
 				dup2(out[1],STDOUT_FILENO);
 				dup2(err[1],STDERR_FILENO);
-				setenv("ZT_HOME",_r->homePath.c_str(),1);
-				chdir(_r->homePath.c_str());
-				execl(_path.c_str(),_path.c_str(),_r->homePath.c_str(),(const char *)0);
+				setenv("ZT_HOME",RR->homePath.c_str(),1);
+				chdir(RR->homePath.c_str());
+				execl(_path.c_str(),_path.c_str(),RR->homePath.c_str(),(const char *)0);
 				exit(-1);
 			}
 		} else {

node/Service.hpp

@@ -99,7 +99,7 @@ public:
 		throw();
 
 private:
-	const RuntimeEnvironment *_r;
+	const RuntimeEnvironment *RR;
 
 	Thread _thread;
 

node/SoftwareUpdater.cpp

@@ -79,7 +79,7 @@ SoftwareUpdater::~SoftwareUpdater()
 
 void SoftwareUpdater::cleanOldUpdates()
 {
-	std::string updatesDir(_r->homePath + ZT_PATH_SEPARATOR_S + "updates.d");
+	std::string updatesDir(RR->homePath + ZT_PATH_SEPARATOR_S + "updates.d");
 	std::map<std::string,bool> dl(Utils::listDirectory(updatesDir.c_str()));
 	for(std::map<std::string,bool>::iterator i(dl.begin());i!=dl.end();++i) {
 		if (!i->second)
@@ -97,7 +97,7 @@ void SoftwareUpdater::sawRemoteVersion(unsigned int vmaj,unsigned int vmin,unsig
 			if ((now - _lastUpdateAttempt) >= ZT_UPDATE_MIN_INTERVAL) {
 				_lastUpdateAttempt = now;
 				_status = UPDATE_STATUS_GETTING_NFO;
-				_r->http->GET(ZT_DEFAULTS.updateLatestNfoURL,HttpClient::NO_HEADERS,ZT_UPDATE_HTTP_TIMEOUT,&_cbHandleGetLatestVersionInfo,this);
+				RR->http->GET(ZT_DEFAULTS.updateLatestNfoURL,HttpClient::NO_HEADERS,ZT_UPDATE_HTTP_TIMEOUT,&_cbHandleGetLatestVersionInfo,this);
 			}
 		}
 	}
@@ -109,7 +109,7 @@ void SoftwareUpdater::checkNow()
 	if (_status == UPDATE_STATUS_IDLE) {
 		_lastUpdateAttempt = Utils::now();
 		_status = UPDATE_STATUS_GETTING_NFO;
-		_r->http->GET(ZT_DEFAULTS.updateLatestNfoURL,HttpClient::NO_HEADERS,ZT_UPDATE_HTTP_TIMEOUT,&_cbHandleGetLatestVersionInfo,this);
+		RR->http->GET(ZT_DEFAULTS.updateLatestNfoURL,HttpClient::NO_HEADERS,ZT_UPDATE_HTTP_TIMEOUT,&_cbHandleGetLatestVersionInfo,this);
 	}
 }
 
@@ -158,7 +158,7 @@ bool SoftwareUpdater::validateUpdate(
 void SoftwareUpdater::_cbHandleGetLatestVersionInfo(void *arg,int code,const std::string &url,const std::string &body)
 {
 	SoftwareUpdater *upd = (SoftwareUpdater *)arg;
-	const RuntimeEnvironment *_r = (const RuntimeEnvironment *)upd->_r;
+	const RuntimeEnvironment *RR = (const RuntimeEnvironment *)upd->_r;
 	Mutex::Lock _l(upd->_lock);
 
 	if ((upd->_die)||(upd->_status != UPDATE_STATUS_GETTING_NFO)) {
@@ -203,7 +203,7 @@ void SoftwareUpdater::_cbHandleGetLatestVersionInfo(void *arg,int code,const std
 		upd->_signedBy = signedBy;
 		upd->_signature = signature;
 
-		_r->http->GET(url,HttpClient::NO_HEADERS,ZT_UPDATE_HTTP_TIMEOUT,&_cbHandleGetLatestVersionBinary,arg);
+		RR->http->GET(url,HttpClient::NO_HEADERS,ZT_UPDATE_HTTP_TIMEOUT,&_cbHandleGetLatestVersionBinary,arg);
 	} catch ( ... ) {
 		LOG("software update check failed: .nfo file invalid or missing field(s)");
 		upd->_status = UPDATE_STATUS_IDLE;
@@ -213,7 +213,7 @@ void SoftwareUpdater::_cbHandleGetLatestVersionInfo(void *arg,int code,const std
 void SoftwareUpdater::_cbHandleGetLatestVersionBinary(void *arg,int code,const std::string &url,const std::string &body)
 {
 	SoftwareUpdater *upd = (SoftwareUpdater *)arg;
-	const RuntimeEnvironment *_r = (const RuntimeEnvironment *)upd->_r;
+	const RuntimeEnvironment *RR = (const RuntimeEnvironment *)upd->_r;
 	Mutex::Lock _l(upd->_lock);
 
 	if (!validateUpdate(body.data(),(unsigned int)body.length(),upd->_signedBy,upd->_signature)) {
@@ -228,7 +228,7 @@ void SoftwareUpdater::_cbHandleGetLatestVersionBinary(void *arg,int code,const s
 		upd->_status = UPDATE_STATUS_IDLE;
 		return;
 	}
-	std::string updatesDir(_r->homePath + ZT_PATH_SEPARATOR_S + "updates.d");
+	std::string updatesDir(RR->homePath + ZT_PATH_SEPARATOR_S + "updates.d");
 	std::string updateFilename(url.substr(lastSlash + 1));
 	if ((updateFilename.length() < 3)||(updateFilename.find("..") != std::string::npos)) {
 		LOG("software update failed: invalid URL: filename contains invalid characters");
@@ -274,7 +274,7 @@ void SoftwareUpdater::_cbHandleGetLatestVersionBinary(void *arg,int code,const s
 	// caller's responsibility (main.c) to pick this up and do the right
 	// thing.
 	upd->_status = UPDATE_STATUS_IDLE;
-	_r->node->terminate(Node::NODE_RESTART_FOR_UPGRADE,updatePath.c_str());
+	RR->node->terminate(Node::NODE_RESTART_FOR_UPGRADE,updatePath.c_str());
 }
 
 } // namespace ZeroTier

node/SoftwareUpdater.hpp

@@ -147,7 +147,7 @@ private:
 	static void _cbHandleGetLatestVersionInfo(void *arg,int code,const std::string &url,const std::string &body);
 	static void _cbHandleGetLatestVersionBinary(void *arg,int code,const std::string &url,const std::string &body);
 
-	const RuntimeEnvironment *_r;
+	const RuntimeEnvironment *RR;
 	const uint64_t _myVersion;
 	volatile uint64_t _lastUpdateAttempt;
 	volatile enum {

node/Switch.cpp

@@ -96,7 +96,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 	 * Note: even when we introduce a more purposeful binding of the main UDP port, this can
 	 * still happen because Windows likes to send broadcasts over interfaces that have little
 	 * to do with their intended target audience. :P */
-	if (!_r->antiRec->checkEthernetFrame(data.data(),data.size())) {
+	if (!RR->antiRec->checkEthernetFrame(data.data(),data.size())) {
 		TRACE("%s: rejected recursively addressed ZeroTier packet by tail match (type %s, length: %u)",network->tapDeviceName().c_str(),etherTypeName(etherType),data.size());
 		return;
 	}
@@ -110,7 +110,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 	// Check if this packet is from someone other than the tap -- i.e. bridged in
 	bool fromBridged = false;
 	if (from != network->mac()) {
-		if (!network->permitsBridging(_r->identity.address())) {
+		if (!network->permitsBridging(RR->identity.address())) {
 			LOG("%s: %s -> %s %s not forwarded, bridging disabled on %.16llx or this peer not a bridge",network->tapDeviceName().c_str(),from.toString().c_str(),to.toString().c_str(),etherTypeName(etherType),network->id());
 			return;
 		}
@@ -143,7 +143,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 			network->learnBridgedMulticastGroup(mg,now);
 
 		// Check multicast/broadcast bandwidth quotas and reject if quota exceeded
-		if (!network->updateAndCheckMulticastBalance(_r->identity.address(),mg,data.size())) {
+		if (!network->updateAndCheckMulticastBalance(RR->identity.address(),mg,data.size())) {
 			TRACE("%s: didn't multicast %d bytes, quota exceeded for multicast group %s",network->tapDeviceName().c_str(),(int)data.size(),mg.toString().c_str());
 			return;
 		}
@@ -152,12 +152,12 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 
 		/* old P5 multicast algorithm
 		const unsigned int mcid = ++_multicastIdCounter & 0xffffff;
-		const uint16_t bloomNonce = (uint16_t)(_r->prng->next32() & 0xffff); // doesn't need to be cryptographically strong
+		const uint16_t bloomNonce = (uint16_t)(RR->prng->next32() & 0xffff); // doesn't need to be cryptographically strong
 		unsigned char bloom[ZT_PROTO_VERB_MULTICAST_FRAME_LEN_PROPAGATION_BLOOM];
 		unsigned char fifo[ZT_PROTO_VERB_MULTICAST_FRAME_LEN_PROPAGATION_FIFO + ZT_ADDRESS_LENGTH]; // extra ZT_ADDRESS_LENGTH is for first hop, not put in packet but serves as destination for packet
 		unsigned char *const fifoEnd = fifo + sizeof(fifo);
 		const unsigned int signedPartLen = (ZT_PROTO_VERB_MULTICAST_FRAME_IDX_FRAME - ZT_PROTO_VERB_MULTICAST_FRAME_IDX__START_OF_SIGNED_PORTION) + data.size();
-		const SharedPtr<Peer> supernode(_r->topology->getBestSupernode());
+		const SharedPtr<Peer> supernode(RR->topology->getBestSupernode());
 
 		// For each bit prefix send a packet to a list of destinations within it
 		for(unsigned int prefix=0,np=((unsigned int)2 << (nconf->multicastPrefixBits() - 1));prefix<np;++prefix) {
@@ -170,16 +170,16 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 				fifoEnd,
 				bloom,
 				bloomNonce,
-				_r->identity.address(),
+				RR->identity.address(),
 				nconf->multicastPrefixBits(),
 				prefix,
-				_r->topology,
+				RR->topology,
 				now);
 			for(std::set<Address>::const_iterator ab(nconf->activeBridges().begin());ab!=nconf->activeBridges().end();++ab) {
 				if (!appender(*ab))
 					break;
 			}
-			_r->mc->getNextHops(network->id(),mg,appender);
+			RR->mc->getNextHops(network->id(),mg,appender);
 
 			// Pad remainder of FIFO with zeroes
 			while (fifoPtr != fifoEnd)
@@ -193,7 +193,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 				else continue; // nowhere to go
 			}
 
-			Packet outp(firstHop,_r->identity.address(),Packet::VERB_MULTICAST_FRAME);
+			Packet outp(firstHop,RR->identity.address(),Packet::VERB_MULTICAST_FRAME);
 			outp.append((uint16_t)0);
 			outp.append(fifo + ZT_ADDRESS_LENGTH,ZT_PROTO_VERB_MULTICAST_FRAME_LEN_PROPAGATION_FIFO); // remainder of fifo is loaded into packet
 			outp.append(bloom,ZT_PROTO_VERB_MULTICAST_FRAME_LEN_PROPAGATION_BLOOM);
@@ -202,7 +202,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 			outp.append(bloomNonce);
 			outp.append((unsigned char)nconf->multicastPrefixBits());
 			outp.append((unsigned char)prefix);
-			_r->identity.address().appendTo(outp); // lower 40 bits of MCID are my address
+			RR->identity.address().appendTo(outp); // lower 40 bits of MCID are my address
 			outp.append((unsigned char)((mcid >> 16) & 0xff));
 			outp.append((unsigned char)((mcid >> 8) & 0xff));
 			outp.append((unsigned char)(mcid & 0xff)); // upper 24 bits of MCID are from our counter
@@ -213,7 +213,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 			outp.append((uint16_t)data.size());
 			outp.append(data);
 
-			C25519::Signature sig(_r->identity.sign(outp.field(ZT_PROTO_VERB_MULTICAST_FRAME_IDX__START_OF_SIGNED_PORTION,signedPartLen),signedPartLen));
+			C25519::Signature sig(RR->identity.sign(outp.field(ZT_PROTO_VERB_MULTICAST_FRAME_IDX__START_OF_SIGNED_PORTION,signedPartLen),signedPartLen));
 			outp.append((uint16_t)sig.size());
 			outp.append(sig.data,(unsigned int)sig.size());
 
@@ -240,7 +240,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 
 			if (fromBridged) {
 				// Must use EXT_FRAME if source is not myself
-				Packet outp(toZT,_r->identity.address(),Packet::VERB_EXT_FRAME);
+				Packet outp(toZT,RR->identity.address(),Packet::VERB_EXT_FRAME);
 				outp.append(network->id());
 				outp.append((unsigned char)0);
 				to.appendTo(outp);
@@ -251,7 +251,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 				send(outp,true);
 			} else {
 				// VERB_FRAME is really just lighter weight EXT_FRAME, can use for direct-to-direct (before bridging this was the only unicast method)
-				Packet outp(toZT,_r->identity.address(),Packet::VERB_FRAME);
+				Packet outp(toZT,RR->identity.address(),Packet::VERB_FRAME);
 				outp.append(network->id());
 				outp.append((uint16_t)etherType);
 				outp.append(data);
@@ -272,7 +272,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 		unsigned int numBridges = 0;
 
 		bridges[0] = network->findBridgeTo(to);
-		if ((bridges[0])&&(bridges[0] != _r->identity.address())&&(network->isAllowed(bridges[0]))&&(network->permitsBridging(bridges[0]))) {
+		if ((bridges[0])&&(bridges[0] != RR->identity.address())&&(network->isAllowed(bridges[0]))&&(network->permitsBridging(bridges[0]))) {
 			// We have a known bridge route for this MAC.
 			++numBridges;
 		} else if (!nconf->activeBridges().empty()) {
@@ -294,7 +294,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 				while (numBridges < ZT_MAX_BRIDGE_SPAM) {
 					if (ab == nconf->activeBridges().end())
 						ab = nconf->activeBridges().begin();
-					if (((unsigned long)_r->prng->next32() % (unsigned long)nconf->activeBridges().size()) == 0) {
+					if (((unsigned long)RR->prng->next32() % (unsigned long)nconf->activeBridges().size()) == 0) {
 						if (network->isAllowed(*ab)) // config sanity check
 							bridges[numBridges++] = *ab;
 						++ab;
@@ -304,7 +304,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 		}
 
 		for(unsigned int b=0;b<numBridges;++b) {
-			Packet outp(bridges[b],_r->identity.address(),Packet::VERB_EXT_FRAME);
+			Packet outp(bridges[b],RR->identity.address(),Packet::VERB_EXT_FRAME);
 			outp.append(network->id());
 			outp.append((unsigned char)0);
 			to.appendTo(outp);
@@ -319,7 +319,7 @@ void Switch::onLocalEthernet(const SharedPtr<Network> &network,const MAC &from,c
 
 void Switch::send(const Packet &packet,bool encrypt)
 {
-	if (packet.destination() == _r->identity.address()) {
+	if (packet.destination() == RR->identity.address()) {
 		TRACE("BUG: caught attempt to send() to self, ignored");
 		return;
 	}
@@ -332,55 +332,55 @@ void Switch::send(const Packet &packet,bool encrypt)
 
 void Switch::sendHELLO(const Address &dest)
 {
-	Packet outp(dest,_r->identity.address(),Packet::VERB_HELLO);
+	Packet outp(dest,RR->identity.address(),Packet::VERB_HELLO);
 	outp.append((unsigned char)ZT_PROTO_VERSION);
 	outp.append((unsigned char)ZEROTIER_ONE_VERSION_MAJOR);
 	outp.append((unsigned char)ZEROTIER_ONE_VERSION_MINOR);
 	outp.append((uint16_t)ZEROTIER_ONE_VERSION_REVISION);
 	outp.append(Utils::now());
-	_r->identity.serialize(outp,false);
+	RR->identity.serialize(outp,false);
 	send(outp,false);
 }
 
 bool Switch::sendHELLO(const SharedPtr<Peer> &dest,const Path &path)
 {
 	uint64_t now = Utils::now();
-	Packet outp(dest->address(),_r->identity.address(),Packet::VERB_HELLO);
+	Packet outp(dest->address(),RR->identity.address(),Packet::VERB_HELLO);
 	outp.append((unsigned char)ZT_PROTO_VERSION);
 	outp.append((unsigned char)ZEROTIER_ONE_VERSION_MAJOR);
 	outp.append((unsigned char)ZEROTIER_ONE_VERSION_MINOR);
 	outp.append((uint16_t)ZEROTIER_ONE_VERSION_REVISION);
 	outp.append(now);
-	_r->identity.serialize(outp,false);
+	RR->identity.serialize(outp,false);
 	outp.armor(dest->key(),false);
-	_r->antiRec->logOutgoingZT(outp.data(),outp.size());
-	return _r->sm->send(path.address(),path.tcp(),path.type() == Path::PATH_TYPE_TCP_OUT,outp.data(),outp.size());
+	RR->antiRec->logOutgoingZT(outp.data(),outp.size());
+	return RR->sm->send(path.address(),path.tcp(),path.type() == Path::PATH_TYPE_TCP_OUT,outp.data(),outp.size());
 }
 
 bool Switch::sendHELLO(const SharedPtr<Peer> &dest,const InetAddress &destUdp)
 {
 	uint64_t now = Utils::now();
-	Packet outp(dest->address(),_r->identity.address(),Packet::VERB_HELLO);
+	Packet outp(dest->address(),RR->identity.address(),Packet::VERB_HELLO);
 	outp.append((unsigned char)ZT_PROTO_VERSION);
 	outp.append((unsigned char)ZEROTIER_ONE_VERSION_MAJOR);
 	outp.append((unsigned char)ZEROTIER_ONE_VERSION_MINOR);
 	outp.append((uint16_t)ZEROTIER_ONE_VERSION_REVISION);
 	outp.append(now);
-	_r->identity.serialize(outp,false);
+	RR->identity.serialize(outp,false);
 	outp.armor(dest->key(),false);
-	_r->antiRec->logOutgoingZT(outp.data(),outp.size());
-	return _r->sm->send(destUdp,false,false,outp.data(),outp.size());
+	RR->antiRec->logOutgoingZT(outp.data(),outp.size());
+	return RR->sm->send(destUdp,false,false,outp.data(),outp.size());
 }
 
 bool Switch::unite(const Address &p1,const Address &p2,bool force)
 {
-	if ((p1 == _r->identity.address())||(p2 == _r->identity.address()))
+	if ((p1 == RR->identity.address())||(p2 == RR->identity.address()))
 		return false;
 
-	SharedPtr<Peer> p1p = _r->topology->getPeer(p1);
+	SharedPtr<Peer> p1p = RR->topology->getPeer(p1);
 	if (!p1p)
 		return false;
-	SharedPtr<Peer> p2p = _r->topology->getPeer(p2);
+	SharedPtr<Peer> p2p = RR->topology->getPeer(p2);
 	if (!p2p)
 		return false;
 
@@ -420,12 +420,12 @@ bool Switch::unite(const Address &p1,const Address &p2,bool force)
 	 * the order we make each attempted NAT-t favor one or the other going
 	 * first, meaning if it doesn't succeed the first time it might the second
 	 * and so forth. */
-	unsigned int alt = _r->prng->next32() & 1;
+	unsigned int alt = RR->prng->next32() & 1;
 	unsigned int completed = alt + 2;
 	while (alt != completed) {
 		if ((alt & 1) == 0) {
 			// Tell p1 where to find p2.
-			Packet outp(p1,_r->identity.address(),Packet::VERB_RENDEZVOUS);
+			Packet outp(p1,RR->identity.address(),Packet::VERB_RENDEZVOUS);
 			outp.append((unsigned char)0);
 			p2.appendTo(outp);
 			outp.append((uint16_t)cg.first.port());
@@ -437,10 +437,10 @@ bool Switch::unite(const Address &p1,const Address &p2,bool force)
 				outp.append(cg.first.rawIpData(),4);
 			}
 			outp.armor(p1p->key(),true);
-			p1p->send(_r,outp.data(),outp.size(),now);
+			p1p->send(RR,outp.data(),outp.size(),now);
 		} else {
 			// Tell p2 where to find p1.
-			Packet outp(p2,_r->identity.address(),Packet::VERB_RENDEZVOUS);
+			Packet outp(p2,RR->identity.address(),Packet::VERB_RENDEZVOUS);
 			outp.append((unsigned char)0);
 			p1.appendTo(outp);
 			outp.append((uint16_t)cg.second.port());
@@ -452,7 +452,7 @@ bool Switch::unite(const Address &p1,const Address &p2,bool force)
 				outp.append(cg.second.rawIpData(),4);
 			}
 			outp.armor(p2p->key(),true);
-			p2p->send(_r,outp.data(),outp.size(),now);
+			p2p->send(RR,outp.data(),outp.size(),now);
 		}
 		++alt; // counts up and also flips LSB
 	}
@@ -474,13 +474,13 @@ void Switch::contact(const SharedPtr<Peer> &peer,const InetAddress &atAddr)
 
 	// Kick main loop out of wait so that it can pick up this
 	// change to our scheduled timer tasks.
-	_r->sm->whack();
+	RR->sm->whack();
 }
 
 void Switch::announceMulticastGroups(const std::map< SharedPtr<Network>,std::set<MulticastGroup> > &allMemberships)
 {
 	std::vector< SharedPtr<Peer> > directPeers;
-	_r->topology->eachPeer(Topology::CollectPeersWithActiveDirectPath(directPeers,Utils::now()));
+	RR->topology->eachPeer(Topology::CollectPeersWithActiveDirectPath(directPeers,Utils::now()));
 
 #ifdef ZT_TRACE
 	unsigned int totalMulticastGroups = 0;
@@ -491,16 +491,16 @@ void Switch::announceMulticastGroups(const std::map< SharedPtr<Network>,std::set
 
 	uint64_t now = Utils::now();
 	for(std::vector< SharedPtr<Peer> >::iterator p(directPeers.begin());p!=directPeers.end();++p) {
-		Packet outp((*p)->address(),_r->identity.address(),Packet::VERB_MULTICAST_LIKE);
+		Packet outp((*p)->address(),RR->identity.address(),Packet::VERB_MULTICAST_LIKE);
 
 		for(std::map< SharedPtr<Network>,std::set<MulticastGroup> >::const_iterator nwmgs(allMemberships.begin());nwmgs!=allMemberships.end();++nwmgs) {
 			nwmgs->first->pushMembershipCertificate((*p)->address(),false,now);
 
-			if ((_r->topology->isSupernode((*p)->address()))||(nwmgs->first->isAllowed((*p)->address()))) {
+			if ((RR->topology->isSupernode((*p)->address()))||(nwmgs->first->isAllowed((*p)->address()))) {
 				for(std::set<MulticastGroup>::iterator mg(nwmgs->second.begin());mg!=nwmgs->second.end();++mg) {
 					if ((outp.size() + 18) > ZT_UDP_DEFAULT_PAYLOAD_MTU) {
 						send(outp,true);
-						outp.reset((*p)->address(),_r->identity.address(),Packet::VERB_MULTICAST_LIKE);
+						outp.reset((*p)->address(),RR->identity.address(),Packet::VERB_MULTICAST_LIKE);
 					}
 
 					// network ID, MAC, ADI
@@ -518,18 +518,18 @@ void Switch::announceMulticastGroups(const std::map< SharedPtr<Network>,std::set
 
 void Switch::announceMulticastGroups(const SharedPtr<Peer> &peer)
 {
-	Packet outp(peer->address(),_r->identity.address(),Packet::VERB_MULTICAST_LIKE);
-	std::vector< SharedPtr<Network> > networks(_r->nc->networks());
+	Packet outp(peer->address(),RR->identity.address(),Packet::VERB_MULTICAST_LIKE);
+	std::vector< SharedPtr<Network> > networks(RR->nc->networks());
 	uint64_t now = Utils::now();
 	for(std::vector< SharedPtr<Network> >::iterator n(networks.begin());n!=networks.end();++n) {
-		if (((*n)->isAllowed(peer->address()))||(_r->topology->isSupernode(peer->address()))) {
+		if (((*n)->isAllowed(peer->address()))||(RR->topology->isSupernode(peer->address()))) {
 			(*n)->pushMembershipCertificate(peer->address(),false,now);
 
 			std::set<MulticastGroup> mgs((*n)->multicastGroups());
 			for(std::set<MulticastGroup>::iterator mg(mgs.begin());mg!=mgs.end();++mg) {
 				if ((outp.size() + 18) > ZT_UDP_DEFAULT_PAYLOAD_MTU) {
 					send(outp,true);
-					outp.reset(peer->address(),_r->identity.address(),Packet::VERB_MULTICAST_LIKE);
+					outp.reset(peer->address(),RR->identity.address(),Packet::VERB_MULTICAST_LIKE);
 				}
 
 				// network ID, MAC, ADI
@@ -702,19 +702,19 @@ void Switch::_handleRemotePacketFragment(const SharedPtr<Socket> &fromSock,const
 	Packet::Fragment fragment(data);
 	Address destination(fragment.destination());
 
-	if (destination != _r->identity.address()) {
+	if (destination != RR->identity.address()) {
 		// Fragment is not for us, so try to relay it
 		if (fragment.hops() < ZT_RELAY_MAX_HOPS) {
 			fragment.incrementHops();
 
 			// Note: we don't bother initiating NAT-t for fragments, since heads will set that off.
 			// It wouldn't hurt anything, just redundant and unnecessary.
-			SharedPtr<Peer> relayTo = _r->topology->getPeer(destination);
-			if ((!relayTo)||(relayTo->send(_r,fragment.data(),fragment.size(),Utils::now()) == Path::PATH_TYPE_NULL)) {
+			SharedPtr<Peer> relayTo = RR->topology->getPeer(destination);
+			if ((!relayTo)||(relayTo->send(RR,fragment.data(),fragment.size(),Utils::now()) == Path::PATH_TYPE_NULL)) {
 				// Don't know peer or no direct path -- so relay via supernode
-				relayTo = _r->topology->getBestSupernode();
+				relayTo = RR->topology->getBestSupernode();
 				if (relayTo)
-					relayTo->send(_r,fragment.data(),fragment.size(),Utils::now());
+					relayTo->send(RR,fragment.data(),fragment.size(),Utils::now());
 			}
 		} else {
 			TRACE("dropped relay [fragment](%s) -> %s, max hops exceeded",fromAddr.toString().c_str(),destination.toString().c_str());
@@ -778,14 +778,14 @@ void Switch::_handleRemotePacketHead(const SharedPtr<Socket> &fromSock,const Ine
 
 	//TRACE("<< %.16llx %s -> %s (size: %u)",(unsigned long long)packet->packetId(),source.toString().c_str(),destination.toString().c_str(),packet->size());
 
-	if (destination != _r->identity.address()) {
+	if (destination != RR->identity.address()) {
 		// Packet is not for us, so try to relay it
 		if (packet->hops() < ZT_RELAY_MAX_HOPS) {
 			packet->incrementHops();
 
-			SharedPtr<Peer> relayTo = _r->topology->getPeer(destination);
+			SharedPtr<Peer> relayTo = RR->topology->getPeer(destination);
 			Path::Type relayedVia;
-			if ((relayTo)&&((relayedVia = relayTo->send(_r,packet->data(),packet->size(),Utils::now())) != Path::PATH_TYPE_NULL)) {
+			if ((relayTo)&&((relayedVia = relayTo->send(RR,packet->data(),packet->size(),Utils::now())) != Path::PATH_TYPE_NULL)) {
 				/* If both paths are UDP, attempt to invoke UDP NAT-t between peers
 				 * by sending VERB_RENDEZVOUS. Do not do this for TCP due to GitHub
 				 * issue #63. */
@@ -793,9 +793,9 @@ void Switch::_handleRemotePacketHead(const SharedPtr<Socket> &fromSock,const Ine
 					unite(source,destination,false);
 			} else {
 				// Don't know peer or no direct path -- so relay via supernode
-				relayTo = _r->topology->getBestSupernode(&source,1,true);
+				relayTo = RR->topology->getBestSupernode(&source,1,true);
 				if (relayTo)
-					relayTo->send(_r,packet->data(),packet->size(),Utils::now());
+					relayTo->send(RR,packet->data(),packet->size(),Utils::now());
 			}
 		} else {
 			TRACE("dropped relay %s(%s) -> %s, max hops exceeded",packet->source().toString().c_str(),fromAddr.toString().c_str(),destination.toString().c_str());
@@ -847,14 +847,14 @@ void Switch::_handleRemotePacketHead(const SharedPtr<Socket> &fromSock,const Ine
 void Switch::_handleBeacon(const SharedPtr<Socket> &fromSock,const InetAddress &fromAddr,const Buffer<4096> &data)
 {
 	Address beaconAddr(data.field(ZT_PROTO_BEACON_IDX_ADDRESS,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH);
-	if (beaconAddr == _r->identity.address())
+	if (beaconAddr == RR->identity.address())
 		return;
-	SharedPtr<Peer> peer(_r->topology->getPeer(beaconAddr));
+	SharedPtr<Peer> peer(RR->topology->getPeer(beaconAddr));
 	if (peer) {
 		uint64_t now = Utils::now();
 		if (peer->haveUdpPath(fromAddr)) {
 			if ((now - peer->lastDirectReceive()) >= ZT_PEER_DIRECT_PING_DELAY)
-				peer->sendPing(_r,now);
+				peer->sendPing(RR,now);
 		} else {
 			if ((now - _lastBeacon) < ZT_MIN_BEACON_RESPONSE_INTERVAL)
 				return;
@@ -866,13 +866,13 @@ void Switch::_handleBeacon(const SharedPtr<Socket> &fromSock,const InetAddress &
 
 Address Switch::_sendWhoisRequest(const Address &addr,const Address *peersAlreadyConsulted,unsigned int numPeersAlreadyConsulted)
 {
-	SharedPtr<Peer> supernode(_r->topology->getBestSupernode(peersAlreadyConsulted,numPeersAlreadyConsulted,false));
+	SharedPtr<Peer> supernode(RR->topology->getBestSupernode(peersAlreadyConsulted,numPeersAlreadyConsulted,false));
 	if (supernode) {
-		Packet outp(supernode->address(),_r->identity.address(),Packet::VERB_WHOIS);
+		Packet outp(supernode->address(),RR->identity.address(),Packet::VERB_WHOIS);
 		addr.appendTo(outp);
 		outp.armor(supernode->key(),true);
 		uint64_t now = Utils::now();
-		if (supernode->send(_r,outp.data(),outp.size(),now) != Path::PATH_TYPE_NULL)
+		if (supernode->send(RR,outp.data(),outp.size(),now) != Path::PATH_TYPE_NULL)
 			return supernode->address();
 	}
 	return Address();
@@ -880,7 +880,7 @@ Address Switch::_sendWhoisRequest(const Address &addr,const Address *peersAlread
 
 bool Switch::_trySend(const Packet &packet,bool encrypt)
 {
-	SharedPtr<Peer> peer(_r->topology->getPeer(packet.destination()));
+	SharedPtr<Peer> peer(RR->topology->getPeer(packet.destination()));
 
 	if (peer) {
 		uint64_t now = Utils::now();
@@ -889,7 +889,7 @@ bool Switch::_trySend(const Packet &packet,bool encrypt)
 		if (peer->hasActiveDirectPath(now)) {
 			via = peer;
 		} else {
-			via = _r->topology->getBestSupernode();
+			via = RR->topology->getBestSupernode();
 			if (!via)
 				return false;
 		}
@@ -901,7 +901,7 @@ bool Switch::_trySend(const Packet &packet,bool encrypt)
 
 		tmp.armor(peer->key(),encrypt);
 
-		if (via->send(_r,tmp.data(),chunkSize,now) != Path::PATH_TYPE_NULL) {
+		if (via->send(RR,tmp.data(),chunkSize,now) != Path::PATH_TYPE_NULL) {
 			if (chunkSize < tmp.size()) {
 				// Too big for one bite, fragment the rest
 				unsigned int fragStart = chunkSize;
@@ -914,7 +914,7 @@ bool Switch::_trySend(const Packet &packet,bool encrypt)
 				for(unsigned int f=0;f<fragsRemaining;++f) {
 					chunkSize = std::min(remaining,(unsigned int)(ZT_UDP_DEFAULT_PAYLOAD_MTU - ZT_PROTO_MIN_FRAGMENT_LENGTH));
 					Packet::Fragment frag(tmp,fragStart,chunkSize,f + 1,totalFragments);
-					via->send(_r,frag.data(),frag.size(),now);
+					via->send(RR,frag.data(),frag.size(),now);
 					fragStart += chunkSize;
 					remaining -= chunkSize;
 				}

node/Topology.cpp

@@ -39,11 +39,11 @@
 namespace ZeroTier {
 
 Topology::Topology(const RuntimeEnvironment *renv,bool enablePermanentIdCaching) :
-	_r(renv),
+	RR(renv),
 	_amSupernode(false)
 {
 	if (enablePermanentIdCaching)
-		_idCacheBase = (_r->homePath + ZT_PATH_SEPARATOR_S + "iddb.d");
+		_idCacheBase = (RR->homePath + ZT_PATH_SEPARATOR_S + "iddb.d");
 	_loadPeers();
 }
 
@@ -66,10 +66,10 @@ void Topology::setSupernodes(const std::map< Identity,std::vector< std::pair<Ine
 	uint64_t now = Utils::now();
 
 	for(std::map< Identity,std::vector< std::pair<InetAddress,bool> > >::const_iterator i(sn.begin());i!=sn.end();++i) {
-		if (i->first != _r->identity) {
+		if (i->first != RR->identity) {
 			SharedPtr<Peer> p(getPeer(i->first.address()));
 			if (!p)
-				p = addPeer(SharedPtr<Peer>(new Peer(_r->identity,i->first)));
+				p = addPeer(SharedPtr<Peer>(new Peer(RR->identity,i->first)));
 			for(std::vector< std::pair<InetAddress,bool> >::const_iterator j(i->second.begin());j!=i->second.end();++j)
 				p->addPath(Path(j->first,(j->second) ? Path::PATH_TYPE_TCP_OUT : Path::PATH_TYPE_UDP,true));
 			p->use(now);
@@ -78,7 +78,7 @@ void Topology::setSupernodes(const std::map< Identity,std::vector< std::pair<Ine
 		_supernodeAddresses.insert(i->first.address());
 	}
 
-	_amSupernode = (_supernodes.find(_r->identity) != _supernodes.end());
+	_amSupernode = (_supernodes.find(RR->identity) != _supernodes.end());
 }
 
 void Topology::setSupernodes(const Dictionary &sn)
@@ -104,7 +104,7 @@ void Topology::setSupernodes(const Dictionary &sn)
 
 SharedPtr<Peer> Topology::addPeer(const SharedPtr<Peer> &peer)
 {
-	if (peer->address() == _r->identity.address()) {
+	if (peer->address() == RR->identity.address()) {
 		TRACE("BUG: addNewPeer() caught and ignored attempt to add peer for self");
 		throw std::logic_error("cannot add peer for self");
 	}
@@ -118,7 +118,7 @@ SharedPtr<Peer> Topology::addPeer(const SharedPtr<Peer> &peer)
 
 SharedPtr<Peer> Topology::getPeer(const Address &zta) const
 {
-	if (zta == _r->identity.address()) {
+	if (zta == RR->identity.address()) {
 		TRACE("BUG: ignored attempt to getPeer() for self, returned NULL");
 		return SharedPtr<Peer>();
 	}
@@ -171,12 +171,12 @@ SharedPtr<Peer> Topology::getBestSupernode(const Address *avoid,unsigned int avo
 		 * circumnavigate the globe rather than bouncing between just two. */
 
 		if (_supernodeAddresses.size() > 1) { // gotta be one other than me for this to work
-			std::set<Address>::const_iterator sna(_supernodeAddresses.find(_r->identity.address()));
+			std::set<Address>::const_iterator sna(_supernodeAddresses.find(RR->identity.address()));
 			if (sna != _supernodeAddresses.end()) { // sanity check -- _amSupernode should've been false in this case
 				for(;;) {
 					if (++sna == _supernodeAddresses.end())
 						sna = _supernodeAddresses.begin(); // wrap around at end
-					if (*sna != _r->identity.address()) { // pick one other than us -- starting from me+1 in sorted set order
+					if (*sna != RR->identity.address()) { // pick one other than us -- starting from me+1 in sorted set order
 						SharedPtr<Peer> p(getPeer(*sna));
 						if ((p)&&(p->hasActiveDirectPath(now))) {
 							bestSupernode = p;
@@ -292,7 +292,7 @@ bool Topology::authenticateRootTopology(const Dictionary &rt)
 void Topology::_dumpPeers()
 {
 	Buffer<ZT_PEER_WRITE_BUF_SIZE> buf;
-	std::string pdpath(_r->homePath + ZT_PATH_SEPARATOR_S + "peers.persist");
+	std::string pdpath(RR->homePath + ZT_PATH_SEPARATOR_S + "peers.persist");
 	Mutex::Lock _l(_activePeers_m);
 
 	FILE *pd = fopen(pdpath.c_str(),"wb");
@@ -343,7 +343,7 @@ void Topology::_dumpPeers()
 void Topology::_loadPeers()
 {
 	Buffer<ZT_PEER_WRITE_BUF_SIZE> buf;
-	std::string pdpath(_r->homePath + ZT_PATH_SEPARATOR_S + "peers.persist");
+	std::string pdpath(RR->homePath + ZT_PATH_SEPARATOR_S + "peers.persist");
 	Mutex::Lock _l(_activePeers_m);
 
 	_activePeers.clear();

node/Topology.hpp

@@ -237,7 +237,7 @@ public:
 		PingPeersThatNeedPing(const RuntimeEnvironment *renv,uint64_t now) throw() :
 			_now(now),
 			_supernodeAddresses(renv->topology->supernodeAddresses()),
-			_r(renv) {}
+			RR(renv) {}
 
 		inline void operator()(Topology &t,const SharedPtr<Peer> &p)
 		{
@@ -249,14 +249,14 @@ public:
 			if ( (!_supernodeAddresses.count(p->address())) &&
 			     ((_now - p->lastFrame()) < ZT_PEER_PATH_ACTIVITY_TIMEOUT) &&
 			     ((_now - p->lastDirectReceive()) >= ZT_PEER_DIRECT_PING_DELAY) ) {
-				p->sendPing(_r,_now);
+				p->sendPing(RR,_now);
 			}
 		}
 
 	private:
 		uint64_t _now;
 		std::set<Address> _supernodeAddresses;
-		const RuntimeEnvironment *_r;
+		const RuntimeEnvironment *RR;
 	};
 
 	/**
@@ -273,7 +273,7 @@ public:
 	public:
 		PingSupernodesThatNeedPing(const RuntimeEnvironment *renv,uint64_t now) throw() :
 			_now(now),
-			_r(renv) {}
+			RR(renv) {}
 
 		inline void operator()(Topology &t,const SharedPtr<Peer> &p)
 		{
@@ -284,13 +284,13 @@ public:
 			uint64_t lp = 0;
 			uint64_t lr = 0;
 			p->lastPingAndDirectReceive(lp,lr);
-			if ( (lr < _r->timeOfLastResynchronize) || ((lr < lp)&&((lp - lr) >= ZT_PING_UNANSWERED_AFTER)) || ((_now - lr) >= ZT_PEER_DIRECT_PING_DELAY) )
-				p->sendPing(_r,_now);
+			if ( (lr < RR->timeOfLastResynchronize) || ((lr < lp)&&((lp - lr) >= ZT_PING_UNANSWERED_AFTER)) || ((_now - lr) >= ZT_PEER_DIRECT_PING_DELAY) )
+				p->sendPing(RR,_now);
 		}
 
 	private:
 		uint64_t _now;
-		const RuntimeEnvironment *_r;
+		const RuntimeEnvironment *RR;
 	};
 
 	/**
@@ -315,23 +315,23 @@ public:
 			_now(now),
 			_supernode(renv->topology->getBestSupernode()),
 			_supernodeAddresses(renv->topology->supernodeAddresses()),
-			_r(renv) {}
+			RR(renv) {}
 
 		inline void operator()(Topology &t,const SharedPtr<Peer> &p)
 		{
 			p->clearPaths(false); // false means don't forget 'fixed' paths e.g. supernodes
 
-			Packet outp(p->address(),_r->identity.address(),Packet::VERB_NOP);
+			Packet outp(p->address(),RR->identity.address(),Packet::VERB_NOP);
 			outp.armor(p->key(),false); // no need to encrypt a NOP
 
 			if (_supernodeAddresses.count(p->address())) {
 				// Send NOP directly to supernodes
-				p->send(_r,outp.data(),outp.size(),_now);
+				p->send(RR,outp.data(),outp.size(),_now);
 			} else {
 				// Send NOP indirectly to regular peers if still active, triggering a new RENDEZVOUS
 				if (((_now - p->lastFrame()) < ZT_PEER_PATH_ACTIVITY_TIMEOUT)&&(_supernode)) {
 					TRACE("sending reset NOP to %s",p->address().toString().c_str());
-					_supernode->send(_r,outp.data(),outp.size(),_now);
+					_supernode->send(RR,outp.data(),outp.size(),_now);
 				}
 			}
 		}
@@ -340,7 +340,7 @@ public:
 		uint64_t _now;
 		SharedPtr<Peer> _supernode;
 		std::set<Address> _supernodeAddresses;
-		const RuntimeEnvironment *_r;
+		const RuntimeEnvironment *RR;
 	};
 
 	/**
@@ -373,7 +373,7 @@ public:
 	static bool authenticateRootTopology(const Dictionary &rt);
 
 private:
-	const RuntimeEnvironment *const _r;
+	const RuntimeEnvironment *RR;
 
 	void _dumpPeers();
 	void _loadPeers();