Bunch more refactoring for an even more compact NetworkConfig representation, especially rules.

This commit is contained in:
Adam Ierymenko 2016-04-26 17:11:25 -07:00
parent 25a5275921
commit b9dba97fdb
7 changed files with 524 additions and 248 deletions

View file

@ -23,10 +23,8 @@
#include <string.h>
#include <stdlib.h>
#include <map>
#include <vector>
#include <stdexcept>
#include <algorithm>
#include "../include/ZeroTierOne.h"
@ -59,6 +57,21 @@
*/
#define ZT_NETWORKCONFIG_FLAG_ENABLE_BROADCAST 0x0002
/**
* Device is a network preferred relay
*/
#define ZT_NETWORKCONFIG_SPECIALIST_TYPE_NETWORK_PREFERRED_RELAY 0x0000010000000000ULL
/**
* Device is an active bridge
*/
#define ZT_NETWORKCONFIG_SPECIALIST_TYPE_ACTIVE_BRIDGE 0x0000020000000000ULL
/**
* This device is allowed to send packets from any Ethernet MAC, including ZeroTier-reserved ones
*/
#define ZT_NETWORKCONFIG_SPECIALIST_TYPE_IMPOSTOR 0x0000040000000000ULL
namespace ZeroTier {
#ifdef ZT_SUPPORT_OLD_STYLE_NETCONF
@ -119,6 +132,15 @@ namespace ZeroTier {
class NetworkConfig
{
public:
/**
* Network preferred relay with optional physical endpoint addresses
*/
struct Relay
{
Address address;
InetAddress phy4,phy6;
};
/**
* Create an instance of a NetworkConfig for the test network ID
*
@ -128,7 +150,37 @@ public:
* @param self This node's ZT address
* @return Configuration for test network ID
*/
static NetworkConfig createTestNetworkConfig(const Address &self);
static inline NetworkConfig createTestNetworkConfig(const Address &self)
{
NetworkConfig nc;
nc._nwid = ZT_TEST_NETWORK_ID;
nc._timestamp = 1;
nc._revision = 1;
nc._issuedTo = self;
nc._multicastLimit = ZT_MULTICAST_DEFAULT_LIMIT;
nc._flags = ZT_NETWORKCONFIG_FLAG_ENABLE_BROADCAST;
nc._type = ZT_NETWORK_TYPE_PUBLIC;
nc._rules[nc._ruleCount].t = ZT_NETWORK_RULE_ACTION_ACCEPT;
nc._ruleCount = 1;
Utils::snprintf(nc._name,sizeof(nc._name),"ZT_TEST_NETWORK");
// Make up a V4 IP from 'self' in the 10.0.0.0/8 range -- no
// guarantee of uniqueness but collisions are unlikely.
uint32_t ip = (uint32_t)((self.toInt() & 0x00ffffff) | 0x0a000000); // 10.x.x.x
if ((ip & 0x000000ff) == 0x000000ff) ip ^= 0x00000001; // but not ending in .255
if ((ip & 0x000000ff) == 0x00000000) ip ^= 0x00000001; // or .0
nc._staticIps[0] = InetAddress(Utils::hton(ip),8);
// Assign an RFC4193-compliant IPv6 address -- will never collide
nc._staticIps[1] = InetAddress::makeIpv6rfc4193(ZT_TEST_NETWORK_ID,self.toInt());
nc._staticIpCount = 2;
return nc;
}
NetworkConfig()
{
@ -152,28 +204,20 @@ public:
*/
inline bool permitsEtherType(unsigned int etherType) const
{
unsigned int et = 0;
for(unsigned int i=0;i<_ruleCount;++i) {
if ((ZT_VirtualNetworkRuleMatches)_rules[i].matches == ZT_NETWORK_RULE_MATCHES_ETHERTYPE) {
if (_rules[i].datum.etherType == etherType)
return ((ZT_VirtualNetworkRuleAction)_rules[i].action == ZT_NETWORK_RULE_ACTION_ACCEPT);
} else if ((ZT_VirtualNetworkRuleMatches)_rules[i].matches == ZT_NETWORK_RULE_MATCHES_ALL) {
return ((ZT_VirtualNetworkRuleAction)_rules[i].action == ZT_NETWORK_RULE_ACTION_ACCEPT);
ZT_VirtualNetworkRuleType rt = (ZT_VirtualNetworkRuleType)(_rules[i].t & 0x7f);
if (rt == ZT_NETWORK_RULE_MATCH_ETHERTYPE) {
et = _rules[i].v.etherType;
} else if (rt == ZT_NETWORK_RULE_ACTION_ACCEPT) {
if ((!et)||(et == etherType))
return true;
et = 0;
}
}
return false;
}
#ifdef ZT_SUPPORT_OLD_STYLE_NETCONF
/**
* Parse an old-style dictionary and fill in structure
*
* @param ds String-serialized dictionary
* @param dslen Length of dictionary in bytes
* @throws std::invalid_argument Invalid dictionary
*/
void fromDictionary(const char *ds,unsigned int dslen);
#endif
/**
* @return Network ID that this config applies to
*/
@ -273,33 +317,47 @@ public:
inline std::vector<Address> activeBridges() const
{
std::vector<Address> r;
for(unsigned int i=0;i<_activeBridgeCount;++i)
r.push_back(_activeBridges[i]);
return r;
}
/**
* @return Network-preferred relays for this network (if none, only roots will be used)
*/
inline std::vector<ZT_VirtualNetworkStaticDevice> relays() const
{
std::vector<ZT_VirtualNetworkStaticDevice> r;
for(unsigned int i=0;i<_staticCount;++i) {
if ((_static[i].flags & ZT_NETWORK_STATIC_DEVICE_IS_RELAY) != 0)
r.push_back(_static[i]);
for(unsigned int i=0;i<_specialistCount;++i) {
if ((_specialists[i] & ZT_NETWORKCONFIG_SPECIALIST_TYPE_ACTIVE_BRIDGE) != 0)
r.push_back(Address(_specialists[i]));
}
return r;
}
/**
* @return Static device at index [i] (warning: no bounds checking! see staticDeviceCount() for count)
* Look up a static physical address for a given ZeroTier address
*
* @param zt ZeroTier address
* @param af Address family (e.g. AF_INET) or 0 for the first we find of any type
* @return Physical address, if any
*/
const ZT_VirtualNetworkStaticDevice &staticDevice(unsigned int i) const { return _static[i]; }
inline InetAddress staticPhysicalAddress(const Address &zt,unsigned int af) const
{
for(unsigned int i=0;i<_staticCount;++i) {
if (_static[i].zt == zt) {
if ((af == 0)||((unsigned int)_static[i].phy.ss_family == af))
return _static[i].phy;
}
}
return InetAddress();
}
/**
* @return Number of static devices defined in this network config
* @return Network-preferred relays for this network (if none, only roots will be used)
*/
unsigned int staticDeviceCount() const { return _staticCount; }
inline std::vector<Relay> relays() const
{
std::vector<Relay> r;
for(unsigned int i=0;i<_specialistCount;++i) {
if ((_specialists[i] & ZT_NETWORKCONFIG_SPECIALIST_TYPE_NETWORK_PREFERRED_RELAY) != 0) {
r.push_back(Relay());
r.back().address = _specialists[i];
r.back().phy4 = staticPhysicalAddress(r.back().address,AF_INET);
r.back().phy6 = staticPhysicalAddress(r.back().address,AF_INET6);
}
}
return r;
}
/**
* @param fromPeer Peer attempting to bridge other Ethernet peers onto network
@ -309,8 +367,38 @@ public:
{
if ((_flags & ZT_NETWORKCONFIG_FLAG_ALLOW_PASSIVE_BRIDGING) != 0)
return true;
for(unsigned int i=0;i<_activeBridgeCount;++i) {
if (_activeBridges[i] == fromPeer)
for(unsigned int i=0;i<_specialistCount;++i) {
if ((fromPeer == _specialists[i])&&((_specialists[i] & ZT_NETWORKCONFIG_SPECIALIST_TYPE_ACTIVE_BRIDGE) != 0))
return true;
}
return false;
}
/**
* Iterate through relays efficiently
*
* @param ptr Value-result parameter -- start by initializing with zero, then call until return is null
* @return Address of relay or NULL if no more
*/
Address nextRelay(unsigned int &ptr) const
{
while (ptr < _specialistCount) {
if ((_specialists[ptr] & ZT_NETWORKCONFIG_SPECIALIST_TYPE_NETWORK_PREFERRED_RELAY) != 0) {
return Address(_specialists[ptr]);
}
++ptr;
}
return Address();
}
/**
* @param zt ZeroTier address
* @return True if this address is a relay
*/
bool isRelay(const Address &zt) const
{
for(unsigned int i=0;i<_specialistCount;++i) {
if ((zt == _specialists[i])&&((_specialists[i] & ZT_NETWORKCONFIG_SPECIALIST_TYPE_NETWORK_PREFERRED_RELAY) != 0))
return true;
}
return false;
@ -324,6 +412,263 @@ public:
inline bool operator==(const NetworkConfig &nc) const { return (memcmp(this,&nc,sizeof(NetworkConfig)) == 0); }
inline bool operator!=(const NetworkConfig &nc) const { return (!(*this == nc)); }
template<unsigned int C>
inline void serialize(Buffer<C> &b) const
{
b.append((uint8_t)ZT_NETWORKCONFIG_V2_MARKER_BYTE);
b.append((uint16_t)0); // version
b.append((uint64_t)_nwid);
b.append((uint64_t)_timestamp);
b.append((uint64_t)_revision);
_issuedTo.appendTo(b);
b.append((uint32_t)_multicastLimit);
b.append((uint32_t)_flags);
b.append((uint8_t)_type);
unsigned int nl = (unsigned int)strlen(_name);
if (nl > 255) nl = 255; // sanity check
b.append((uint8_t)nl);
b.append((const void *)_name,nl);
b.append((uint16_t)_specialistCount);
for(unsigned int i=0;i<_specialistCount;++i)
b.append((uint64_t)_specialists[i]);
b.append((uint16_t)_localRouteCount);
for(unsigned int i=0;i<_localRouteCount;++i)
_localRoutes[i].serialize(b);
b.append((uint16_t)_staticIpCount);
for(unsigned int i=0;i<_staticIpCount;++i)
_staticIps[i].serialize(b);
b.append((uint16_t)_gatewayCount);
for(unsigned int i=0;i<_gatewayCount;++i)
_gateways[i].serialize(b);
b.append((uint16_t)_staticCount);
for(unsigned int i=0;i<_staticCount;++i) {
_static[i].zt.appendTo(b);
_static[i].phy.serialize(b);
}
b.append((uint16_t)_ruleCount);
for(unsigned int i=0;i<_ruleCount;++i) {
b.append((uint8_t)_rules[i].t);
switch((ZT_VirtualNetworkRuleType)(_rules[i].t & 0x7f)) {
//case ZT_NETWORK_RULE_ACTION_DROP:
//case ZT_NETWORK_RULE_ACTION_ACCEPT:
default:
b.append((uint8_t)0);
break;
case ZT_NETWORK_RULE_ACTION_TEE:
case ZT_NETWORK_RULE_ACTION_REDIRECT:
case ZT_NETWORK_RULE_MATCH_SOURCE_ZEROTIER_ADDRESS:
case ZT_NETWORK_RULE_MATCH_DEST_ZEROTIER_ADDRESS:
b.append((uint8_t)5);
Address(_rules[i].v.zt).appendTo(b);
break;
case ZT_NETWORK_RULE_MATCH_VLAN_ID:
b.append((uint8_t)2);
b.append((uint16_t)_rules[i].v.vlanId);
break;
case ZT_NETWORK_RULE_MATCH_VLAN_PCP:
b.append((uint8_t)1);
b.append((uint8_t)_rules[i].v.vlanPcp);
break;
case ZT_NETWORK_RULE_MATCH_VLAN_DEI:
b.append((uint8_t)1);
b.append((uint8_t)_rules[i].v.vlanDei);
break;
case ZT_NETWORK_RULE_MATCH_ETHERTYPE:
b.append((uint8_t)2);
b.append((uint16_t)_rules[i].v.etherType);
break;
case ZT_NETWORK_RULE_MATCH_MAC_SOURCE:
case ZT_NETWORK_RULE_MATCH_MAC_DEST:
b.append((uint8_t)6);
b.append(_rules[i].v.mac,6);
break;
case ZT_NETWORK_RULE_MATCH_IPV4_SOURCE:
case ZT_NETWORK_RULE_MATCH_IPV4_DEST:
b.append((uint8_t)5);
b.append(&(_rules[i].v.ipv4.ip),4);
b.append((uint8_t)_rules[i].v.ipv4.mask);
break;
case ZT_NETWORK_RULE_MATCH_IPV6_SOURCE:
case ZT_NETWORK_RULE_MATCH_IPV6_DEST:
b.append((uint8_t)17);
b.append(_rules[i].v.ipv6.ip,16);
b.append((uint8_t)_rules[i].v.ipv6.mask);
break;
case ZT_NETWORK_RULE_MATCH_IP_TOS:
b.append((uint8_t)1);
b.append((uint8_t)_rules[i].v.ipTos);
break;
case ZT_NETWORK_RULE_MATCH_IP_PROTOCOL:
b.append((uint8_t)1);
b.append((uint8_t)_rules[i].v.ipProtocol);
break;
case ZT_NETWORK_RULE_MATCH_IP_SOURCE_PORT_RANGE:
case ZT_NETWORK_RULE_MATCH_IP_DEST_PORT_RANGE:
b.append((uint8_t)4);
b.append((uint16_t)_rules[i].v.port[0]);
b.append((uint16_t)_rules[i].v.port[1]);
break;
case ZT_NETWORK_RULE_MATCH_CHARACTERISTICS:
b.append((uint8_t)8);
b.append((uint64_t)_rules[i].v.characteristics);
break;
case ZT_NETWORK_RULE_MATCH_FRAME_SIZE_RANGE:
b.append((uint8_t)4);
b.append((uint16_t)_rules[i].v.frameSize[0]);
b.append((uint16_t)_rules[i].v.frameSize[1]);
break;
}
}
b.append((uint16_t)0); // extended bytes, currently 0 since unused
}
template<unsigned int C>
inline unsigned int deserialize(const Buffer<C> &b,unsigned int startAt = 0)
{
memset(this,0,sizeof(NetworkConfig));
unsigned int p = startAt;
if (b[p++] != ZT_NETWORKCONFIG_V2_MARKER_BYTE)
throw std::invalid_argument("use fromDictionary() for old style netconf deserialization");
if (b.template at<uint16_t>(p) != 0)
throw std::invalid_argument("unrecognized version");
p += 2;
_nwid = b.template at<uint64_t>(p); p += 8;
_timestamp = b.template at<uint64_t>(p); p += 8;
_revision = b.template at<uint64_t>(p); p += 8;
_issuedTo.setTo(b.field(p,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); p += ZT_ADDRESS_LENGTH;
_multicastLimit = (unsigned int)b.template at<uint32_t>(p); p += 4;
_flags = (unsigned int)b.template at<uint32_t>(p); p += 4;
_type = (ZT_VirtualNetworkType)b[p++];
unsigned int nl = (unsigned int)b[p++];
if (nl > ZT_MAX_NETWORK_SHORT_NAME_LENGTH)
nl = ZT_MAX_NETWORK_SHORT_NAME_LENGTH;
memcpy(_name,b.field(p,nl),nl);
// _name will always be null terminated since field size is ZT_MAX_NETWORK_SHORT_NAME_LENGTH + 1
_specialistCount = (unsigned int)b.template at<uint16_t>(p); p += 2;
if (_specialistCount > ZT_MAX_NETWORK_SPECIALISTS)
throw std::invalid_argument("overflow (specialists)");
for(unsigned int i=0;i<_specialistCount;++i) {
_specialists[i] = b.template at<uint64_t>(p); p += 8;
}
_localRouteCount = (unsigned int)b.template at<uint16_t>(p); p += 2;
if (_localRouteCount > ZT_MAX_NETWORK_LOCAL_ROUTES)
throw std::invalid_argument("overflow (local routes)");
for(unsigned int i=0;i<_localRouteCount;++i) {
p += _localRoutes[i].deserialize(b,p);
}
_staticIpCount = (unsigned int)b.template at<uint16_t>(p); p += 2;
if (_staticIpCount > ZT_MAX_ZT_ASSIGNED_ADDRESSES)
throw std::invalid_argument("overflow (static IPs)");
for(unsigned int i=0;i<_staticIpCount;++i) {
p += _staticIps[i].deserialize(b,p);
}
_gatewayCount = (unsigned int)b.template at<uint16_t>(p); p += 2;
if (_gatewayCount > ZT_MAX_NETWORK_GATEWAYS)
throw std::invalid_argument("overflow (gateways)");
for(unsigned int i=0;i<_gatewayCount;++i) {
p += _gateways[i].deserialize(b,p);
}
_staticCount = (unsigned int)b.template at<uint16_t>(p); p += 2;
if (_staticCount > ZT_MAX_NETWORK_STATIC_PHYSICAL_ADDRESSES)
throw std::invalid_argument("overflow (static addresses)");
for(unsigned int i=0;i<_staticCount;++i) {
}
_ruleCount = (unsigned int)b.template at<uint16_t>(p); p += 2;
if (_ruleCount > ZT_MAX_NETWORK_RULES)
throw std::invalid_argument("overflow (rules)");
for(unsigned int i=0;i<_ruleCount;++i) {
_rules[i].t = (uint8_t)b[p++];
unsigned int rlen = (unsigned int)b[p++];
switch((ZT_VirtualNetworkRuleType)(_rules[i].t & 0x7f)) {
//case ZT_NETWORK_RULE_ACTION_DROP:
//case ZT_NETWORK_RULE_ACTION_ACCEPT:
default:
break;
case ZT_NETWORK_RULE_ACTION_TEE:
case ZT_NETWORK_RULE_ACTION_REDIRECT:
case ZT_NETWORK_RULE_MATCH_SOURCE_ZEROTIER_ADDRESS:
case ZT_NETWORK_RULE_MATCH_DEST_ZEROTIER_ADDRESS: {
Address tmp;
tmp.setTo(b.field(p,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH);
_rules[i].v.zt = tmp.toInt();
} break;
case ZT_NETWORK_RULE_MATCH_VLAN_ID:
_rules[i].v.vlanId = b.template at<uint16_t>(p);
break;
case ZT_NETWORK_RULE_MATCH_VLAN_PCP:
_rules[i].v.vlanPcp = (uint8_t)b[p];
break;
case ZT_NETWORK_RULE_MATCH_VLAN_DEI:
_rules[i].v.vlanDei = (uint8_t)b[p];
break;
case ZT_NETWORK_RULE_MATCH_ETHERTYPE:
_rules[i].v.etherType = b.template at<uint16_t>(p);
break;
case ZT_NETWORK_RULE_MATCH_MAC_SOURCE:
case ZT_NETWORK_RULE_MATCH_MAC_DEST:
memcpy(_rules[i].v.mac,b.field(p,6),6);
break;
case ZT_NETWORK_RULE_MATCH_IPV4_SOURCE:
case ZT_NETWORK_RULE_MATCH_IPV4_DEST:
memcpy(&(_rules[i].v.ipv4.ip),b.field(p,4),4);
_rules[i].v.ipv4.mask = (uint8_t)b[p+4];
break;
case ZT_NETWORK_RULE_MATCH_IPV6_SOURCE:
case ZT_NETWORK_RULE_MATCH_IPV6_DEST:
memcpy(_rules[i].v.ipv6.ip,b.field(p,16),16);
_rules[i].v.ipv6.mask = (uint8_t)b[p+16];
break;
case ZT_NETWORK_RULE_MATCH_IP_TOS:
_rules[i].v.ipTos = (uint8_t)b[p];
break;
case ZT_NETWORK_RULE_MATCH_IP_PROTOCOL:
_rules[i].v.ipProtocol = (uint8_t)b[p];
break;
case ZT_NETWORK_RULE_MATCH_IP_SOURCE_PORT_RANGE:
case ZT_NETWORK_RULE_MATCH_IP_DEST_PORT_RANGE:
_rules[i].v.port[0] = b.template at<uint16_t>(p);
_rules[i].v.port[1] = b.template at<uint16_t>(p+2);
break;
case ZT_NETWORK_RULE_MATCH_CHARACTERISTICS:
_rules[i].v.characteristics = b.template at<uint64_t>(p);
break;
case ZT_NETWORK_RULE_MATCH_FRAME_SIZE_RANGE:
_rules[i].v.frameSize[0] = b.template at<uint16_t>(p);
_rules[i].v.frameSize[1] = b.template at<uint16_t>(p+2);
break;
}
p += rlen;
}
p += b.template at<uint16_t>(p) + 2;
return (p - startAt);
}
#ifdef ZT_SUPPORT_OLD_STYLE_NETCONF
void fromDictionary(const char *ds,unsigned int dslen);
#endif
protected: // protected so that a subclass can fill this out in network controller code
uint64_t _nwid;
uint64_t _timestamp;
@ -335,14 +680,24 @@ protected: // protected so that a subclass can fill this out in network controll
char _name[ZT_MAX_NETWORK_SHORT_NAME_LENGTH + 1];
Address _activeBridges[ZT_MAX_NETWORK_ACTIVE_BRIDGES];
// Special ZeroTier addresses -- most significant 40 bits are address, least 24 are specialist type flags
uint64_t _specialists[ZT_MAX_NETWORK_SPECIALISTS];
// ZeroTier-managed IPs and routing table entries and stuff
InetAddress _localRoutes[ZT_MAX_NETWORK_LOCAL_ROUTES];
InetAddress _staticIps[ZT_MAX_ZT_ASSIGNED_ADDRESSES];
InetAddress _gateways[ZT_MAX_NETWORK_GATEWAYS];
ZT_VirtualNetworkStaticDevice _static[ZT_MAX_NETWORK_STATIC_DEVICES];
// ZeroTier to physical static mappings
struct {
Address zt;
InetAddress phy;
} _static[ZT_MAX_NETWORK_STATIC_PHYSICAL_ADDRESSES];
// Network rules (only Ethernet type filtering is currently supported)
ZT_VirtualNetworkRule _rules[ZT_MAX_NETWORK_RULES];
unsigned int _activeBridgeCount;
unsigned int _specialistCount;
unsigned int _localRouteCount;
unsigned int _staticIpCount;
unsigned int _gatewayCount;