2013-07-04 20:56:19 +00:00
|
|
|
/*
|
|
|
|
* ZeroTier One - Global Peer to Peer Ethernet
|
|
|
|
* Copyright (C) 2012-2013 ZeroTier Networks LLC
|
|
|
|
*
|
|
|
|
* 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_NETWORK_HPP
|
|
|
|
#define ZT_NETWORK_HPP
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-09-11 19:09:53 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#include <string>
|
|
|
|
#include <set>
|
2013-07-29 17:56:20 +00:00
|
|
|
#include <map>
|
2013-07-04 20:56:19 +00:00
|
|
|
#include <vector>
|
2013-09-11 20:08:31 +00:00
|
|
|
#include <algorithm>
|
2013-07-04 20:56:19 +00:00
|
|
|
#include <stdexcept>
|
2013-07-29 17:56:20 +00:00
|
|
|
|
|
|
|
#include "Constants.hpp"
|
2013-10-18 16:01:48 +00:00
|
|
|
#include "NonCopyable.hpp"
|
2013-07-29 17:56:20 +00:00
|
|
|
#include "Utils.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "EthernetTap.hpp"
|
|
|
|
#include "Address.hpp"
|
|
|
|
#include "Mutex.hpp"
|
|
|
|
#include "SharedPtr.hpp"
|
|
|
|
#include "AtomicCounter.hpp"
|
|
|
|
#include "MulticastGroup.hpp"
|
2013-07-10 21:24:27 +00:00
|
|
|
#include "MAC.hpp"
|
2013-07-29 17:56:20 +00:00
|
|
|
#include "Dictionary.hpp"
|
|
|
|
#include "Identity.hpp"
|
|
|
|
#include "InetAddress.hpp"
|
2013-09-04 13:27:56 +00:00
|
|
|
#include "BandwidthAccount.hpp"
|
2013-10-18 16:01:48 +00:00
|
|
|
#include "NetworkConfig.hpp"
|
2013-10-07 19:29:03 +00:00
|
|
|
#include "CertificateOfMembership.hpp"
|
2014-01-28 07:13:36 +00:00
|
|
|
#include "Thread.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
namespace ZeroTier {
|
|
|
|
|
2013-07-29 17:56:20 +00:00
|
|
|
class RuntimeEnvironment;
|
2013-07-04 20:56:19 +00:00
|
|
|
class NodeConfig;
|
|
|
|
|
|
|
|
/**
|
2013-07-27 20:20:08 +00:00
|
|
|
* A virtual LAN
|
|
|
|
*
|
2013-07-29 17:56:20 +00:00
|
|
|
* Networks can be open or closed. Each network has an ID whose most
|
|
|
|
* significant 40 bits are the ZeroTier address of the node that should
|
|
|
|
* be contacted for network configuration. The least significant 24
|
|
|
|
* bits are arbitrary, allowing up to 2^24 networks per managing
|
|
|
|
* node.
|
2013-07-27 20:20:08 +00:00
|
|
|
*
|
|
|
|
* Open networks do not track membership. Anyone is allowed to communicate
|
2013-10-18 16:01:48 +00:00
|
|
|
* over them. For closed networks, each peer must distribute a certificate
|
|
|
|
* regularly that proves that they are allowed to communicate.
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
class Network : NonCopyable
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
|
|
|
friend class SharedPtr<Network>;
|
|
|
|
friend class NodeConfig;
|
|
|
|
|
2013-10-18 16:01:48 +00:00
|
|
|
private:
|
|
|
|
// Only NodeConfig can create, only SharedPtr can delete
|
2013-07-29 17:56:20 +00:00
|
|
|
|
2013-10-18 16:01:48 +00:00
|
|
|
// Actual construction happens in newInstance()
|
|
|
|
Network() throw() : _tap((EthernetTap *)0) {}
|
2013-08-06 04:05:39 +00:00
|
|
|
|
2013-10-18 16:01:48 +00:00
|
|
|
~Network();
|
2013-09-04 13:27:56 +00:00
|
|
|
|
|
|
|
/**
|
2013-10-18 16:01:48 +00:00
|
|
|
* Create a new Network instance and restore any saved state
|
2013-09-30 17:51:56 +00:00
|
|
|
*
|
2013-10-18 16:01:48 +00:00
|
|
|
* If there is no saved state, a dummy .conf is created on disk to remember
|
|
|
|
* this network across restarts.
|
2013-09-30 17:51:56 +00:00
|
|
|
*
|
2014-01-28 07:13:36 +00:00
|
|
|
* This can be a time consuming operation on some platforms (cough Windows
|
|
|
|
* cough).
|
|
|
|
*
|
2013-10-18 16:01:48 +00:00
|
|
|
* @param renv Runtime environment
|
|
|
|
* @param id Network ID
|
|
|
|
* @return Reference counted pointer to new network
|
|
|
|
* @throws std::runtime_error Unable to create tap device or other fatal error
|
2013-09-04 13:27:56 +00:00
|
|
|
*/
|
2013-10-18 16:01:48 +00:00
|
|
|
static SharedPtr<Network> newInstance(const RuntimeEnvironment *renv,uint64_t id);
|
2013-07-29 21:11:00 +00:00
|
|
|
|
2013-10-18 16:01:48 +00:00
|
|
|
/**
|
|
|
|
* Causes all persistent disk presence to be erased on delete
|
|
|
|
*/
|
|
|
|
inline void destroyOnDelete() throw() { _destroyOnDelete = true; }
|
2013-07-29 17:56:20 +00:00
|
|
|
|
2013-10-18 16:01:48 +00:00
|
|
|
public:
|
2013-08-08 14:41:17 +00:00
|
|
|
/**
|
2013-10-18 16:01:48 +00:00
|
|
|
* Possible network states
|
2013-08-08 14:41:17 +00:00
|
|
|
*/
|
|
|
|
enum Status
|
|
|
|
{
|
2014-01-28 07:13:36 +00:00
|
|
|
NETWORK_INITIALIZING,
|
2013-08-08 14:41:17 +00:00
|
|
|
NETWORK_WAITING_FOR_FIRST_AUTOCONF,
|
|
|
|
NETWORK_OK,
|
2013-10-16 21:47:26 +00:00
|
|
|
NETWORK_ACCESS_DENIED,
|
2014-01-28 07:13:36 +00:00
|
|
|
NETWORK_NOT_FOUND,
|
|
|
|
NETWORK_INITIALIZATION_FAILED
|
2013-08-08 14:41:17 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param s Status
|
|
|
|
* @return String description
|
|
|
|
*/
|
|
|
|
static const char *statusString(const Status s)
|
|
|
|
throw();
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* @return Network ID
|
|
|
|
*/
|
|
|
|
inline uint64_t id() const throw() { return _id; }
|
|
|
|
|
|
|
|
/**
|
2013-07-29 17:56:20 +00:00
|
|
|
* @return Address of network's controlling node
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-07-29 17:56:20 +00:00
|
|
|
inline Address controller() throw() { return Address(_id >> 24); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-08-03 16:53:46 +00:00
|
|
|
/**
|
|
|
|
* @return Network ID in hexadecimal form
|
|
|
|
*/
|
2013-09-11 20:17:51 +00:00
|
|
|
inline std::string idString()
|
2013-08-03 16:53:46 +00:00
|
|
|
{
|
|
|
|
char buf[64];
|
2013-08-30 21:05:43 +00:00
|
|
|
Utils::snprintf(buf,sizeof(buf),"%.16llx",(unsigned long long)_id);
|
2013-08-03 16:53:46 +00:00
|
|
|
return std::string(buf);
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2013-07-29 17:56:20 +00:00
|
|
|
* Update multicast groups for this network's tap
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* @return True if internal multicast group set has changed
|
|
|
|
*/
|
|
|
|
inline bool updateMulticastGroups()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
2014-01-28 07:13:36 +00:00
|
|
|
EthernetTap *t = _tap;
|
|
|
|
if (t)
|
|
|
|
return _tap->updateMulticastGroups(_multicastGroups);
|
|
|
|
return false;
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-07-29 17:56:20 +00:00
|
|
|
* @return Latest set of multicast groups for this network's tap
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
|
|
|
inline std::set<MulticastGroup> multicastGroups() const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
return _multicastGroups;
|
|
|
|
}
|
|
|
|
|
2013-07-29 17:56:20 +00:00
|
|
|
/**
|
|
|
|
* Set or update this network's configuration
|
|
|
|
*
|
|
|
|
* This is called by PacketDecoder when an update comes over the wire, or
|
|
|
|
* internally when an old config is reloaded from disk.
|
|
|
|
*
|
2014-01-28 07:13:36 +00:00
|
|
|
* This also cancels any netconf failure flags.
|
|
|
|
*
|
|
|
|
* The network can't accept configuration when in INITIALIZATION state,
|
|
|
|
* and so in that state this will just return false.
|
|
|
|
*
|
2013-07-29 17:56:20 +00:00
|
|
|
* @param conf Configuration in key/value dictionary form
|
2013-10-16 21:47:26 +00:00
|
|
|
* @param saveToDisk IF true (default), write config to disk
|
2014-01-28 07:13:36 +00:00
|
|
|
* @return True if configuration was accepted
|
|
|
|
*/
|
|
|
|
bool setConfiguration(const Dictionary &conf,bool saveToDisk = true);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set netconf failure to 'access denied'.
|
2013-07-29 17:56:20 +00:00
|
|
|
*/
|
2014-01-28 07:13:36 +00:00
|
|
|
inline void setAccessDenied()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
_netconfFailure = NETCONF_FAILURE_ACCESS_DENIED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set netconf failure to 'not found'.
|
|
|
|
*/
|
|
|
|
inline void setNotFound()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
_netconfFailure = NETCONF_FAILURE_NOT_FOUND;
|
|
|
|
}
|
2013-07-29 17:56:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Causes this network to request an updated configuration from its master node now
|
|
|
|
*/
|
|
|
|
void requestConfiguration();
|
|
|
|
|
2013-07-29 21:11:00 +00:00
|
|
|
/**
|
2013-10-16 21:47:26 +00:00
|
|
|
* Add or update a membership certificate
|
2013-07-29 21:11:00 +00:00
|
|
|
*
|
2013-10-18 16:01:48 +00:00
|
|
|
* This cert must have been signature checked first. Certs older than the
|
|
|
|
* cert on file are ignored and the newer cert remains in the database.
|
2013-07-29 21:11:00 +00:00
|
|
|
*
|
2013-10-16 21:47:26 +00:00
|
|
|
* @param cert Certificate of membership
|
2013-07-29 21:11:00 +00:00
|
|
|
*/
|
2013-10-16 21:47:26 +00:00
|
|
|
void addMembershipCertificate(const CertificateOfMembership &cert);
|
2013-07-29 21:11:00 +00:00
|
|
|
|
2013-10-07 20:13:52 +00:00
|
|
|
/**
|
|
|
|
* Push our membership certificate to a peer
|
|
|
|
*
|
|
|
|
* @param peer Destination peer address
|
|
|
|
* @param force If true, push even if we've already done so within required time frame
|
|
|
|
* @param now Current time
|
|
|
|
*/
|
2013-10-07 21:00:53 +00:00
|
|
|
inline void pushMembershipCertificate(const Address &peer,bool force,uint64_t now)
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
2013-10-24 20:57:26 +00:00
|
|
|
if ((_config)&&(!_config->isOpen())&&(_config->com()))
|
2013-10-07 21:00:53 +00:00
|
|
|
_pushMembershipCertificate(peer,force,now);
|
|
|
|
}
|
|
|
|
|
2013-08-06 04:05:39 +00:00
|
|
|
/**
|
|
|
|
* @param peer Peer address to check
|
|
|
|
* @return True if peer is allowed to communicate on this network
|
|
|
|
*/
|
2013-07-29 21:11:00 +00:00
|
|
|
bool isAllowed(const Address &peer) const;
|
|
|
|
|
|
|
|
/**
|
2013-08-06 04:05:39 +00:00
|
|
|
* Perform cleanup and possibly save state
|
2013-07-29 21:11:00 +00:00
|
|
|
*/
|
|
|
|
void clean();
|
|
|
|
|
2013-07-30 15:14:53 +00:00
|
|
|
/**
|
|
|
|
* @return Time of last updated configuration or 0 if none
|
|
|
|
*/
|
2013-10-07 20:13:52 +00:00
|
|
|
inline uint64_t lastConfigUpdate() const throw() { return _lastConfigUpdate; }
|
2013-07-30 15:14:53 +00:00
|
|
|
|
2013-08-08 14:41:17 +00:00
|
|
|
/**
|
|
|
|
* @return Status of this network
|
|
|
|
*/
|
2013-10-16 21:47:26 +00:00
|
|
|
inline Status status() const
|
|
|
|
throw()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
2014-01-28 07:13:36 +00:00
|
|
|
if (_tap) {
|
|
|
|
switch(_netconfFailure) {
|
|
|
|
case NETCONF_FAILURE_ACCESS_DENIED:
|
|
|
|
return NETWORK_ACCESS_DENIED;
|
|
|
|
case NETCONF_FAILURE_NOT_FOUND:
|
|
|
|
return NETWORK_NOT_FOUND;
|
|
|
|
case NETCONF_FAILURE_NONE:
|
|
|
|
if (_lastConfigUpdate > 0)
|
|
|
|
return NETWORK_OK;
|
|
|
|
else return NETWORK_WAITING_FOR_FIRST_AUTOCONF;
|
2014-01-28 07:16:15 +00:00
|
|
|
case NETCONF_FAILURE_INIT_FAILED:
|
2014-01-29 23:27:02 +00:00
|
|
|
default:
|
2014-01-28 07:16:15 +00:00
|
|
|
return NETWORK_INITIALIZATION_FAILED;
|
2014-01-28 07:13:36 +00:00
|
|
|
}
|
2014-01-29 23:27:02 +00:00
|
|
|
} else if (_netconfFailure == NETCONF_FAILURE_INIT_FAILED) {
|
2014-01-28 07:13:36 +00:00
|
|
|
return NETWORK_INITIALIZATION_FAILED;
|
2014-01-29 23:27:02 +00:00
|
|
|
} else return NETWORK_INITIALIZING;
|
2013-08-08 21:20:35 +00:00
|
|
|
}
|
|
|
|
|
2013-09-07 16:23:53 +00:00
|
|
|
/**
|
|
|
|
* Update multicast balance for an address and multicast group, return whether packet is allowed
|
|
|
|
*
|
|
|
|
* @param a Address that wants to send/relay packet
|
|
|
|
* @param mg Multicast group
|
|
|
|
* @param bytes Size of packet
|
|
|
|
* @return True if packet is within budget
|
|
|
|
*/
|
2013-09-04 13:27:56 +00:00
|
|
|
inline bool updateAndCheckMulticastBalance(const Address &a,const MulticastGroup &mg,unsigned int bytes)
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
2013-10-18 16:01:48 +00:00
|
|
|
if (!_config)
|
|
|
|
return false;
|
2013-09-07 16:23:53 +00:00
|
|
|
std::pair<Address,MulticastGroup> k(a,mg);
|
|
|
|
std::map< std::pair<Address,MulticastGroup>,BandwidthAccount >::iterator bal(_multicastRateAccounts.find(k));
|
|
|
|
if (bal == _multicastRateAccounts.end()) {
|
2013-10-18 16:01:48 +00:00
|
|
|
NetworkConfig::MulticastRate r(_config->multicastRate(mg));
|
2013-09-10 18:13:04 +00:00
|
|
|
bal = _multicastRateAccounts.insert(std::pair< std::pair<Address,MulticastGroup>,BandwidthAccount >(k,BandwidthAccount(r.preload,r.maxBalance,r.accrual))).first;
|
2013-09-07 16:23:53 +00:00
|
|
|
}
|
2013-09-11 20:08:31 +00:00
|
|
|
return bal->second.deduct(bytes);
|
2013-09-04 13:27:56 +00:00
|
|
|
}
|
|
|
|
|
2013-09-25 21:41:49 +00:00
|
|
|
/**
|
2013-10-18 16:01:48 +00:00
|
|
|
* Get current network config or throw exception
|
|
|
|
*
|
|
|
|
* This version never returns null. Instead it throws a runtime error if
|
|
|
|
* there is no current configuration. Callers should check isUp() first or
|
|
|
|
* use config2() to get with the potential for null.
|
|
|
|
*
|
|
|
|
* Since it never returns null, it's safe to config()->whatever().
|
|
|
|
*
|
|
|
|
* @return Network configuration (never null)
|
|
|
|
* @throws std::runtime_error Network configuration unavailable
|
2013-09-25 21:41:49 +00:00
|
|
|
*/
|
2013-10-18 16:01:48 +00:00
|
|
|
inline SharedPtr<NetworkConfig> config() const
|
2013-09-25 21:41:49 +00:00
|
|
|
{
|
2013-10-18 16:01:48 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
if (_config)
|
|
|
|
return _config;
|
|
|
|
throw std::runtime_error("no configuration");
|
2013-09-25 21:41:49 +00:00
|
|
|
}
|
|
|
|
|
2013-09-30 17:51:56 +00:00
|
|
|
/**
|
2013-10-25 17:43:04 +00:00
|
|
|
* Get current network config or return NULL
|
|
|
|
*
|
2013-10-18 16:01:48 +00:00
|
|
|
* @return Network configuration -- may be NULL
|
2013-09-30 17:51:56 +00:00
|
|
|
*/
|
2013-10-18 16:01:48 +00:00
|
|
|
inline SharedPtr<NetworkConfig> config2() const
|
|
|
|
throw()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
return _config;
|
|
|
|
}
|
2013-09-30 17:51:56 +00:00
|
|
|
|
2014-01-28 07:13:36 +00:00
|
|
|
/**
|
|
|
|
* Thread main method; do not call elsewhere
|
|
|
|
*/
|
|
|
|
void threadMain()
|
|
|
|
throw();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inject a frame into tap (if it's created)
|
|
|
|
*
|
|
|
|
* @param from Origin MAC
|
|
|
|
* @param to Destination MC
|
|
|
|
* @param etherType Ethernet frame type
|
|
|
|
* @param data Frame data
|
|
|
|
* @param len Frame length
|
|
|
|
*/
|
|
|
|
inline void tapPut(const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len)
|
|
|
|
{
|
|
|
|
EthernetTap *t = _tap;
|
|
|
|
if (t)
|
|
|
|
t->put(from,to,etherType,data,len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inject a frame into tap with local MAC as destination MAC (if it's created)
|
|
|
|
*
|
|
|
|
* @param from Origin MAC
|
|
|
|
* @param etherType Ethernet frame type
|
|
|
|
* @param data Frame data
|
|
|
|
* @param len Frame length
|
|
|
|
*/
|
|
|
|
inline void tapPut(const MAC &from,unsigned int etherType,const void *data,unsigned int len)
|
|
|
|
{
|
|
|
|
EthernetTap *t = _tap;
|
|
|
|
if (t)
|
|
|
|
t->put(from,t->mac(),etherType,data,len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Tap device name or empty string if still initializing
|
|
|
|
*/
|
|
|
|
inline std::string tapDeviceName() const
|
|
|
|
{
|
|
|
|
EthernetTap *t = _tap;
|
|
|
|
if (t)
|
|
|
|
return t->deviceName();
|
|
|
|
else return std::string();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Ethernet MAC address for this network's local interface
|
|
|
|
*/
|
|
|
|
inline const MAC &mac() const
|
|
|
|
{
|
|
|
|
return _mac;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Set of currently assigned IP addresses
|
|
|
|
*/
|
|
|
|
inline std::set<InetAddress> ips() const
|
|
|
|
{
|
|
|
|
EthernetTap *t = _tap;
|
|
|
|
if (t)
|
|
|
|
return t->ips();
|
|
|
|
return std::set<InetAddress>();
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
private:
|
2013-07-09 18:06:55 +00:00
|
|
|
static void _CBhandleTapData(void *arg,const MAC &from,const MAC &to,unsigned int etherType,const Buffer<4096> &data);
|
2013-10-18 16:01:48 +00:00
|
|
|
|
2013-10-07 21:00:53 +00:00
|
|
|
void _pushMembershipCertificate(const Address &peer,bool force,uint64_t now);
|
2013-08-06 14:15:05 +00:00
|
|
|
void _restoreState();
|
2013-10-16 21:47:26 +00:00
|
|
|
void _dumpMulticastCerts();
|
2013-07-09 18:06:55 +00:00
|
|
|
|
2013-10-18 16:01:48 +00:00
|
|
|
uint64_t _id;
|
2014-01-28 07:13:36 +00:00
|
|
|
MAC _mac;
|
2013-10-18 16:01:48 +00:00
|
|
|
const RuntimeEnvironment *_r;
|
2014-01-28 07:13:36 +00:00
|
|
|
EthernetTap *volatile _tap;
|
2013-07-04 20:56:19 +00:00
|
|
|
std::set<MulticastGroup> _multicastGroups;
|
2013-10-18 16:01:48 +00:00
|
|
|
std::map< std::pair<Address,MulticastGroup>,BandwidthAccount > _multicastRateAccounts;
|
2013-09-11 19:13:05 +00:00
|
|
|
std::map<Address,CertificateOfMembership> _membershipCertificates;
|
2013-10-07 20:13:52 +00:00
|
|
|
std::map<Address,uint64_t> _lastPushedMembershipCertificate;
|
2013-10-18 16:01:48 +00:00
|
|
|
SharedPtr<NetworkConfig> _config;
|
2013-08-03 16:53:46 +00:00
|
|
|
volatile uint64_t _lastConfigUpdate;
|
2013-08-06 04:05:39 +00:00
|
|
|
volatile bool _destroyOnDelete;
|
2014-01-28 07:13:36 +00:00
|
|
|
volatile enum {
|
|
|
|
NETCONF_FAILURE_NONE,
|
|
|
|
NETCONF_FAILURE_ACCESS_DENIED,
|
|
|
|
NETCONF_FAILURE_NOT_FOUND,
|
|
|
|
NETCONF_FAILURE_INIT_FAILED
|
|
|
|
} _netconfFailure;
|
|
|
|
Thread _setupThread;
|
2013-07-04 20:56:19 +00:00
|
|
|
Mutex _lock;
|
|
|
|
|
|
|
|
AtomicCounter __refCount;
|
|
|
|
};
|
|
|
|
|
|
|
|
} // naemspace ZeroTier
|
|
|
|
|
|
|
|
#endif
|