2013-07-04 20:56:19 +00:00
|
|
|
/*
|
|
|
|
* ZeroTier One - Global Peer to Peer Ethernet
|
2014-02-16 20:40:22 +00:00
|
|
|
* Copyright (C) 2011-2014 ZeroTier Networks LLC
|
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/>.
|
|
|
|
*
|
|
|
|
* --
|
|
|
|
*
|
|
|
|
* ZeroTier may be used and distributed under the terms of the GPLv3, which
|
|
|
|
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
|
|
|
|
*
|
|
|
|
* If you would like to embed ZeroTier into a commercial application or
|
|
|
|
* redistribute it in a modified binary form, please contact ZeroTier Networks
|
|
|
|
* LLC. Start here: http://www.zerotier.com/
|
|
|
|
*/
|
|
|
|
|
2013-12-07 00:49:20 +00:00
|
|
|
#ifndef ZT_PEER_HPP
|
|
|
|
#define ZT_PEER_HPP
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-08-13 01:25:36 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2014-03-21 01:49:33 +00:00
|
|
|
#include <vector>
|
2013-07-04 20:56:19 +00:00
|
|
|
#include <algorithm>
|
|
|
|
#include <utility>
|
|
|
|
#include <stdexcept>
|
2013-08-13 01:25:36 +00:00
|
|
|
|
2013-10-05 14:19:12 +00:00
|
|
|
#include "Constants.hpp"
|
2014-03-21 01:49:33 +00:00
|
|
|
#include "Path.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "Address.hpp"
|
|
|
|
#include "Utils.hpp"
|
|
|
|
#include "Identity.hpp"
|
|
|
|
#include "Logger.hpp"
|
|
|
|
#include "RuntimeEnvironment.hpp"
|
|
|
|
#include "InetAddress.hpp"
|
|
|
|
#include "Packet.hpp"
|
|
|
|
#include "SharedPtr.hpp"
|
2014-03-21 03:07:35 +00:00
|
|
|
#include "Socket.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "AtomicCounter.hpp"
|
|
|
|
#include "NonCopyable.hpp"
|
|
|
|
#include "Mutex.hpp"
|
|
|
|
|
2014-10-12 18:42:49 +00:00
|
|
|
// Comment out to disable peers.persist
|
|
|
|
//#define ZT_PEER_SERIALIZATION_VERSION 13
|
2013-12-24 18:39:29 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
namespace ZeroTier {
|
|
|
|
|
|
|
|
/**
|
2014-03-21 01:49:33 +00:00
|
|
|
* Peer on P2P Network
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
|
|
|
class Peer : NonCopyable
|
|
|
|
{
|
|
|
|
friend class SharedPtr<Peer>;
|
|
|
|
|
|
|
|
public:
|
2014-03-21 03:07:35 +00:00
|
|
|
/**
|
|
|
|
* Construct an uninitialized peer (used with deserialize())
|
|
|
|
*/
|
2013-07-04 20:56:19 +00:00
|
|
|
Peer();
|
|
|
|
|
2014-04-18 07:14:12 +00:00
|
|
|
~Peer() { Utils::burn(_key,sizeof(_key)); }
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* Construct a new peer
|
|
|
|
*
|
|
|
|
* @param myIdentity Identity of THIS node (for key agreement)
|
|
|
|
* @param peerIdentity Identity of peer
|
|
|
|
* @throws std::runtime_error Key agreement with peer's identity failed
|
|
|
|
*/
|
|
|
|
Peer(const Identity &myIdentity,const Identity &peerIdentity)
|
|
|
|
throw(std::runtime_error);
|
|
|
|
|
2013-10-21 14:29:44 +00:00
|
|
|
/**
|
|
|
|
* @return Time peer record was last used in any way
|
|
|
|
*/
|
2014-04-10 17:00:20 +00:00
|
|
|
inline uint64_t lastUsed() const throw() { return _lastUsed; }
|
2013-10-21 14:29:44 +00:00
|
|
|
|
|
|
|
/**
|
2014-04-10 17:00:20 +00:00
|
|
|
* Log a use of this peer record (done by Topology when peers are looked up)
|
|
|
|
*
|
2013-10-21 14:29:44 +00:00
|
|
|
* @param now New time of last use
|
|
|
|
*/
|
2014-04-10 17:00:20 +00:00
|
|
|
inline void use(uint64_t now) throw() { _lastUsed = now; }
|
2013-10-21 14:29:44 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* @return This peer's ZT address (short for identity().address())
|
|
|
|
*/
|
|
|
|
inline const Address &address() const throw() { return _id.address(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return This peer's identity
|
|
|
|
*/
|
|
|
|
inline const Identity &identity() const throw() { return _id; }
|
|
|
|
|
|
|
|
/**
|
2014-04-10 17:00:20 +00:00
|
|
|
* Log receipt of an authenticated packet
|
|
|
|
*
|
|
|
|
* This is called by the decode pipe when a packet is proven to be authentic
|
|
|
|
* and appears to be valid.
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
2014-09-25 22:08:29 +00:00
|
|
|
* @param RR Runtime environment
|
2014-03-21 03:07:35 +00:00
|
|
|
* @param fromSock Socket from which packet was received
|
2013-07-13 18:28:26 +00:00
|
|
|
* @param remoteAddr Internet address of sender
|
2013-07-04 20:56:19 +00:00
|
|
|
* @param hops ZeroTier (not IP) hops
|
2013-12-24 18:39:29 +00:00
|
|
|
* @param packetId Packet ID
|
2013-07-04 20:56:19 +00:00
|
|
|
* @param verb Packet verb
|
2013-12-24 18:39:29 +00:00
|
|
|
* @param inRePacketId Packet ID in reply to (for OK/ERROR, 0 otherwise)
|
|
|
|
* @param inReVerb Verb in reply to (for OK/ERROR, VERB_NOP otherwise)
|
2013-07-04 20:56:19 +00:00
|
|
|
* @param now Current time
|
|
|
|
*/
|
2014-03-21 21:18:35 +00:00
|
|
|
void receive(
|
2014-09-24 20:53:03 +00:00
|
|
|
const RuntimeEnvironment *RR,
|
2014-03-21 03:07:35 +00:00
|
|
|
const SharedPtr<Socket> &fromSock,
|
2013-12-24 18:39:29 +00:00
|
|
|
const InetAddress &remoteAddr,
|
|
|
|
unsigned int hops,
|
|
|
|
uint64_t packetId,
|
|
|
|
Packet::Verb verb,
|
|
|
|
uint64_t inRePacketId,
|
|
|
|
Packet::Verb inReVerb,
|
|
|
|
uint64_t now);
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
2014-04-10 17:00:20 +00:00
|
|
|
* Send a packet directly to this peer
|
2014-03-21 01:49:33 +00:00
|
|
|
*
|
2014-04-10 17:00:20 +00:00
|
|
|
* This sends only via direct paths if available and does not handle
|
|
|
|
* finding of relays. That is done in the send logic in Switch.
|
2014-03-21 01:49:33 +00:00
|
|
|
*
|
2014-09-25 22:08:29 +00:00
|
|
|
* @param RR Runtime environment
|
2013-07-04 20:56:19 +00:00
|
|
|
* @param data Data to send
|
|
|
|
* @param len Length of packet
|
|
|
|
* @param now Current time
|
2014-04-10 18:17:54 +00:00
|
|
|
* @return Type of path used or Path::PATH_TYPE_NULL on failure
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2014-09-24 20:53:03 +00:00
|
|
|
Path::Type send(const RuntimeEnvironment *RR,const void *data,unsigned int len,uint64_t now);
|
2013-07-13 18:28:26 +00:00
|
|
|
|
2013-10-02 20:12:10 +00:00
|
|
|
/**
|
2014-03-21 03:07:35 +00:00
|
|
|
* Send HELLO to a peer via all direct paths available
|
2014-03-21 01:49:33 +00:00
|
|
|
*
|
|
|
|
* This begins attempting to use TCP paths if no ping response has been
|
|
|
|
* received from any UDP path in more than ZT_TCP_FALLBACK_AFTER.
|
2013-10-02 20:12:10 +00:00
|
|
|
*
|
2014-09-25 22:08:29 +00:00
|
|
|
* @param RR Runtime environment
|
2013-10-02 20:12:10 +00:00
|
|
|
* @param now Current time
|
|
|
|
* @return True if send appears successful for at least one address type
|
|
|
|
*/
|
2014-09-24 20:53:03 +00:00
|
|
|
bool sendPing(const RuntimeEnvironment *RR,uint64_t now);
|
2014-03-21 03:07:35 +00:00
|
|
|
|
2014-03-31 18:41:14 +00:00
|
|
|
/**
|
|
|
|
* Called periodically by Topology::clean() to remove stale paths and do other cleanup
|
|
|
|
*/
|
|
|
|
void clean(uint64_t now);
|
|
|
|
|
2014-03-21 03:07:35 +00:00
|
|
|
/**
|
|
|
|
* @return All known direct paths to this peer
|
|
|
|
*/
|
|
|
|
std::vector<Path> paths() const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
return _paths;
|
|
|
|
}
|
2013-10-02 20:12:10 +00:00
|
|
|
|
2014-04-10 23:30:15 +00:00
|
|
|
/**
|
|
|
|
* @param addr IP:port
|
|
|
|
* @return True if we have a UDP path to this address
|
|
|
|
*/
|
|
|
|
inline bool haveUdpPath(const InetAddress &addr) const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
for(std::vector<Path>::const_iterator p(_paths.begin());p!=_paths.end();++p) {
|
|
|
|
if ((p->type() == Path::PATH_TYPE_UDP)&&(p->address() == addr))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2014-03-21 03:07:35 +00:00
|
|
|
* @return Time of last direct packet receive for any path
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-10-02 17:50:42 +00:00
|
|
|
inline uint64_t lastDirectReceive() const
|
2013-07-04 20:56:19 +00:00
|
|
|
throw()
|
|
|
|
{
|
2014-03-21 03:07:35 +00:00
|
|
|
uint64_t x = 0;
|
|
|
|
Mutex::Lock _l(_lock);
|
2014-04-09 23:00:25 +00:00
|
|
|
for(std::vector<Path>::const_iterator p(_paths.begin());p!=_paths.end();++p)
|
|
|
|
x = std::max(x,p->lastReceived());
|
2014-03-21 03:07:35 +00:00
|
|
|
return x;
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-03-21 03:07:35 +00:00
|
|
|
* @return Time of last direct packet send for any path
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-10-02 17:50:42 +00:00
|
|
|
inline uint64_t lastDirectSend() const
|
2013-07-04 20:56:19 +00:00
|
|
|
throw()
|
|
|
|
{
|
2014-03-21 03:07:35 +00:00
|
|
|
uint64_t x = 0;
|
|
|
|
Mutex::Lock _l(_lock);
|
2014-04-09 23:00:25 +00:00
|
|
|
for(std::vector<Path>::const_iterator p(_paths.begin());p!=_paths.end();++p)
|
|
|
|
x = std::max(x,p->lastSend());
|
2014-03-21 03:07:35 +00:00
|
|
|
return x;
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
2014-04-03 21:36:52 +00:00
|
|
|
/**
|
2014-04-10 00:08:35 +00:00
|
|
|
* Get max timestamp of last ping and max timestamp of last receive in a single pass
|
|
|
|
*
|
|
|
|
* @param lp Last ping result parameter (init to 0 before calling)
|
|
|
|
* @param lr Last receive result parameter (init to 0 before calling)
|
2014-04-03 21:36:52 +00:00
|
|
|
*/
|
2014-04-10 00:08:35 +00:00
|
|
|
inline void lastPingAndDirectReceive(uint64_t &lp,uint64_t &lr)
|
|
|
|
throw()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
for(std::vector<Path>::const_iterator p(_paths.begin());p!=_paths.end();++p) {
|
|
|
|
lp = std::max(lp,p->lastPing());
|
|
|
|
lr = std::max(lr,p->lastReceived());
|
|
|
|
}
|
|
|
|
}
|
2014-04-03 21:36:52 +00:00
|
|
|
|
2014-06-30 18:31:04 +00:00
|
|
|
/**
|
|
|
|
* @return Time of last receive of anything, whether direct or relayed
|
|
|
|
*/
|
|
|
|
inline uint64_t lastReceive() const throw() { return _lastReceive; }
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2013-09-24 21:35:05 +00:00
|
|
|
* @return Time of most recent unicast frame received
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2014-04-09 23:00:25 +00:00
|
|
|
inline uint64_t lastUnicastFrame() const throw() { return _lastUnicastFrame; }
|
2013-07-13 18:28:26 +00:00
|
|
|
|
|
|
|
/**
|
2013-09-24 21:35:05 +00:00
|
|
|
* @return Time of most recent multicast frame received
|
2013-07-13 18:28:26 +00:00
|
|
|
*/
|
2014-04-09 23:00:25 +00:00
|
|
|
inline uint64_t lastMulticastFrame() const throw() { return _lastMulticastFrame; }
|
2013-07-13 18:28:26 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Time of most recent frame of any kind (unicast or multicast)
|
|
|
|
*/
|
2014-04-09 23:00:25 +00:00
|
|
|
inline uint64_t lastFrame() const throw() { return std::max(_lastUnicastFrame,_lastMulticastFrame); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-10-01 20:01:36 +00:00
|
|
|
/**
|
|
|
|
* @return Time we last announced state TO this peer, such as multicast LIKEs
|
|
|
|
*/
|
2014-10-11 23:26:02 +00:00
|
|
|
inline uint64_t lastAnnouncedTo() const throw() { return __lastAnnouncedTo; }
|
2013-10-01 20:01:36 +00:00
|
|
|
|
2014-06-30 18:31:04 +00:00
|
|
|
/**
|
|
|
|
* @param now Current time
|
|
|
|
* @return True if peer has received something within ZT_PEER_ACTIVITY_TIMEOUT ms
|
|
|
|
*/
|
|
|
|
inline bool alive(uint64_t now) const
|
|
|
|
throw()
|
|
|
|
{
|
|
|
|
return ((now - _lastReceive) < ZT_PEER_ACTIVITY_TIMEOUT);
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2013-12-31 19:03:45 +00:00
|
|
|
* @return Current latency or 0 if unknown (max: 65535)
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-12-31 19:03:45 +00:00
|
|
|
inline unsigned int latency() const
|
|
|
|
throw()
|
|
|
|
{
|
2014-02-03 18:46:37 +00:00
|
|
|
unsigned int l = _latency;
|
|
|
|
return std::min(l,(unsigned int)65535);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Update latency with a new direct measurment
|
|
|
|
*
|
|
|
|
* @param l Direct latency measurment in ms
|
|
|
|
*/
|
|
|
|
inline void addDirectLatencyMeasurment(unsigned int l)
|
|
|
|
throw()
|
|
|
|
{
|
|
|
|
unsigned int ol = _latency;
|
|
|
|
if ((ol > 0)&&(ol < 10000))
|
2014-04-09 23:00:25 +00:00
|
|
|
_latency = (ol + std::min(l,(unsigned int)65535)) / 2;
|
|
|
|
else _latency = std::min(l,(unsigned int)65535);
|
2013-12-31 19:03:45 +00:00
|
|
|
}
|
2013-07-11 22:15:51 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* @return True if this peer has at least one direct IP address path
|
|
|
|
*/
|
2014-03-21 01:49:33 +00:00
|
|
|
inline bool hasDirectPath() const
|
|
|
|
throw()
|
|
|
|
{
|
2014-03-21 03:07:35 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
return (!_paths.empty());
|
2014-03-21 01:49:33 +00:00
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @param now Current time
|
2014-01-30 22:23:52 +00:00
|
|
|
* @return True if this peer has at least one active or fixed direct path
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2014-03-21 01:49:33 +00:00
|
|
|
inline bool hasActiveDirectPath(uint64_t now) const
|
2013-07-06 18:58:34 +00:00
|
|
|
throw()
|
|
|
|
{
|
2014-03-21 03:07:35 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
for(std::vector<Path>::const_iterator p(_paths.begin());p!=_paths.end();++p) {
|
|
|
|
if (p->active(now))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2013-07-06 18:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-03-21 01:49:33 +00:00
|
|
|
* Add a path (if we don't already have it)
|
|
|
|
*
|
|
|
|
* @param p New path to add
|
2013-07-06 18:58:34 +00:00
|
|
|
*/
|
2014-03-21 03:07:35 +00:00
|
|
|
inline void addPath(const Path &newp)
|
2013-07-06 18:58:34 +00:00
|
|
|
{
|
2014-03-21 03:07:35 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
2014-03-21 20:46:55 +00:00
|
|
|
for(std::vector<Path>::iterator p(_paths.begin());p!=_paths.end();++p) {
|
2014-03-21 03:07:35 +00:00
|
|
|
if (*p == newp) {
|
|
|
|
p->setFixed(newp.fixed());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_paths.push_back(newp);
|
2013-07-06 18:58:34 +00:00
|
|
|
}
|
|
|
|
|
2014-01-29 00:12:24 +00:00
|
|
|
/**
|
2014-03-21 01:49:33 +00:00
|
|
|
* Clear paths
|
2014-01-29 00:12:24 +00:00
|
|
|
*
|
2014-03-21 01:49:33 +00:00
|
|
|
* @param fixedToo If true, clear fixed paths as well as learned ones
|
2014-01-29 00:12:24 +00:00
|
|
|
*/
|
2014-03-21 01:49:33 +00:00
|
|
|
inline void clearPaths(bool fixedToo)
|
2014-01-29 00:12:24 +00:00
|
|
|
{
|
2014-03-21 03:07:35 +00:00
|
|
|
std::vector<Path> npv;
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
if (!fixedToo) {
|
|
|
|
for(std::vector<Path>::const_iterator p(_paths.begin());p!=_paths.end();++p) {
|
|
|
|
if (p->fixed())
|
|
|
|
npv.push_back(*p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_paths = npv;
|
2014-01-29 00:12:24 +00:00
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2013-12-24 18:39:29 +00:00
|
|
|
* @return 256-bit secret symmetric encryption key
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-12-24 18:39:29 +00:00
|
|
|
inline const unsigned char *key() const throw() { return _key; }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-07-12 02:06:25 +00:00
|
|
|
/**
|
2014-02-03 18:46:37 +00:00
|
|
|
* Set the currently known remote version of this peer's client
|
2013-07-12 02:06:25 +00:00
|
|
|
*
|
2014-09-30 23:28:25 +00:00
|
|
|
* @param vproto Protocol version
|
2013-07-12 02:06:25 +00:00
|
|
|
* @param vmaj Major version
|
|
|
|
* @param vmin Minor version
|
|
|
|
* @param vrev Revision
|
|
|
|
*/
|
2014-09-30 23:28:25 +00:00
|
|
|
inline void setRemoteVersion(unsigned int vproto,unsigned int vmaj,unsigned int vmin,unsigned int vrev)
|
2013-07-12 02:06:25 +00:00
|
|
|
{
|
2014-09-30 23:28:25 +00:00
|
|
|
_vProto = (uint16_t)vproto;
|
|
|
|
_vMajor = (uint16_t)vmaj;
|
|
|
|
_vMinor = (uint16_t)vmin;
|
|
|
|
_vRevision = (uint16_t)vrev;
|
2013-07-12 02:06:25 +00:00
|
|
|
}
|
|
|
|
|
2014-09-30 23:28:25 +00:00
|
|
|
inline unsigned int remoteVersionProtocol() const throw() { return _vProto; }
|
|
|
|
|
2014-09-12 23:57:37 +00:00
|
|
|
inline unsigned int remoteVersionMajor() const throw() { return _vMajor; }
|
|
|
|
inline unsigned int remoteVersionMinor() const throw() { return _vMinor; }
|
|
|
|
inline unsigned int remoteVersionRevision() const throw() { return _vRevision; }
|
2014-09-30 23:28:25 +00:00
|
|
|
|
2014-09-12 23:57:37 +00:00
|
|
|
inline bool remoteVersionKnown() const throw() { return ((_vMajor > 0)||(_vMinor > 0)||(_vRevision > 0)); }
|
2013-08-06 15:50:56 +00:00
|
|
|
|
2014-03-21 20:46:55 +00:00
|
|
|
/**
|
2014-04-09 23:00:25 +00:00
|
|
|
* Get most recently active UDP path addresses for IPv4 and/or IPv6
|
|
|
|
*
|
|
|
|
* Note that v4 and v6 are not modified if they are not found, so
|
|
|
|
* initialize these to a NULL address to be able to check.
|
|
|
|
*
|
2014-03-21 20:46:55 +00:00
|
|
|
* @param now Current time
|
|
|
|
* @param v4 Result parameter to receive active IPv4 address, if any
|
|
|
|
* @param v6 Result parameter to receive active IPv6 address, if any
|
|
|
|
*/
|
2014-04-09 23:00:25 +00:00
|
|
|
void getBestActiveUdpPathAddresses(uint64_t now,InetAddress &v4,InetAddress &v6) const;
|
2014-03-21 20:46:55 +00:00
|
|
|
|
2013-12-24 18:39:29 +00:00
|
|
|
/**
|
|
|
|
* Find a common set of addresses by which two peers can link, if any
|
|
|
|
*
|
|
|
|
* @param a Peer A
|
|
|
|
* @param b Peer B
|
|
|
|
* @param now Current time
|
2014-03-21 20:46:55 +00:00
|
|
|
* @return Pair: B's address (to send to A), A's address (to send to B)
|
2013-12-24 18:39:29 +00:00
|
|
|
*/
|
|
|
|
static inline std::pair<InetAddress,InetAddress> findCommonGround(const Peer &a,const Peer &b,uint64_t now)
|
|
|
|
{
|
2014-03-21 20:46:55 +00:00
|
|
|
std::pair<InetAddress,InetAddress> v4,v6;
|
2014-04-09 23:00:25 +00:00
|
|
|
b.getBestActiveUdpPathAddresses(now,v4.first,v6.first);
|
|
|
|
a.getBestActiveUdpPathAddresses(now,v4.second,v6.second);
|
|
|
|
if ((v6.first)&&(v6.second)) // prefer IPv6 if both have it since NAT-t is (almost) unnecessary
|
2014-03-21 20:46:55 +00:00
|
|
|
return v6;
|
2014-04-09 23:00:25 +00:00
|
|
|
else if ((v4.first)&&(v4.second))
|
2014-03-21 20:46:55 +00:00
|
|
|
return v4;
|
2014-04-09 23:00:25 +00:00
|
|
|
else return std::pair<InetAddress,InetAddress>();
|
2013-12-24 18:39:29 +00:00
|
|
|
}
|
|
|
|
|
2014-10-12 18:42:49 +00:00
|
|
|
#ifdef ZT_PEER_SERIALIZATION_VERSION
|
2013-07-04 20:56:19 +00:00
|
|
|
template<unsigned int C>
|
2014-03-21 03:07:35 +00:00
|
|
|
inline void serialize(Buffer<C> &b) const
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2014-03-21 03:07:35 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
|
2013-12-24 18:39:29 +00:00
|
|
|
b.append((unsigned char)ZT_PEER_SERIALIZATION_VERSION);
|
2013-07-04 20:56:19 +00:00
|
|
|
_id.serialize(b,false);
|
2014-03-21 03:07:35 +00:00
|
|
|
b.append(_key,sizeof(_key));
|
2013-10-21 14:29:44 +00:00
|
|
|
b.append(_lastUsed);
|
2014-06-30 18:31:04 +00:00
|
|
|
b.append(_lastReceive);
|
2013-07-13 18:28:26 +00:00
|
|
|
b.append(_lastUnicastFrame);
|
|
|
|
b.append(_lastMulticastFrame);
|
2014-09-30 23:28:25 +00:00
|
|
|
b.append((uint16_t)_vProto);
|
2013-10-01 20:01:36 +00:00
|
|
|
b.append((uint16_t)_vMajor);
|
|
|
|
b.append((uint16_t)_vMinor);
|
|
|
|
b.append((uint16_t)_vRevision);
|
2013-12-24 18:39:29 +00:00
|
|
|
b.append((uint16_t)_latency);
|
2014-03-21 03:07:35 +00:00
|
|
|
b.append((uint16_t)_paths.size());
|
|
|
|
for(std::vector<Path>::const_iterator p(_paths.begin());p!=_paths.end();++p)
|
|
|
|
p->serialize(b);
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
template<unsigned int C>
|
|
|
|
inline unsigned int deserialize(const Buffer<C> &b,unsigned int startAt = 0)
|
|
|
|
{
|
|
|
|
unsigned int p = startAt;
|
|
|
|
|
2013-12-24 18:39:29 +00:00
|
|
|
if (b[p++] != ZT_PEER_SERIALIZATION_VERSION)
|
2013-07-04 20:56:19 +00:00
|
|
|
throw std::invalid_argument("Peer: deserialize(): version mismatch");
|
|
|
|
|
2014-03-21 03:07:35 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
p += _id.deserialize(b,p);
|
2014-03-21 03:07:35 +00:00
|
|
|
memcpy(_key,b.field(p,sizeof(_key)),sizeof(_key)); p += sizeof(_key);
|
2013-10-21 14:29:44 +00:00
|
|
|
_lastUsed = b.template at<uint64_t>(p); p += sizeof(uint64_t);
|
2014-06-30 18:31:04 +00:00
|
|
|
_lastReceive = b.template at<uint64_t>(p); p += sizeof(uint64_t);
|
2013-07-13 18:28:26 +00:00
|
|
|
_lastUnicastFrame = b.template at<uint64_t>(p); p += sizeof(uint64_t);
|
|
|
|
_lastMulticastFrame = b.template at<uint64_t>(p); p += sizeof(uint64_t);
|
2014-10-11 23:26:02 +00:00
|
|
|
__lastAnnouncedTo = 0;
|
2014-09-30 23:28:25 +00:00
|
|
|
_vProto = b.template at<uint16_t>(p); p += sizeof(uint16_t);
|
2013-10-01 20:01:36 +00:00
|
|
|
_vMajor = b.template at<uint16_t>(p); p += sizeof(uint16_t);
|
|
|
|
_vMinor = b.template at<uint16_t>(p); p += sizeof(uint16_t);
|
|
|
|
_vRevision = b.template at<uint16_t>(p); p += sizeof(uint16_t);
|
2013-12-24 18:39:29 +00:00
|
|
|
_latency = b.template at<uint16_t>(p); p += sizeof(uint16_t);
|
2014-03-21 03:07:35 +00:00
|
|
|
unsigned int npaths = (unsigned int)b.template at<uint16_t>(p); p += sizeof(uint16_t);
|
|
|
|
_paths.clear();
|
|
|
|
for(unsigned int i=0;i<npaths;++i) {
|
|
|
|
_paths.push_back(Path());
|
|
|
|
p += _paths.back().deserialize(b,p);
|
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
return (p - startAt);
|
|
|
|
}
|
2014-10-12 18:42:49 +00:00
|
|
|
#endif // ZT_PEER_SERIALIZATION_VERSION
|
2014-01-29 00:12:24 +00:00
|
|
|
|
2013-12-24 18:39:29 +00:00
|
|
|
private:
|
2014-10-04 01:27:42 +00:00
|
|
|
void _announceMulticastGroups(const RuntimeEnvironment *RR,uint64_t now);
|
|
|
|
|
2013-10-05 14:19:12 +00:00
|
|
|
unsigned char _key[ZT_PEER_SECRET_KEY_LENGTH];
|
2013-07-04 20:56:19 +00:00
|
|
|
Identity _id;
|
|
|
|
|
2014-03-21 01:49:33 +00:00
|
|
|
std::vector<Path> _paths;
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-12-31 19:03:45 +00:00
|
|
|
volatile uint64_t _lastUsed;
|
2014-06-30 18:31:04 +00:00
|
|
|
volatile uint64_t _lastReceive; // direct or indirect
|
2013-12-31 19:03:45 +00:00
|
|
|
volatile uint64_t _lastUnicastFrame;
|
|
|
|
volatile uint64_t _lastMulticastFrame;
|
2014-10-11 23:26:02 +00:00
|
|
|
volatile uint64_t __lastAnnouncedTo; // not persisted -- shouldn't be unless Multicaster state is also persisted
|
2014-09-30 23:28:25 +00:00
|
|
|
volatile uint16_t _vProto;
|
|
|
|
volatile uint16_t _vMajor;
|
|
|
|
volatile uint16_t _vMinor;
|
|
|
|
volatile uint16_t _vRevision;
|
2013-12-31 19:03:45 +00:00
|
|
|
volatile unsigned int _latency;
|
2013-07-13 18:28:26 +00:00
|
|
|
|
2014-03-21 03:07:35 +00:00
|
|
|
Mutex _lock;
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
AtomicCounter __refCount;
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ZeroTier
|
|
|
|
|
2013-07-13 18:28:26 +00:00
|
|
|
// Add a swap() for shared ptr's to peers to speed up peer sorts
|
|
|
|
namespace std {
|
|
|
|
template<>
|
|
|
|
inline void swap(ZeroTier::SharedPtr<ZeroTier::Peer> &a,ZeroTier::SharedPtr<ZeroTier::Peer> &b)
|
|
|
|
{
|
|
|
|
a.swap(b);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#endif
|