2013-07-04 20:56:19 +00:00
|
|
|
/*
|
2015-02-17 21:11:34 +00:00
|
|
|
* ZeroTier One - Network Virtualization Everywhere
|
2017-04-28 03:47:25 +00:00
|
|
|
* Copyright (C) 2011-2017 ZeroTier, Inc. https://www.zerotier.com/
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2017-04-28 03:47:25 +00:00
|
|
|
*
|
|
|
|
* --
|
|
|
|
*
|
|
|
|
* You can be released from the requirements of the license by purchasing
|
|
|
|
* a commercial license. Buying such a license is mandatory as soon as you
|
|
|
|
* develop commercial closed-source software that incorporates or links
|
|
|
|
* directly against ZeroTier software without disclosing the source code
|
|
|
|
* of your own application.
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2013-08-12 20:57:34 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#include <algorithm>
|
|
|
|
#include <utility>
|
|
|
|
#include <stdexcept>
|
|
|
|
|
2015-04-03 20:14:37 +00:00
|
|
|
#include "../version.h"
|
|
|
|
#include "../include/ZeroTierOne.h"
|
2013-08-13 01:25:36 +00:00
|
|
|
|
2015-04-03 20:14:37 +00:00
|
|
|
#include "Constants.hpp"
|
2015-04-03 23:52:53 +00:00
|
|
|
#include "RuntimeEnvironment.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "Switch.hpp"
|
|
|
|
#include "Node.hpp"
|
|
|
|
#include "InetAddress.hpp"
|
|
|
|
#include "Topology.hpp"
|
|
|
|
#include "Peer.hpp"
|
2015-07-28 18:28:47 +00:00
|
|
|
#include "SelfAwareness.hpp"
|
2015-04-03 23:52:53 +00:00
|
|
|
#include "Packet.hpp"
|
2017-07-07 23:58:05 +00:00
|
|
|
#include "Trace.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
namespace ZeroTier {
|
|
|
|
|
|
|
|
Switch::Switch(const RuntimeEnvironment *renv) :
|
2015-07-13 15:33:02 +00:00
|
|
|
RR(renv),
|
2015-09-04 22:35:43 +00:00
|
|
|
_lastBeaconResponse(0),
|
|
|
|
_outstandingWhoisRequests(32),
|
|
|
|
_lastUniteAttempt(8) // only really used on root servers and upstreams, and it'll grow there just fine
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-07-06 18:45:22 +00:00
|
|
|
void Switch::onRemotePacket(void *tPtr,const int64_t localSocket,const InetAddress &fromAddr,const void *data,unsigned int len)
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
|
|
|
try {
|
2016-03-18 21:16:07 +00:00
|
|
|
const uint64_t now = RR->node->now();
|
|
|
|
|
2017-07-17 20:48:39 +00:00
|
|
|
const SharedPtr<Path> path(RR->topology->getPath(localSocket,fromAddr));
|
2016-09-01 22:43:07 +00:00
|
|
|
path->received(now);
|
|
|
|
|
2015-07-13 15:33:02 +00:00
|
|
|
if (len == 13) {
|
|
|
|
/* LEGACY: before VERB_PUSH_DIRECT_PATHS, peers used broadcast
|
|
|
|
* announcements on the LAN to solve the 'same network problem.' We
|
|
|
|
* no longer send these, but we'll listen for them for a while to
|
|
|
|
* locate peers with versions <1.0.4. */
|
2016-03-18 21:16:07 +00:00
|
|
|
|
2017-02-01 23:22:14 +00:00
|
|
|
const Address beaconAddr(reinterpret_cast<const char *>(data) + 8,5);
|
2015-07-13 15:33:02 +00:00
|
|
|
if (beaconAddr == RR->identity.address())
|
|
|
|
return;
|
2017-07-06 18:45:22 +00:00
|
|
|
if (!RR->node->shouldUsePathForZeroTierTraffic(tPtr,beaconAddr,localSocket,fromAddr))
|
2016-01-11 23:57:58 +00:00
|
|
|
return;
|
2017-03-28 00:03:17 +00:00
|
|
|
const SharedPtr<Peer> peer(RR->topology->getPeer(tPtr,beaconAddr));
|
2015-07-13 15:33:02 +00:00
|
|
|
if (peer) { // we'll only respond to beacons from known peers
|
|
|
|
if ((now - _lastBeaconResponse) >= 2500) { // limit rate of responses
|
|
|
|
_lastBeaconResponse = now;
|
|
|
|
Packet outp(peer->address(),RR->identity.address(),Packet::VERB_NOP);
|
2017-03-01 18:22:57 +00:00
|
|
|
outp.armor(peer->key(),true,path->nextOutgoingCounter());
|
2017-03-28 00:03:17 +00:00
|
|
|
path->send(RR,tPtr,outp.data(),outp.size(),now);
|
2015-07-13 15:33:02 +00:00
|
|
|
}
|
|
|
|
}
|
2016-03-18 21:16:07 +00:00
|
|
|
|
2016-09-01 20:45:32 +00:00
|
|
|
} else if (len > ZT_PROTO_MIN_FRAGMENT_LENGTH) { // SECURITY: min length check is important since we do some C-style stuff below!
|
2016-03-18 21:16:07 +00:00
|
|
|
if (reinterpret_cast<const uint8_t *>(data)[ZT_PACKET_FRAGMENT_IDX_FRAGMENT_INDICATOR] == ZT_PACKET_FRAGMENT_INDICATOR) {
|
|
|
|
// Handle fragment ----------------------------------------------------
|
|
|
|
|
|
|
|
Packet::Fragment fragment(data,len);
|
2016-03-18 21:32:48 +00:00
|
|
|
const Address destination(fragment.destination());
|
2016-03-18 21:16:07 +00:00
|
|
|
|
|
|
|
if (destination != RR->identity.address()) {
|
2017-07-06 17:25:36 +00:00
|
|
|
if ( (!RR->topology->amRoot()) && (!path->trustEstablished(now)) )
|
2017-01-27 22:05:09 +00:00
|
|
|
return;
|
2016-09-13 21:27:18 +00:00
|
|
|
|
2016-03-18 21:16:07 +00:00
|
|
|
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.
|
2017-03-28 00:03:17 +00:00
|
|
|
SharedPtr<Peer> relayTo = RR->topology->getPeer(tPtr,destination);
|
|
|
|
if ((!relayTo)||(!relayTo->sendDirect(tPtr,fragment.data(),fragment.size(),now,false))) {
|
2016-11-18 00:31:58 +00:00
|
|
|
// Don't know peer or no direct path -- so relay via someone upstream
|
|
|
|
relayTo = RR->topology->getUpstreamPeer();
|
2016-03-18 21:16:07 +00:00
|
|
|
if (relayTo)
|
2017-03-28 00:03:17 +00:00
|
|
|
relayTo->sendDirect(tPtr,fragment.data(),fragment.size(),now,true);
|
2016-03-18 21:16:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Fragment looks like ours
|
|
|
|
const uint64_t fragmentPacketId = fragment.packetId();
|
|
|
|
const unsigned int fragmentNumber = fragment.fragmentNumber();
|
|
|
|
const unsigned int totalFragments = fragment.totalFragments();
|
|
|
|
|
|
|
|
if ((totalFragments <= ZT_MAX_PACKET_FRAGMENTS)&&(fragmentNumber < ZT_MAX_PACKET_FRAGMENTS)&&(fragmentNumber > 0)&&(totalFragments > 1)) {
|
|
|
|
// Fragment appears basically sane. Its fragment number must be
|
|
|
|
// 1 or more, since a Packet with fragmented bit set is fragment 0.
|
|
|
|
// Total fragments must be more than 1, otherwise why are we
|
|
|
|
// seeing a Packet::Fragment?
|
|
|
|
|
|
|
|
Mutex::Lock _l(_rxQueue_m);
|
2016-04-06 23:28:40 +00:00
|
|
|
RXQueueEntry *const rq = _findRXQueueEntry(now,fragmentPacketId);
|
2016-03-18 21:16:07 +00:00
|
|
|
|
|
|
|
if ((!rq->timestamp)||(rq->packetId != fragmentPacketId)) {
|
|
|
|
// No packet found, so we received a fragment without its head.
|
|
|
|
|
|
|
|
rq->timestamp = now;
|
|
|
|
rq->packetId = fragmentPacketId;
|
|
|
|
rq->frags[fragmentNumber - 1] = fragment;
|
|
|
|
rq->totalFragments = totalFragments; // total fragment count is known
|
|
|
|
rq->haveFragments = 1 << fragmentNumber; // we have only this fragment
|
|
|
|
rq->complete = false;
|
|
|
|
} else if (!(rq->haveFragments & (1 << fragmentNumber))) {
|
|
|
|
// We have other fragments and maybe the head, so add this one and check
|
|
|
|
|
|
|
|
rq->frags[fragmentNumber - 1] = fragment;
|
|
|
|
rq->totalFragments = totalFragments;
|
|
|
|
|
|
|
|
if (Utils::countBits(rq->haveFragments |= (1 << fragmentNumber)) == totalFragments) {
|
|
|
|
// We have all fragments -- assemble and process full Packet
|
|
|
|
|
|
|
|
for(unsigned int f=1;f<totalFragments;++f)
|
|
|
|
rq->frag0.append(rq->frags[f - 1].payload(),rq->frags[f - 1].payloadLength());
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
if (rq->frag0.tryDecode(RR,tPtr)) {
|
2016-03-18 21:16:07 +00:00
|
|
|
rq->timestamp = 0; // packet decoded, free entry
|
|
|
|
} else {
|
|
|
|
rq->complete = true; // set complete flag but leave entry since it probably needs WHOIS or something
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // else this is a duplicate fragment, ignore
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
} else if (len >= ZT_PROTO_MIN_PACKET_LENGTH) { // min length check is important!
|
|
|
|
// Handle packet head -------------------------------------------------
|
|
|
|
|
|
|
|
const Address destination(reinterpret_cast<const uint8_t *>(data) + 8,ZT_ADDRESS_LENGTH);
|
|
|
|
const Address source(reinterpret_cast<const uint8_t *>(data) + 13,ZT_ADDRESS_LENGTH);
|
|
|
|
|
2017-02-01 22:18:56 +00:00
|
|
|
if (source == RR->identity.address())
|
|
|
|
return;
|
|
|
|
|
2016-03-18 21:16:07 +00:00
|
|
|
if (destination != RR->identity.address()) {
|
2017-02-01 22:35:07 +00:00
|
|
|
if ( (!RR->topology->amRoot()) && (!path->trustEstablished(now)) && (source != RR->identity.address()) )
|
2017-01-27 22:05:09 +00:00
|
|
|
return;
|
2016-09-13 21:27:18 +00:00
|
|
|
|
2016-03-18 21:16:07 +00:00
|
|
|
Packet packet(data,len);
|
|
|
|
|
|
|
|
if (packet.hops() < ZT_RELAY_MAX_HOPS) {
|
|
|
|
packet.incrementHops();
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
SharedPtr<Peer> relayTo = RR->topology->getPeer(tPtr,destination);
|
|
|
|
if ((relayTo)&&(relayTo->sendDirect(tPtr,packet.data(),packet.size(),now,false))) {
|
2017-02-04 08:04:44 +00:00
|
|
|
if ((source != RR->identity.address())&&(_shouldUnite(now,source,destination))) { // don't send RENDEZVOUS for cluster frontplane relays
|
|
|
|
const InetAddress *hintToSource = (InetAddress *)0;
|
|
|
|
const InetAddress *hintToDest = (InetAddress *)0;
|
|
|
|
|
|
|
|
InetAddress destV4,destV6;
|
|
|
|
InetAddress sourceV4,sourceV6;
|
|
|
|
relayTo->getRendezvousAddresses(now,destV4,destV6);
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
const SharedPtr<Peer> sourcePeer(RR->topology->getPeer(tPtr,source));
|
2017-02-04 08:04:44 +00:00
|
|
|
if (sourcePeer) {
|
|
|
|
sourcePeer->getRendezvousAddresses(now,sourceV4,sourceV6);
|
|
|
|
if ((destV6)&&(sourceV6)) {
|
|
|
|
hintToSource = &destV6;
|
|
|
|
hintToDest = &sourceV6;
|
|
|
|
} else if ((destV4)&&(sourceV4)) {
|
|
|
|
hintToSource = &destV4;
|
|
|
|
hintToDest = &sourceV4;
|
|
|
|
}
|
2017-02-04 07:54:02 +00:00
|
|
|
|
2017-02-04 08:04:44 +00:00
|
|
|
if ((hintToSource)&&(hintToDest)) {
|
|
|
|
unsigned int alt = (unsigned int)RR->node->prng() & 1; // randomize which hint we send first for obscure NAT-t reasons
|
|
|
|
const unsigned int completed = alt + 2;
|
|
|
|
while (alt != completed) {
|
|
|
|
if ((alt & 1) == 0) {
|
|
|
|
Packet outp(source,RR->identity.address(),Packet::VERB_RENDEZVOUS);
|
|
|
|
outp.append((uint8_t)0);
|
|
|
|
destination.appendTo(outp);
|
|
|
|
outp.append((uint16_t)hintToSource->port());
|
|
|
|
if (hintToSource->ss_family == AF_INET6) {
|
|
|
|
outp.append((uint8_t)16);
|
|
|
|
outp.append(hintToSource->rawIpData(),16);
|
|
|
|
} else {
|
|
|
|
outp.append((uint8_t)4);
|
|
|
|
outp.append(hintToSource->rawIpData(),4);
|
|
|
|
}
|
2017-03-28 00:03:17 +00:00
|
|
|
send(tPtr,outp,true);
|
2017-02-04 08:04:44 +00:00
|
|
|
} else {
|
|
|
|
Packet outp(destination,RR->identity.address(),Packet::VERB_RENDEZVOUS);
|
|
|
|
outp.append((uint8_t)0);
|
|
|
|
source.appendTo(outp);
|
|
|
|
outp.append((uint16_t)hintToDest->port());
|
|
|
|
if (hintToDest->ss_family == AF_INET6) {
|
|
|
|
outp.append((uint8_t)16);
|
|
|
|
outp.append(hintToDest->rawIpData(),16);
|
2017-02-04 07:54:02 +00:00
|
|
|
} else {
|
2017-02-04 08:04:44 +00:00
|
|
|
outp.append((uint8_t)4);
|
|
|
|
outp.append(hintToDest->rawIpData(),4);
|
2017-02-04 07:54:02 +00:00
|
|
|
}
|
2017-03-28 00:03:17 +00:00
|
|
|
send(tPtr,outp,true);
|
2017-02-04 07:54:02 +00:00
|
|
|
}
|
2017-02-04 08:04:44 +00:00
|
|
|
++alt;
|
2017-02-04 07:54:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-03-18 21:16:07 +00:00
|
|
|
}
|
|
|
|
} else {
|
2016-11-18 00:31:58 +00:00
|
|
|
relayTo = RR->topology->getUpstreamPeer(&source,1,true);
|
2016-03-18 21:16:07 +00:00
|
|
|
if (relayTo)
|
2017-03-28 00:03:17 +00:00
|
|
|
relayTo->sendDirect(tPtr,packet.data(),packet.size(),now,true);
|
2016-03-18 21:16:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if ((reinterpret_cast<const uint8_t *>(data)[ZT_PACKET_IDX_FLAGS] & ZT_PROTO_FLAG_FRAGMENTED) != 0) {
|
|
|
|
// Packet is the head of a fragmented packet series
|
|
|
|
|
2017-03-01 22:36:52 +00:00
|
|
|
const uint64_t packetId = (
|
|
|
|
(((uint64_t)reinterpret_cast<const uint8_t *>(data)[0]) << 56) |
|
|
|
|
(((uint64_t)reinterpret_cast<const uint8_t *>(data)[1]) << 48) |
|
|
|
|
(((uint64_t)reinterpret_cast<const uint8_t *>(data)[2]) << 40) |
|
|
|
|
(((uint64_t)reinterpret_cast<const uint8_t *>(data)[3]) << 32) |
|
|
|
|
(((uint64_t)reinterpret_cast<const uint8_t *>(data)[4]) << 24) |
|
|
|
|
(((uint64_t)reinterpret_cast<const uint8_t *>(data)[5]) << 16) |
|
|
|
|
(((uint64_t)reinterpret_cast<const uint8_t *>(data)[6]) << 8) |
|
|
|
|
((uint64_t)reinterpret_cast<const uint8_t *>(data)[7])
|
|
|
|
);
|
|
|
|
|
2016-03-18 21:16:07 +00:00
|
|
|
Mutex::Lock _l(_rxQueue_m);
|
2016-04-06 23:28:40 +00:00
|
|
|
RXQueueEntry *const rq = _findRXQueueEntry(now,packetId);
|
2016-03-18 21:16:07 +00:00
|
|
|
|
|
|
|
if ((!rq->timestamp)||(rq->packetId != packetId)) {
|
|
|
|
// If we have no other fragments yet, create an entry and save the head
|
|
|
|
|
|
|
|
rq->timestamp = now;
|
|
|
|
rq->packetId = packetId;
|
2016-09-02 18:51:33 +00:00
|
|
|
rq->frag0.init(data,len,path,now);
|
2016-03-18 21:16:07 +00:00
|
|
|
rq->totalFragments = 0;
|
|
|
|
rq->haveFragments = 1;
|
|
|
|
rq->complete = false;
|
|
|
|
} else if (!(rq->haveFragments & 1)) {
|
|
|
|
// If we have other fragments but no head, see if we are complete with the head
|
|
|
|
|
|
|
|
if ((rq->totalFragments > 1)&&(Utils::countBits(rq->haveFragments |= 1) == rq->totalFragments)) {
|
|
|
|
// We have all fragments -- assemble and process full Packet
|
|
|
|
|
2016-09-01 22:43:07 +00:00
|
|
|
rq->frag0.init(data,len,path,now);
|
2016-03-18 21:16:07 +00:00
|
|
|
for(unsigned int f=1;f<rq->totalFragments;++f)
|
|
|
|
rq->frag0.append(rq->frags[f - 1].payload(),rq->frags[f - 1].payloadLength());
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
if (rq->frag0.tryDecode(RR,tPtr)) {
|
2016-03-18 21:16:07 +00:00
|
|
|
rq->timestamp = 0; // packet decoded, free entry
|
|
|
|
} else {
|
|
|
|
rq->complete = true; // set complete flag but leave entry since it probably needs WHOIS or something
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Still waiting on more fragments, but keep the head
|
2016-09-01 22:43:07 +00:00
|
|
|
rq->frag0.init(data,len,path,now);
|
2016-03-18 21:16:07 +00:00
|
|
|
}
|
|
|
|
} // else this is a duplicate head, ignore
|
|
|
|
} else {
|
|
|
|
// Packet is unfragmented, so just process it
|
2016-09-01 22:43:07 +00:00
|
|
|
IncomingPacket packet(data,len,path,now);
|
2017-03-28 00:03:17 +00:00
|
|
|
if (!packet.tryDecode(RR,tPtr)) {
|
2016-03-18 21:16:07 +00:00
|
|
|
Mutex::Lock _l(_rxQueue_m);
|
|
|
|
RXQueueEntry *rq = &(_rxQueue[ZT_RX_QUEUE_SIZE - 1]);
|
|
|
|
unsigned long i = ZT_RX_QUEUE_SIZE - 1;
|
|
|
|
while ((i)&&(rq->timestamp)) {
|
|
|
|
RXQueueEntry *tmp = &(_rxQueue[--i]);
|
|
|
|
if (tmp->timestamp < rq->timestamp)
|
|
|
|
rq = tmp;
|
|
|
|
}
|
|
|
|
rq->timestamp = now;
|
2017-03-01 22:36:52 +00:00
|
|
|
rq->packetId = packet.packetId();
|
2016-03-18 21:16:07 +00:00
|
|
|
rq->frag0 = packet;
|
|
|
|
rq->totalFragments = 1;
|
|
|
|
rq->haveFragments = 1;
|
|
|
|
rq->complete = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------
|
2015-04-03 20:14:37 +00:00
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
2017-07-07 23:58:05 +00:00
|
|
|
} catch ( ... ) {} // sanity check, should be caught elsewhere
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
void Switch::onLocalEthernet(void *tPtr,const SharedPtr<Network> &network,const MAC &from,const MAC &to,unsigned int etherType,unsigned int vlanId,const void *data,unsigned int len)
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2016-04-12 19:49:46 +00:00
|
|
|
if (!network->hasConfig())
|
2013-10-18 17:20:34 +00:00
|
|
|
return;
|
|
|
|
|
2014-06-14 00:49:33 +00:00
|
|
|
// Check if this packet is from someone other than the tap -- i.e. bridged in
|
2016-10-05 17:12:06 +00:00
|
|
|
bool fromBridged;
|
|
|
|
if ((fromBridged = (from != network->mac()))) {
|
2016-04-12 19:49:46 +00:00
|
|
|
if (!network->config().permitsBridging(RR->identity.address())) {
|
2017-07-13 17:51:05 +00:00
|
|
|
RR->t->outgoingNetworkFrameDropped(tPtr,network,from,to,etherType,vlanId,len,"not a bridge");
|
2014-06-14 00:49:33 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (to.isMulticast()) {
|
2016-09-21 04:21:34 +00:00
|
|
|
MulticastGroup multicastGroup(to,0);
|
2014-03-26 04:38:54 +00:00
|
|
|
|
2014-06-14 00:49:33 +00:00
|
|
|
if (to.isBroadcast()) {
|
2015-11-03 18:46:41 +00:00
|
|
|
if ( (etherType == ZT_ETHERTYPE_ARP) && (len >= 28) && ((((const uint8_t *)data)[2] == 0x08)&&(((const uint8_t *)data)[3] == 0x00)&&(((const uint8_t *)data)[4] == 6)&&(((const uint8_t *)data)[5] == 4)&&(((const uint8_t *)data)[7] == 0x01)) ) {
|
|
|
|
/* IPv4 ARP is one of the few special cases that we impose upon what is
|
|
|
|
* otherwise a straightforward Ethernet switch emulation. Vanilla ARP
|
|
|
|
* is dumb old broadcast and simply doesn't scale. ZeroTier multicast
|
|
|
|
* groups have an additional field called ADI (additional distinguishing
|
|
|
|
* information) which was added specifically for ARP though it could
|
|
|
|
* be used for other things too. We then take ARP broadcasts and turn
|
|
|
|
* them into multicasts by stuffing the IP address being queried into
|
|
|
|
* the 32-bit ADI field. In practice this uses our multicast pub/sub
|
|
|
|
* system to implement a kind of extended/distributed ARP table. */
|
2016-09-21 04:21:34 +00:00
|
|
|
multicastGroup = MulticastGroup::deriveMulticastGroupForAddressResolution(InetAddress(((const unsigned char *)data) + 24,4,0));
|
2016-04-12 19:49:46 +00:00
|
|
|
} else if (!network->config().enableBroadcast()) {
|
2014-06-14 00:49:33 +00:00
|
|
|
// Don't transmit broadcasts if this network doesn't want them
|
2017-07-13 17:51:05 +00:00
|
|
|
RR->t->outgoingNetworkFrameDropped(tPtr,network,from,to,etherType,vlanId,len,"broadcast disabled");
|
2014-05-23 21:32:31 +00:00
|
|
|
return;
|
2013-09-27 20:03:13 +00:00
|
|
|
}
|
2015-11-03 18:46:41 +00:00
|
|
|
} else if ((etherType == ZT_ETHERTYPE_IPV6)&&(len >= (40 + 8 + 16))) {
|
2016-06-24 11:54:05 +00:00
|
|
|
// IPv6 NDP emulation for certain very special patterns of private IPv6 addresses -- if enabled
|
2016-06-24 05:41:14 +00:00
|
|
|
if ((network->config().ndpEmulation())&&(reinterpret_cast<const uint8_t *>(data)[6] == 0x3a)&&(reinterpret_cast<const uint8_t *>(data)[40] == 0x87)) { // ICMPv6 neighbor solicitation
|
|
|
|
Address v6EmbeddedAddress;
|
|
|
|
const uint8_t *const pkt6 = reinterpret_cast<const uint8_t *>(data) + 40 + 8;
|
|
|
|
const uint8_t *my6 = (const uint8_t *)0;
|
|
|
|
|
2016-06-24 12:21:25 +00:00
|
|
|
// ZT-RFC4193 address: fdNN:NNNN:NNNN:NNNN:NN99:93DD:DDDD:DDDD / 88 (one /128 per actual host)
|
2016-06-24 05:41:14 +00:00
|
|
|
|
2016-06-24 12:21:25 +00:00
|
|
|
// ZT-6PLANE address: fcXX:XXXX:XXDD:DDDD:DDDD:####:####:#### / 40 (one /80 per actual host)
|
2016-06-24 11:54:05 +00:00
|
|
|
// (XX - lower 32 bits of network ID XORed with higher 32 bits)
|
|
|
|
|
|
|
|
// For these to work, we must have a ZT-managed address assigned in one of the
|
|
|
|
// above formats, and the query must match its prefix.
|
2016-05-06 23:13:11 +00:00
|
|
|
for(unsigned int sipk=0;sipk<network->config().staticIpCount;++sipk) {
|
2016-06-24 11:54:05 +00:00
|
|
|
const InetAddress *const sip = &(network->config().staticIps[sipk]);
|
|
|
|
if (sip->ss_family == AF_INET6) {
|
2016-06-24 05:41:14 +00:00
|
|
|
my6 = reinterpret_cast<const uint8_t *>(reinterpret_cast<const struct sockaddr_in6 *>(&(*sip))->sin6_addr.s6_addr);
|
2016-06-24 11:54:05 +00:00
|
|
|
const unsigned int sipNetmaskBits = Utils::ntoh((uint16_t)reinterpret_cast<const struct sockaddr_in6 *>(&(*sip))->sin6_port);
|
2016-06-24 12:21:25 +00:00
|
|
|
if ((sipNetmaskBits == 88)&&(my6[0] == 0xfd)&&(my6[9] == 0x99)&&(my6[10] == 0x93)) { // ZT-RFC4193 /88 ???
|
2015-11-03 18:46:41 +00:00
|
|
|
unsigned int ptr = 0;
|
|
|
|
while (ptr != 11) {
|
|
|
|
if (pkt6[ptr] != my6[ptr])
|
|
|
|
break;
|
|
|
|
++ptr;
|
|
|
|
}
|
2016-06-24 12:21:25 +00:00
|
|
|
if (ptr == 11) { // prefix match!
|
2016-06-24 05:41:14 +00:00
|
|
|
v6EmbeddedAddress.setTo(pkt6 + ptr,5);
|
|
|
|
break;
|
|
|
|
}
|
2016-06-24 12:21:25 +00:00
|
|
|
} else if (sipNetmaskBits == 40) { // ZT-6PLANE /40 ???
|
2016-06-24 11:54:05 +00:00
|
|
|
const uint32_t nwid32 = (uint32_t)((network->id() ^ (network->id() >> 32)) & 0xffffffff);
|
2016-06-24 12:21:25 +00:00
|
|
|
if ( (my6[0] == 0xfc) && (my6[1] == (uint8_t)((nwid32 >> 24) & 0xff)) && (my6[2] == (uint8_t)((nwid32 >> 16) & 0xff)) && (my6[3] == (uint8_t)((nwid32 >> 8) & 0xff)) && (my6[4] == (uint8_t)(nwid32 & 0xff))) {
|
2016-06-24 11:54:05 +00:00
|
|
|
unsigned int ptr = 0;
|
|
|
|
while (ptr != 5) {
|
|
|
|
if (pkt6[ptr] != my6[ptr])
|
|
|
|
break;
|
|
|
|
++ptr;
|
|
|
|
}
|
2016-06-24 12:21:25 +00:00
|
|
|
if (ptr == 5) { // prefix match!
|
2016-06-24 11:54:05 +00:00
|
|
|
v6EmbeddedAddress.setTo(pkt6 + ptr,5);
|
2016-06-24 05:41:14 +00:00
|
|
|
break;
|
2016-06-24 11:54:05 +00:00
|
|
|
}
|
2015-11-03 18:46:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-06-24 05:41:14 +00:00
|
|
|
|
|
|
|
if ((v6EmbeddedAddress)&&(v6EmbeddedAddress != RR->identity.address())) {
|
|
|
|
const MAC peerMac(v6EmbeddedAddress,network->id());
|
|
|
|
|
|
|
|
uint8_t adv[72];
|
|
|
|
adv[0] = 0x60; adv[1] = 0x00; adv[2] = 0x00; adv[3] = 0x00;
|
|
|
|
adv[4] = 0x00; adv[5] = 0x20;
|
|
|
|
adv[6] = 0x3a; adv[7] = 0xff;
|
|
|
|
for(int i=0;i<16;++i) adv[8 + i] = pkt6[i];
|
|
|
|
for(int i=0;i<16;++i) adv[24 + i] = my6[i];
|
|
|
|
adv[40] = 0x88; adv[41] = 0x00;
|
|
|
|
adv[42] = 0x00; adv[43] = 0x00; // future home of checksum
|
|
|
|
adv[44] = 0x60; adv[45] = 0x00; adv[46] = 0x00; adv[47] = 0x00;
|
|
|
|
for(int i=0;i<16;++i) adv[48 + i] = pkt6[i];
|
|
|
|
adv[64] = 0x02; adv[65] = 0x01;
|
|
|
|
adv[66] = peerMac[0]; adv[67] = peerMac[1]; adv[68] = peerMac[2]; adv[69] = peerMac[3]; adv[70] = peerMac[4]; adv[71] = peerMac[5];
|
|
|
|
|
|
|
|
uint16_t pseudo_[36];
|
|
|
|
uint8_t *const pseudo = reinterpret_cast<uint8_t *>(pseudo_);
|
|
|
|
for(int i=0;i<32;++i) pseudo[i] = adv[8 + i];
|
|
|
|
pseudo[32] = 0x00; pseudo[33] = 0x00; pseudo[34] = 0x00; pseudo[35] = 0x20;
|
|
|
|
pseudo[36] = 0x00; pseudo[37] = 0x00; pseudo[38] = 0x00; pseudo[39] = 0x3a;
|
|
|
|
for(int i=0;i<32;++i) pseudo[40 + i] = adv[40 + i];
|
|
|
|
uint32_t checksum = 0;
|
|
|
|
for(int i=0;i<36;++i) checksum += Utils::hton(pseudo_[i]);
|
|
|
|
while ((checksum >> 16)) checksum = (checksum & 0xffff) + (checksum >> 16);
|
|
|
|
checksum = ~checksum;
|
|
|
|
adv[42] = (checksum >> 8) & 0xff;
|
|
|
|
adv[43] = checksum & 0xff;
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
RR->node->putFrame(tPtr,network->id(),network->userPtr(),peerMac,from,ZT_ETHERTYPE_IPV6,0,adv,72);
|
2016-06-24 11:54:05 +00:00
|
|
|
return; // NDP emulation done. We have forged a "fake" reply, so no need to send actual NDP query.
|
|
|
|
} // else no NDP emulation
|
|
|
|
} // else no NDP emulation
|
2014-06-14 00:49:33 +00:00
|
|
|
}
|
2013-09-12 16:11:21 +00:00
|
|
|
|
2016-09-28 19:21:08 +00:00
|
|
|
// Check this after NDP emulation, since that has to be allowed in exactly this case
|
|
|
|
if (network->config().multicastLimit == 0) {
|
2017-07-13 17:51:05 +00:00
|
|
|
RR->t->outgoingNetworkFrameDropped(tPtr,network,from,to,etherType,vlanId,len,"multicast disabled");
|
2016-09-28 19:21:08 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-06-21 19:19:10 +00:00
|
|
|
/* Learn multicast groups for bridged-in hosts.
|
|
|
|
* Note that some OSes, most notably Linux, do this for you by learning
|
|
|
|
* multicast addresses on bridge interfaces and subscribing each slave.
|
|
|
|
* But in that case this does no harm, as the sets are just merged. */
|
2014-06-14 00:49:33 +00:00
|
|
|
if (fromBridged)
|
2017-03-28 00:03:17 +00:00
|
|
|
network->learnBridgedMulticastGroup(tPtr,multicastGroup,RR->node->now());
|
2014-05-23 21:32:31 +00:00
|
|
|
|
2016-08-31 23:50:22 +00:00
|
|
|
// First pass sets noTee to false, but noTee is set to true in OutboundMulticast to prevent duplicates.
|
2017-03-28 00:03:17 +00:00
|
|
|
if (!network->filterOutgoingPacket(tPtr,false,RR->identity.address(),Address(),from,to,(const uint8_t *)data,len,etherType,vlanId)) {
|
2017-07-13 17:51:05 +00:00
|
|
|
RR->t->outgoingNetworkFrameDropped(tPtr,network,from,to,etherType,vlanId,len,"filter blocked");
|
2016-07-25 23:51:10 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-10-01 19:41:48 +00:00
|
|
|
RR->mc->send(
|
2017-03-28 00:03:17 +00:00
|
|
|
tPtr,
|
2016-05-06 23:13:11 +00:00
|
|
|
network->config().multicastLimit,
|
2015-06-02 00:50:44 +00:00
|
|
|
RR->node->now(),
|
2014-10-01 19:41:48 +00:00
|
|
|
network->id(),
|
2016-09-27 19:22:25 +00:00
|
|
|
network->config().disableCompression(),
|
2016-04-12 19:49:46 +00:00
|
|
|
network->config().activeBridges(),
|
2016-09-21 04:21:34 +00:00
|
|
|
multicastGroup,
|
2014-10-10 00:58:31 +00:00
|
|
|
(fromBridged) ? from : MAC(),
|
2014-10-01 19:41:48 +00:00
|
|
|
etherType,
|
2015-04-08 22:26:45 +00:00
|
|
|
data,
|
|
|
|
len);
|
2016-10-05 17:12:06 +00:00
|
|
|
} else if (to == network->mac()) {
|
|
|
|
// Destination is this node, so just reinject it
|
2017-03-28 00:03:17 +00:00
|
|
|
RR->node->putFrame(tPtr,network->id(),network->userPtr(),from,to,etherType,vlanId,data,len);
|
2016-08-24 22:26:18 +00:00
|
|
|
} else if (to[0] == MAC::firstOctetForNetwork(network->id())) {
|
2015-04-15 20:09:20 +00:00
|
|
|
// Destination is another ZeroTier peer on the same network
|
2014-06-21 19:19:10 +00:00
|
|
|
|
2015-07-07 17:00:34 +00:00
|
|
|
Address toZT(to.toAddress(network->id())); // since in-network MACs are derived from addresses and network IDs, we can reverse this
|
2017-03-28 00:03:17 +00:00
|
|
|
SharedPtr<Peer> toPeer(RR->topology->getPeer(tPtr,toZT));
|
2016-07-25 23:51:10 +00:00
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
if (!network->filterOutgoingPacket(tPtr,false,RR->identity.address(),toZT,from,to,(const uint8_t *)data,len,etherType,vlanId)) {
|
2017-07-13 17:51:05 +00:00
|
|
|
RR->t->outgoingNetworkFrameDropped(tPtr,network,from,to,etherType,vlanId,len,"filter blocked");
|
2016-07-25 23:51:10 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-08-09 00:33:26 +00:00
|
|
|
if (fromBridged) {
|
2015-07-07 17:00:34 +00:00
|
|
|
Packet outp(toZT,RR->identity.address(),Packet::VERB_EXT_FRAME);
|
|
|
|
outp.append(network->id());
|
2016-08-09 00:33:26 +00:00
|
|
|
outp.append((unsigned char)0x00);
|
2015-07-07 17:00:34 +00:00
|
|
|
to.appendTo(outp);
|
|
|
|
from.appendTo(outp);
|
|
|
|
outp.append((uint16_t)etherType);
|
|
|
|
outp.append(data,len);
|
2016-09-27 19:22:25 +00:00
|
|
|
if (!network->config().disableCompression())
|
|
|
|
outp.compress();
|
2017-03-28 00:03:17 +00:00
|
|
|
send(tPtr,outp,true);
|
2013-07-04 20:56:19 +00:00
|
|
|
} else {
|
2015-07-07 17:00:34 +00:00
|
|
|
Packet outp(toZT,RR->identity.address(),Packet::VERB_FRAME);
|
|
|
|
outp.append(network->id());
|
|
|
|
outp.append((uint16_t)etherType);
|
|
|
|
outp.append(data,len);
|
2016-09-27 19:22:25 +00:00
|
|
|
if (!network->config().disableCompression())
|
|
|
|
outp.compress();
|
2017-03-28 00:03:17 +00:00
|
|
|
send(tPtr,outp,true);
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
2014-06-21 16:01:26 +00:00
|
|
|
|
2016-08-24 22:26:18 +00:00
|
|
|
} else {
|
2014-09-30 15:38:03 +00:00
|
|
|
// Destination is bridged behind a remote peer
|
2014-06-21 19:19:10 +00:00
|
|
|
|
2016-08-24 22:26:18 +00:00
|
|
|
// We filter with a NULL destination ZeroTier address first. Filtrations
|
|
|
|
// for each ZT destination are also done below. This is the same rationale
|
|
|
|
// and design as for multicast.
|
2017-03-28 00:03:17 +00:00
|
|
|
if (!network->filterOutgoingPacket(tPtr,false,RR->identity.address(),Address(),from,to,(const uint8_t *)data,len,etherType,vlanId)) {
|
2017-07-13 17:51:05 +00:00
|
|
|
RR->t->outgoingNetworkFrameDropped(tPtr,network,from,to,etherType,vlanId,len,"filter blocked");
|
2016-08-24 22:26:18 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-06-21 19:19:10 +00:00
|
|
|
Address bridges[ZT_MAX_BRIDGE_SPAM];
|
|
|
|
unsigned int numBridges = 0;
|
|
|
|
|
2015-07-06 19:46:27 +00:00
|
|
|
/* Create an array of up to ZT_MAX_BRIDGE_SPAM recipients for this bridged frame. */
|
2014-06-21 19:19:10 +00:00
|
|
|
bridges[0] = network->findBridgeTo(to);
|
2016-04-12 19:49:46 +00:00
|
|
|
std::vector<Address> activeBridges(network->config().activeBridges());
|
|
|
|
if ((bridges[0])&&(bridges[0] != RR->identity.address())&&(network->config().permitsBridging(bridges[0]))) {
|
2015-07-06 19:46:27 +00:00
|
|
|
/* We have a known bridge route for this MAC, send it there. */
|
2014-06-21 19:19:10 +00:00
|
|
|
++numBridges;
|
2016-04-12 19:49:46 +00:00
|
|
|
} else if (!activeBridges.empty()) {
|
2014-06-21 19:19:10 +00:00
|
|
|
/* If there is no known route, spam to up to ZT_MAX_BRIDGE_SPAM active
|
2015-07-06 19:46:27 +00:00
|
|
|
* bridges. If someone responds, we'll learn the route. */
|
2016-04-12 19:49:46 +00:00
|
|
|
std::vector<Address>::const_iterator ab(activeBridges.begin());
|
|
|
|
if (activeBridges.size() <= ZT_MAX_BRIDGE_SPAM) {
|
2014-06-21 19:19:10 +00:00
|
|
|
// If there are <= ZT_MAX_BRIDGE_SPAM active bridges, spam them all
|
2016-04-12 19:49:46 +00:00
|
|
|
while (ab != activeBridges.end()) {
|
2015-07-07 17:00:34 +00:00
|
|
|
bridges[numBridges++] = *ab;
|
2014-06-21 19:19:10 +00:00
|
|
|
++ab;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Otherwise pick a random set of them
|
|
|
|
while (numBridges < ZT_MAX_BRIDGE_SPAM) {
|
2016-04-12 19:49:46 +00:00
|
|
|
if (ab == activeBridges.end())
|
|
|
|
ab = activeBridges.begin();
|
|
|
|
if (((unsigned long)RR->node->prng() % (unsigned long)activeBridges.size()) == 0) {
|
2015-07-07 17:00:34 +00:00
|
|
|
bridges[numBridges++] = *ab;
|
2014-06-21 19:19:10 +00:00
|
|
|
++ab;
|
|
|
|
} else ++ab;
|
|
|
|
}
|
2014-06-14 00:49:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-21 19:19:10 +00:00
|
|
|
for(unsigned int b=0;b<numBridges;++b) {
|
2017-03-28 00:03:17 +00:00
|
|
|
if (network->filterOutgoingPacket(tPtr,true,RR->identity.address(),bridges[b],from,to,(const uint8_t *)data,len,etherType,vlanId)) {
|
2016-08-24 22:26:18 +00:00
|
|
|
Packet outp(bridges[b],RR->identity.address(),Packet::VERB_EXT_FRAME);
|
|
|
|
outp.append(network->id());
|
|
|
|
outp.append((uint8_t)0x00);
|
|
|
|
to.appendTo(outp);
|
|
|
|
from.appendTo(outp);
|
|
|
|
outp.append((uint16_t)etherType);
|
|
|
|
outp.append(data,len);
|
2016-09-27 19:22:25 +00:00
|
|
|
if (!network->config().disableCompression())
|
|
|
|
outp.compress();
|
2017-03-28 00:03:17 +00:00
|
|
|
send(tPtr,outp,true);
|
2016-08-24 22:26:18 +00:00
|
|
|
} else {
|
2017-07-13 17:51:05 +00:00
|
|
|
RR->t->outgoingNetworkFrameDropped(tPtr,network,from,to,etherType,vlanId,len,"filter blocked (bridge replication)");
|
2016-08-24 22:26:18 +00:00
|
|
|
}
|
2014-06-21 15:59:08 +00:00
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
void Switch::send(void *tPtr,Packet &packet,bool encrypt)
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2017-07-07 23:58:05 +00:00
|
|
|
if (packet.destination() == RR->identity.address())
|
2013-07-13 02:07:48 +00:00
|
|
|
return;
|
2017-03-28 00:03:17 +00:00
|
|
|
if (!_trySend(tPtr,packet,encrypt)) {
|
2013-07-11 20:19:06 +00:00
|
|
|
Mutex::Lock _l(_txQueue_m);
|
2016-08-09 22:45:26 +00:00
|
|
|
_txQueue.push_back(TXQueueEntry(packet.destination(),RR->node->now(),packet,encrypt));
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
void Switch::requestWhois(void *tPtr,const Address &addr)
|
2013-07-11 20:19:06 +00:00
|
|
|
{
|
2017-07-07 23:58:05 +00:00
|
|
|
if (addr == RR->identity.address())
|
|
|
|
return;
|
2013-10-03 18:38:07 +00:00
|
|
|
bool inserted = false;
|
2013-07-11 21:52:04 +00:00
|
|
|
{
|
|
|
|
Mutex::Lock _l(_outstandingWhoisRequests_m);
|
2015-09-04 22:35:43 +00:00
|
|
|
WhoisRequest &r = _outstandingWhoisRequests[addr];
|
|
|
|
if (r.lastSent) {
|
|
|
|
r.retries = 0; // reset retry count if entry already existed, but keep waiting and retry again after normal timeout
|
|
|
|
} else {
|
|
|
|
r.lastSent = RR->node->now();
|
|
|
|
inserted = true;
|
|
|
|
}
|
2013-07-11 21:52:04 +00:00
|
|
|
}
|
2013-10-03 18:38:07 +00:00
|
|
|
if (inserted)
|
2017-03-28 00:03:17 +00:00
|
|
|
_sendWhoisRequest(tPtr,addr,(const Address *)0,0);
|
2013-07-11 20:19:06 +00:00
|
|
|
}
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
void Switch::doAnythingWaitingForPeer(void *tPtr,const SharedPtr<Peer> &peer)
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2014-08-19 17:09:21 +00:00
|
|
|
{ // cancel pending WHOIS since we now know this peer
|
2013-07-11 21:52:04 +00:00
|
|
|
Mutex::Lock _l(_outstandingWhoisRequests_m);
|
|
|
|
_outstandingWhoisRequests.erase(peer->address());
|
|
|
|
}
|
|
|
|
|
2014-08-19 17:09:21 +00:00
|
|
|
{ // finish processing any packets waiting on peer's public key / identity
|
2013-07-11 21:52:04 +00:00
|
|
|
Mutex::Lock _l(_rxQueue_m);
|
2016-03-18 21:16:07 +00:00
|
|
|
unsigned long i = ZT_RX_QUEUE_SIZE;
|
|
|
|
while (i) {
|
|
|
|
RXQueueEntry *rq = &(_rxQueue[--i]);
|
|
|
|
if ((rq->timestamp)&&(rq->complete)) {
|
2017-03-28 00:03:17 +00:00
|
|
|
if (rq->frag0.tryDecode(RR,tPtr))
|
2016-03-18 21:16:07 +00:00
|
|
|
rq->timestamp = 0;
|
|
|
|
}
|
2013-07-11 21:52:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 17:09:21 +00:00
|
|
|
{ // finish sending any packets waiting on peer's public key / identity
|
2013-07-11 21:52:04 +00:00
|
|
|
Mutex::Lock _l(_txQueue_m);
|
2015-09-04 21:56:39 +00:00
|
|
|
for(std::list< TXQueueEntry >::iterator txi(_txQueue.begin());txi!=_txQueue.end();) {
|
|
|
|
if (txi->dest == peer->address()) {
|
2017-03-28 00:03:17 +00:00
|
|
|
if (_trySend(tPtr,txi->packet,txi->encrypt))
|
2015-09-04 21:56:39 +00:00
|
|
|
_txQueue.erase(txi++);
|
|
|
|
else ++txi;
|
|
|
|
} else ++txi;
|
2013-07-11 20:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
unsigned long Switch::doTimerTasks(void *tPtr,uint64_t now)
|
2014-09-24 20:45:58 +00:00
|
|
|
{
|
2015-04-08 02:31:11 +00:00
|
|
|
unsigned long nextDelay = 0xffffffff; // ceiling delay, caller will cap to minimum
|
2014-09-24 20:45:58 +00:00
|
|
|
|
2015-04-03 23:52:53 +00:00
|
|
|
{ // Retry outstanding WHOIS requests
|
2014-09-24 20:45:58 +00:00
|
|
|
Mutex::Lock _l(_outstandingWhoisRequests_m);
|
2015-09-04 22:35:43 +00:00
|
|
|
Hashtable< Address,WhoisRequest >::Iterator i(_outstandingWhoisRequests);
|
|
|
|
Address *a = (Address *)0;
|
|
|
|
WhoisRequest *r = (WhoisRequest *)0;
|
|
|
|
while (i.next(a,r)) {
|
|
|
|
const unsigned long since = (unsigned long)(now - r->lastSent);
|
2014-09-24 20:45:58 +00:00
|
|
|
if (since >= ZT_WHOIS_RETRY_DELAY) {
|
2015-09-04 22:35:43 +00:00
|
|
|
if (r->retries >= ZT_MAX_WHOIS_RETRIES) {
|
|
|
|
_outstandingWhoisRequests.erase(*a);
|
2014-09-24 20:45:58 +00:00
|
|
|
} else {
|
2015-09-04 22:35:43 +00:00
|
|
|
r->lastSent = now;
|
2017-03-28 00:03:17 +00:00
|
|
|
r->peersConsulted[r->retries] = _sendWhoisRequest(tPtr,*a,r->peersConsulted,(r->retries > 1) ? r->retries : 0);
|
2017-03-11 03:52:08 +00:00
|
|
|
++r->retries;
|
2014-09-24 20:45:58 +00:00
|
|
|
nextDelay = std::min(nextDelay,(unsigned long)ZT_WHOIS_RETRY_DELAY);
|
|
|
|
}
|
2015-04-03 23:52:53 +00:00
|
|
|
} else {
|
|
|
|
nextDelay = std::min(nextDelay,ZT_WHOIS_RETRY_DELAY - since);
|
|
|
|
}
|
2014-09-24 20:45:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-03 23:52:53 +00:00
|
|
|
{ // Time out TX queue packets that never got WHOIS lookups or other info.
|
2014-09-24 20:45:58 +00:00
|
|
|
Mutex::Lock _l(_txQueue_m);
|
2015-09-04 21:56:39 +00:00
|
|
|
for(std::list< TXQueueEntry >::iterator txi(_txQueue.begin());txi!=_txQueue.end();) {
|
2017-03-28 00:03:17 +00:00
|
|
|
if (_trySend(tPtr,txi->packet,txi->encrypt))
|
2015-09-04 21:56:39 +00:00
|
|
|
_txQueue.erase(txi++);
|
|
|
|
else if ((now - txi->creationTime) > ZT_TRANSMIT_QUEUE_TIMEOUT) {
|
2017-07-13 17:51:05 +00:00
|
|
|
RR->t->txTimedOut(tPtr,txi->dest);
|
2015-09-04 21:56:39 +00:00
|
|
|
_txQueue.erase(txi++);
|
|
|
|
} else ++txi;
|
2014-09-24 20:45:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-04 22:21:22 +00:00
|
|
|
{ // Remove really old last unite attempt entries to keep table size controlled
|
|
|
|
Mutex::Lock _l(_lastUniteAttempt_m);
|
|
|
|
Hashtable< _LastUniteKey,uint64_t >::Iterator i(_lastUniteAttempt);
|
|
|
|
_LastUniteKey *k = (_LastUniteKey *)0;
|
|
|
|
uint64_t *v = (uint64_t *)0;
|
|
|
|
while (i.next(k,v)) {
|
2015-11-02 23:38:53 +00:00
|
|
|
if ((now - *v) >= (ZT_MIN_UNITE_INTERVAL * 8))
|
2015-09-04 22:21:22 +00:00
|
|
|
_lastUniteAttempt.erase(*k);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-08 02:31:11 +00:00
|
|
|
return nextDelay;
|
2014-09-24 20:45:58 +00:00
|
|
|
}
|
|
|
|
|
2017-02-04 08:04:44 +00:00
|
|
|
bool Switch::_shouldUnite(const uint64_t now,const Address &source,const Address &destination)
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lastUniteAttempt_m);
|
|
|
|
uint64_t &ts = _lastUniteAttempt[_LastUniteKey(source,destination)];
|
|
|
|
if ((now - ts) >= ZT_MIN_UNITE_INTERVAL) {
|
|
|
|
ts = now;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
Address Switch::_sendWhoisRequest(void *tPtr,const Address &addr,const Address *peersAlreadyConsulted,unsigned int numPeersAlreadyConsulted)
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2016-11-18 00:31:58 +00:00
|
|
|
SharedPtr<Peer> upstream(RR->topology->getUpstreamPeer(peersAlreadyConsulted,numPeersAlreadyConsulted,false));
|
2016-09-09 15:43:58 +00:00
|
|
|
if (upstream) {
|
|
|
|
Packet outp(upstream->address(),RR->identity.address(),Packet::VERB_WHOIS);
|
2013-07-25 17:24:39 +00:00
|
|
|
addr.appendTo(outp);
|
2016-09-09 15:43:58 +00:00
|
|
|
RR->node->expectReplyTo(outp.packetId());
|
2017-03-28 00:03:17 +00:00
|
|
|
send(tPtr,outp,true);
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
return Address();
|
|
|
|
}
|
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
bool Switch::_trySend(void *tPtr,Packet &packet,bool encrypt)
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2017-02-01 20:00:25 +00:00
|
|
|
SharedPtr<Path> viaPath;
|
|
|
|
const uint64_t now = RR->node->now();
|
|
|
|
const Address destination(packet.destination());
|
2017-02-01 21:52:53 +00:00
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
const SharedPtr<Peer> peer(RR->topology->getPeer(tPtr,destination));
|
2017-02-01 20:00:25 +00:00
|
|
|
if (peer) {
|
2016-11-22 22:23:13 +00:00
|
|
|
/* First get the best path, and if it's dead (and this is not a root)
|
|
|
|
* we attempt to re-activate that path but this packet will flow
|
|
|
|
* upstream. If the path comes back alive, it will be used in the future.
|
|
|
|
* For roots we don't do the alive check since roots are not required
|
|
|
|
* to send heartbeats "down" and because we have to at least try to
|
|
|
|
* go somewhere. */
|
2016-09-07 18:13:17 +00:00
|
|
|
|
2017-02-01 20:00:25 +00:00
|
|
|
viaPath = peer->getBestPath(now,false);
|
2017-01-27 21:27:52 +00:00
|
|
|
if ( (viaPath) && (!viaPath->alive(now)) && (!RR->topology->isUpstream(peer->identity())) ) {
|
2017-07-06 17:25:36 +00:00
|
|
|
if ((now - viaPath->lastOut()) > std::max((now - viaPath->lastIn()) * 4,(uint64_t)ZT_PATH_MIN_REACTIVATE_INTERVAL)) {
|
2017-07-06 18:45:22 +00:00
|
|
|
peer->attemptToContactAt(tPtr,viaPath->localSocket(),viaPath->address(),now,false,viaPath->nextOutgoingCounter());
|
2017-07-06 17:25:36 +00:00
|
|
|
viaPath->sent(now);
|
2017-02-01 21:52:53 +00:00
|
|
|
}
|
2016-09-02 20:55:33 +00:00
|
|
|
viaPath.zero();
|
|
|
|
}
|
2017-02-01 20:00:25 +00:00
|
|
|
|
2017-02-01 21:20:51 +00:00
|
|
|
if (!viaPath) {
|
2017-03-28 00:03:17 +00:00
|
|
|
peer->tryMemorizedPath(tPtr,now); // periodically attempt memorized or statically defined paths, if any are known
|
2017-02-01 21:52:53 +00:00
|
|
|
const SharedPtr<Peer> relay(RR->topology->getUpstreamPeer());
|
|
|
|
if ( (!relay) || (!(viaPath = relay->getBestPath(now,false))) ) {
|
|
|
|
if (!(viaPath = peer->getBestPath(now,true)))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2017-02-01 20:00:25 +00:00
|
|
|
} else {
|
2017-07-06 17:25:36 +00:00
|
|
|
requestWhois(tPtr,destination);
|
|
|
|
return false; // if we are not in cluster mode, there is no way we can send without knowing the peer directly
|
2017-02-01 20:00:25 +00:00
|
|
|
}
|
2015-07-07 17:00:34 +00:00
|
|
|
|
2017-02-01 20:00:25 +00:00
|
|
|
unsigned int chunkSize = std::min(packet.size(),(unsigned int)ZT_UDP_DEFAULT_PAYLOAD_MTU);
|
|
|
|
packet.setFragmented(chunkSize < packet.size());
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2017-02-01 20:00:25 +00:00
|
|
|
const uint64_t trustedPathId = RR->topology->getOutboundPathTrust(viaPath->address());
|
|
|
|
if (trustedPathId) {
|
|
|
|
packet.setTrusted(trustedPathId);
|
|
|
|
} else {
|
2017-03-01 18:22:57 +00:00
|
|
|
packet.armor(peer->key(),encrypt,viaPath->nextOutgoingCounter());
|
2017-02-01 20:00:25 +00:00
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2017-03-28 00:03:17 +00:00
|
|
|
if (viaPath->send(RR,tPtr,packet.data(),chunkSize,now)) {
|
2017-02-01 20:00:25 +00:00
|
|
|
if (chunkSize < packet.size()) {
|
|
|
|
// Too big for one packet, fragment the rest
|
|
|
|
unsigned int fragStart = chunkSize;
|
|
|
|
unsigned int remaining = packet.size() - chunkSize;
|
|
|
|
unsigned int fragsRemaining = (remaining / (ZT_UDP_DEFAULT_PAYLOAD_MTU - ZT_PROTO_MIN_FRAGMENT_LENGTH));
|
|
|
|
if ((fragsRemaining * (ZT_UDP_DEFAULT_PAYLOAD_MTU - ZT_PROTO_MIN_FRAGMENT_LENGTH)) < remaining)
|
|
|
|
++fragsRemaining;
|
|
|
|
const unsigned int totalFragments = fragsRemaining + 1;
|
|
|
|
|
|
|
|
for(unsigned int fno=1;fno<totalFragments;++fno) {
|
|
|
|
chunkSize = std::min(remaining,(unsigned int)(ZT_UDP_DEFAULT_PAYLOAD_MTU - ZT_PROTO_MIN_FRAGMENT_LENGTH));
|
|
|
|
Packet::Fragment frag(packet,fragStart,chunkSize,fno,totalFragments);
|
2017-03-28 00:03:17 +00:00
|
|
|
viaPath->send(RR,tPtr,frag.data(),frag.size(),now);
|
2017-02-01 20:00:25 +00:00
|
|
|
fragStart += chunkSize;
|
|
|
|
remaining -= chunkSize;
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
}
|
2014-10-29 00:25:34 +00:00
|
|
|
}
|
2017-02-01 20:00:25 +00:00
|
|
|
|
|
|
|
return true;
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace ZeroTier
|