/* * ZeroTier One - Network Virtualization Everywhere * Copyright (C) 2011-2016 ZeroTier, Inc. https://www.zerotier.com/ * * 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 . */ #ifndef ZT_PATH_HPP #define ZT_PATH_HPP #include #include #include #include #include "Constants.hpp" #include "InetAddress.hpp" #include "SharedPtr.hpp" #include "AtomicCounter.hpp" /** * Maximum return value of preferenceRank() */ #define ZT_PATH_MAX_PREFERENCE_RANK ((ZT_INETADDRESS_MAX_SCOPE << 1) | 1) namespace ZeroTier { class RuntimeEnvironment; /** * A path across the physical network */ class Path { friend class SharedPtr; public: /** * Efficient unique key for paths in a Hashtable */ class HashKey { public: HashKey() {} HashKey(const InetAddress &l,const InetAddress &r) { // This is an ad-hoc bit packing algorithm to yield unique keys for // remote addresses and their local-side counterparts if defined. // Portability across runtimes is not needed. if (r.ss_family == AF_INET) { _k[0] = (uint64_t)reinterpret_cast(&r)->sin_addr.s_addr; _k[1] = (uint64_t)reinterpret_cast(&r)->sin_port; if (l.ss_family == AF_INET) { _k[2] = (uint64_t)reinterpret_cast(&l)->sin_addr.s_addr; _k[3] = (uint64_t)reinterpret_cast(&r)->sin_port; } else { _k[2] = 0; _k[3] = 0; } } else if (r.ss_family == AF_INET6) { const uint8_t *a = reinterpret_cast(reinterpret_cast(&r)->sin6_addr.s6_addr); uint8_t *b = reinterpret_cast(_k); for(unsigned int i=0;i<16;++i) b[i] = a[i]; _k[2] = ~((uint64_t)reinterpret_cast(&r)->sin6_port); if (l.ss_family == AF_INET6) { _k[2] ^= ((uint64_t)reinterpret_cast(&r)->sin6_port) << 32; a = reinterpret_cast(reinterpret_cast(&l)->sin6_addr.s6_addr); b += 24; for(unsigned int i=0;i<8;++i) b[i] = a[i]; a += 8; for(unsigned int i=0;i<8;++i) b[i] ^= a[i]; } } else { _k[0] = 0; _k[1] = 0; _k[2] = 0; _k[3] = 0; } } inline unsigned long hashCode() const { return (unsigned long)(_k[0] + _k[1] + _k[2] + _k[3]); } inline bool operator==(const HashKey &k) const { return ( (_k[0] == k._k[0]) && (_k[1] == k._k[1]) && (_k[2] == k._k[2]) && (_k[3] == k._k[3]) ); } inline bool operator!=(const HashKey &k) const { return (!(*this == k)); } private: uint64_t _k[4]; }; Path() : _lastOut(0), _lastIn(0), _addr(), _localAddress(), _ipScope(InetAddress::IP_SCOPE_NONE) { } Path(const InetAddress &localAddress,const InetAddress &addr) : _lastOut(0), _lastIn(0), _addr(addr), _localAddress(localAddress), _ipScope(addr.ipScope()) { } /** * Called when a packet is received from this remote path, regardless of content * * @param t Time of receive */ inline void received(const uint64_t t) { _lastIn = t; } /** * Send a packet via this path (last out time is also updated) * * @param RR Runtime environment * @param data Packet data * @param len Packet length * @param now Current time * @return True if transport reported success */ bool send(const RuntimeEnvironment *RR,const void *data,unsigned int len,uint64_t now); /** * @return Address of local side of this path or NULL if unspecified */ inline const InetAddress &localAddress() const { return _localAddress; } /** * @return Physical address */ inline const InetAddress &address() const { return _addr; } /** * @return IP scope -- faster shortcut for address().ipScope() */ inline InetAddress::IpScope ipScope() const { return _ipScope; } /** * @return Preference rank, higher == better (will be less than 255) */ inline unsigned int preferenceRank() const { /* First, since the scope enum values in InetAddress.hpp are in order of * use preference rank, we take that. Then we multiple by two, yielding * a sequence like 0, 2, 4, 6, etc. Then if it's IPv6 we add one. This * makes IPv6 addresses of a given scope outrank IPv4 addresses of the * same scope -- e.g. 1 outranks 0. This makes us prefer IPv6, but not * if the address scope/class is of a fundamentally lower rank. */ return ( ((unsigned int)_ipScope << 1) | (unsigned int)(_addr.ss_family == AF_INET6) ); } /** * @return This path's overall quality score (higher is better) */ inline uint64_t score() const { return (_lastIn + (preferenceRank() * (ZT_PEER_PING_PERIOD / ZT_PATH_MAX_PREFERENCE_RANK))); } /** * Check whether this address is valid for a ZeroTier path * * This checks the address type and scope against address types and scopes * that we currently support for ZeroTier communication. * * @param a Address to check * @return True if address is good for ZeroTier path use */ static inline bool isAddressValidForPath(const InetAddress &a) { if ((a.ss_family == AF_INET)||(a.ss_family == AF_INET6)) { switch(a.ipScope()) { /* Note: we don't do link-local at the moment. Unfortunately these * cause several issues. The first is that they usually require a * device qualifier, which we don't handle yet and can't portably * push in PUSH_DIRECT_PATHS. The second is that some OSes assign * these very ephemerally or otherwise strangely. So we'll use * private, pseudo-private, shared (e.g. carrier grade NAT), or * global IP addresses. */ case InetAddress::IP_SCOPE_PRIVATE: case InetAddress::IP_SCOPE_PSEUDOPRIVATE: case InetAddress::IP_SCOPE_SHARED: case InetAddress::IP_SCOPE_GLOBAL: if (a.ss_family == AF_INET6) { // TEMPORARY HACK: for now, we are going to blacklist he.net IPv6 // tunnels due to very spotty performance and low MTU issues over // these IPv6 tunnel links. const uint8_t *ipd = reinterpret_cast(reinterpret_cast(&a)->sin6_addr.s6_addr); if ((ipd[0] == 0x20)&&(ipd[1] == 0x01)&&(ipd[2] == 0x04)&&(ipd[3] == 0x70)) return false; } return true; default: return false; } } return false; } /** * @return True if path appears alive */ inline bool alive(const uint64_t now) const { return ((now - _lastIn) <= ZT_PATH_ALIVE_TIMEOUT); } /** * @return True if this path needs a heartbeat */ inline bool needsHeartbeat(const uint64_t now) const { return ((now - _lastOut) > ZT_PATH_HEARTBEAT_PERIOD); } /** * @return Last time we sent something */ inline uint64_t lastOut() const { return _lastOut; } /** * @return Last time we received anything */ inline uint64_t lastIn() const { return _lastIn; } private: uint64_t _lastOut; uint64_t _lastIn; InetAddress _addr; InetAddress _localAddress; InetAddress::IpScope _ipScope; // memoize this since it's a computed value checked often AtomicCounter __refCount; }; } // namespace ZeroTier #endif