Joseph Henry
7 years ago
51 changed files with 3151 additions and 1910 deletions
@ -0,0 +1,244 @@
|
||||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere |
||||
* Copyright (C) 2011-2019 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 <http://www.gnu.org/licenses/>.
|
||||
* |
||||
* -- |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include "DBMirrorSet.hpp" |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
DBMirrorSet::DBMirrorSet(DB::ChangeListener *listener) : |
||||
_listener(listener), |
||||
_running(true) |
||||
{ |
||||
_syncCheckerThread = std::thread([this]() { |
||||
for(;;) { |
||||
for(int i=0;i<120;++i) { // 1 minute delay between checks
|
||||
if (!_running) |
||||
return; |
||||
std::this_thread::sleep_for(std::chrono::milliseconds(500)); |
||||
} |
||||
|
||||
std::vector< std::shared_ptr<DB> > dbs; |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
if (_dbs.size() <= 1) |
||||
continue; // no need to do this if there's only one DB, so skip the iteration
|
||||
dbs = _dbs; |
||||
} |
||||
|
||||
for(auto db=dbs.begin();db!=dbs.end();++db) { |
||||
(*db)->each([this,&dbs,&db](uint64_t networkId,const nlohmann::json &network,uint64_t memberId,const nlohmann::json &member) { |
||||
try { |
||||
if (network.is_object()) { |
||||
if (memberId == 0) { |
||||
for(auto db2=dbs.begin();db2!=dbs.end();++db2) { |
||||
if (db->get() != db2->get()) { |
||||
nlohmann::json nw2; |
||||
if ((!(*db2)->get(networkId,nw2))||((nw2.is_object())&&(OSUtils::jsonInt(nw2["revision"],0) < OSUtils::jsonInt(network["revision"],0)))) { |
||||
nw2 = network; |
||||
(*db2)->save(nw2,false); |
||||
} |
||||
} |
||||
} |
||||
} else if (member.is_object()) { |
||||
for(auto db2=dbs.begin();db2!=dbs.end();++db2) { |
||||
if (db->get() != db2->get()) { |
||||
nlohmann::json nw2,m2; |
||||
if ((!(*db2)->get(networkId,nw2,memberId,m2))||((m2.is_object())&&(OSUtils::jsonInt(m2["revision"],0) < OSUtils::jsonInt(member["revision"],0)))) { |
||||
m2 = member; |
||||
(*db2)->save(m2,false); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} catch ( ... ) {} // skip entries that generate JSON errors
|
||||
}); |
||||
} |
||||
} |
||||
}); |
||||
} |
||||
|
||||
DBMirrorSet::~DBMirrorSet() |
||||
{ |
||||
_running = false; |
||||
_syncCheckerThread.join(); |
||||
} |
||||
|
||||
bool DBMirrorSet::hasNetwork(const uint64_t networkId) const |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
if ((*d)->hasNetwork(networkId)) |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
bool DBMirrorSet::get(const uint64_t networkId,nlohmann::json &network) |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
if ((*d)->get(networkId,network)) { |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
bool DBMirrorSet::get(const uint64_t networkId,nlohmann::json &network,const uint64_t memberId,nlohmann::json &member) |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
if ((*d)->get(networkId,network,memberId,member)) |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
bool DBMirrorSet::get(const uint64_t networkId,nlohmann::json &network,const uint64_t memberId,nlohmann::json &member,DB::NetworkSummaryInfo &info) |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
if ((*d)->get(networkId,network,memberId,member,info)) |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
bool DBMirrorSet::get(const uint64_t networkId,nlohmann::json &network,std::vector<nlohmann::json> &members) |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
if ((*d)->get(networkId,network,members)) |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
void DBMirrorSet::networks(std::set<uint64_t> &networks) |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
(*d)->networks(networks); |
||||
} |
||||
} |
||||
|
||||
bool DBMirrorSet::waitForReady() |
||||
{ |
||||
bool r = false; |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
r |= (*d)->waitForReady(); |
||||
} |
||||
return r; |
||||
} |
||||
|
||||
bool DBMirrorSet::isReady() |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
if (!(*d)->isReady()) |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
bool DBMirrorSet::save(nlohmann::json &record,bool notifyListeners) |
||||
{ |
||||
std::vector< std::shared_ptr<DB> > dbs; |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
dbs = _dbs; |
||||
} |
||||
if (notifyListeners) { |
||||
for(auto d=dbs.begin();d!=dbs.end();++d) { |
||||
if ((*d)->save(record,true)) |
||||
return true; |
||||
} |
||||
return false; |
||||
} else { |
||||
bool modified = false; |
||||
for(auto d=dbs.begin();d!=dbs.end();++d) { |
||||
modified |= (*d)->save(record,false); |
||||
} |
||||
return modified; |
||||
} |
||||
} |
||||
|
||||
void DBMirrorSet::eraseNetwork(const uint64_t networkId) |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
(*d)->eraseNetwork(networkId); |
||||
} |
||||
} |
||||
|
||||
void DBMirrorSet::eraseMember(const uint64_t networkId,const uint64_t memberId) |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
(*d)->eraseMember(networkId,memberId); |
||||
} |
||||
} |
||||
|
||||
void DBMirrorSet::nodeIsOnline(const uint64_t networkId,const uint64_t memberId,const InetAddress &physicalAddress) |
||||
{ |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
(*d)->nodeIsOnline(networkId,memberId,physicalAddress); |
||||
} |
||||
} |
||||
|
||||
void DBMirrorSet::onNetworkUpdate(const void *db,uint64_t networkId,const nlohmann::json &network) |
||||
{ |
||||
nlohmann::json record(network); |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
if (d->get() != db) { |
||||
(*d)->save(record,false); |
||||
} |
||||
} |
||||
_listener->onNetworkUpdate(this,networkId,network); |
||||
} |
||||
|
||||
void DBMirrorSet::onNetworkMemberUpdate(const void *db,uint64_t networkId,uint64_t memberId,const nlohmann::json &member) |
||||
{ |
||||
nlohmann::json record(member); |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
for(auto d=_dbs.begin();d!=_dbs.end();++d) { |
||||
if (d->get() != db) { |
||||
(*d)->save(record,false); |
||||
} |
||||
} |
||||
_listener->onNetworkMemberUpdate(this,networkId,memberId,member); |
||||
} |
||||
|
||||
void DBMirrorSet::onNetworkMemberDeauthorize(const void *db,uint64_t networkId,uint64_t memberId) |
||||
{ |
||||
_listener->onNetworkMemberDeauthorize(this,networkId,memberId); |
||||
} |
||||
|
||||
} // namespace ZeroTier
|
||||
@ -0,0 +1,84 @@
|
||||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere |
||||
* Copyright (C) 2011-2019 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 <http://www.gnu.org/licenses/>.
|
||||
* |
||||
* -- |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#ifndef ZT_DBMIRRORSET_HPP |
||||
#define ZT_DBMIRRORSET_HPP |
||||
|
||||
#include "DB.hpp" |
||||
|
||||
#include <vector> |
||||
#include <memory> |
||||
#include <mutex> |
||||
#include <set> |
||||
#include <thread> |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
class DBMirrorSet : public DB::ChangeListener |
||||
{ |
||||
public: |
||||
DBMirrorSet(DB::ChangeListener *listener); |
||||
virtual ~DBMirrorSet(); |
||||
|
||||
bool hasNetwork(const uint64_t networkId) const; |
||||
|
||||
bool get(const uint64_t networkId,nlohmann::json &network); |
||||
bool get(const uint64_t networkId,nlohmann::json &network,const uint64_t memberId,nlohmann::json &member); |
||||
bool get(const uint64_t networkId,nlohmann::json &network,const uint64_t memberId,nlohmann::json &member,DB::NetworkSummaryInfo &info); |
||||
bool get(const uint64_t networkId,nlohmann::json &network,std::vector<nlohmann::json> &members); |
||||
|
||||
void networks(std::set<uint64_t> &networks); |
||||
|
||||
bool waitForReady(); |
||||
bool isReady(); |
||||
bool save(nlohmann::json &record,bool notifyListeners); |
||||
void eraseNetwork(const uint64_t networkId); |
||||
void eraseMember(const uint64_t networkId,const uint64_t memberId); |
||||
void nodeIsOnline(const uint64_t networkId,const uint64_t memberId,const InetAddress &physicalAddress); |
||||
|
||||
// These are called by various DB instances when changes occur.
|
||||
virtual void onNetworkUpdate(const void *db,uint64_t networkId,const nlohmann::json &network); |
||||
virtual void onNetworkMemberUpdate(const void *db,uint64_t networkId,uint64_t memberId,const nlohmann::json &member); |
||||
virtual void onNetworkMemberDeauthorize(const void *db,uint64_t networkId,uint64_t memberId); |
||||
|
||||
inline void addDB(const std::shared_ptr<DB> &db) |
||||
{ |
||||
db->addListener(this); |
||||
std::lock_guard<std::mutex> l(_dbs_l); |
||||
_dbs.push_back(db); |
||||
} |
||||
|
||||
private: |
||||
DB::ChangeListener *const _listener; |
||||
std::atomic_bool _running; |
||||
std::thread _syncCheckerThread; |
||||
std::vector< std::shared_ptr< DB > > _dbs; |
||||
mutable std::mutex _dbs_l; |
||||
}; |
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif |
||||
@ -0,0 +1,36 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>CFBundleDevelopmentRegion</key> |
||||
<string>English</string> |
||||
<key>CFBundleExecutable</key> |
||||
<string>tap</string> |
||||
<key>CFBundleIdentifier</key> |
||||
<string>com.zerotier.tap</string> |
||||
<key>CFBundleInfoDictionaryVersion</key> |
||||
<string>6.0</string> |
||||
<key>CFBundleName</key> |
||||
<string>tap</string> |
||||
<key>CFBundlePackageType</key> |
||||
<string>KEXT</string> |
||||
<key>CFBundleShortVersionString</key> |
||||
<string>20150118</string> |
||||
<key>CFBundleSignature</key> |
||||
<string>????</string> |
||||
<key>CFBundleVersion</key> |
||||
<string>1.0</string> |
||||
<key>OSBundleLibraries</key> |
||||
<dict> |
||||
<key>com.apple.kpi.mach</key> |
||||
<string>8.0</string> |
||||
<key>com.apple.kpi.bsd</key> |
||||
<string>8.0</string> |
||||
<key>com.apple.kpi.libkern</key> |
||||
<string>8.0</string> |
||||
<key>com.apple.kpi.unsupported</key> |
||||
<string>8.0</string> |
||||
</dict> |
||||
</dict> |
||||
</plist> |
||||
|
||||
Binary file not shown.
@ -0,0 +1,105 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>files</key> |
||||
<dict/> |
||||
<key>files2</key> |
||||
<dict/> |
||||
<key>rules</key> |
||||
<dict> |
||||
<key>^Resources/</key> |
||||
<true/> |
||||
<key>^Resources/.*\.lproj/</key> |
||||
<dict> |
||||
<key>optional</key> |
||||
<true/> |
||||
<key>weight</key> |
||||
<real>1000</real> |
||||
</dict> |
||||
<key>^Resources/.*\.lproj/locversion.plist$</key> |
||||
<dict> |
||||
<key>omit</key> |
||||
<true/> |
||||
<key>weight</key> |
||||
<real>1100</real> |
||||
</dict> |
||||
<key>^version.plist$</key> |
||||
<true/> |
||||
</dict> |
||||
<key>rules2</key> |
||||
<dict> |
||||
<key>.*\.dSYM($|/)</key> |
||||
<dict> |
||||
<key>weight</key> |
||||
<real>11</real> |
||||
</dict> |
||||
<key>^(.*/)?\.DS_Store$</key> |
||||
<dict> |
||||
<key>omit</key> |
||||
<true/> |
||||
<key>weight</key> |
||||
<real>2000</real> |
||||
</dict> |
||||
<key>^(Frameworks|SharedFrameworks|PlugIns|Plug-ins|XPCServices|Helpers|MacOS|Library/(Automator|Spotlight|LoginItems))/</key> |
||||
<dict> |
||||
<key>nested</key> |
||||
<true/> |
||||
<key>weight</key> |
||||
<real>10</real> |
||||
</dict> |
||||
<key>^.*</key> |
||||
<true/> |
||||
<key>^Info\.plist$</key> |
||||
<dict> |
||||
<key>omit</key> |
||||
<true/> |
||||
<key>weight</key> |
||||
<real>20</real> |
||||
</dict> |
||||
<key>^PkgInfo$</key> |
||||
<dict> |
||||
<key>omit</key> |
||||
<true/> |
||||
<key>weight</key> |
||||
<real>20</real> |
||||
</dict> |
||||
<key>^Resources/</key> |
||||
<dict> |
||||
<key>weight</key> |
||||
<real>20</real> |
||||
</dict> |
||||
<key>^Resources/.*\.lproj/</key> |
||||
<dict> |
||||
<key>optional</key> |
||||
<true/> |
||||
<key>weight</key> |
||||
<real>1000</real> |
||||
</dict> |
||||
<key>^Resources/.*\.lproj/locversion.plist$</key> |
||||
<dict> |
||||
<key>omit</key> |
||||
<true/> |
||||
<key>weight</key> |
||||
<real>1100</real> |
||||
</dict> |
||||
<key>^[^/]+$</key> |
||||
<dict> |
||||
<key>nested</key> |
||||
<true/> |
||||
<key>weight</key> |
||||
<real>10</real> |
||||
</dict> |
||||
<key>^embedded\.provisionprofile$</key> |
||||
<dict> |
||||
<key>weight</key> |
||||
<real>20</real> |
||||
</dict> |
||||
<key>^version\.plist$</key> |
||||
<dict> |
||||
<key>weight</key> |
||||
<real>20</real> |
||||
</dict> |
||||
</dict> |
||||
</dict> |
||||
</plist> |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,135 @@
|
||||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere |
||||
* Copyright (C) 2011-2019 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 <http://www.gnu.org/licenses/>.
|
||||
* |
||||
* -- |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include "EthernetTap.hpp" |
||||
#include "OSUtils.hpp" |
||||
|
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#ifdef ZT_SDK |
||||
|
||||
#include "../controller/EmbeddedNetworkController.hpp" |
||||
#include "../node/Node.hpp" |
||||
#include "../include/VirtualTap.hpp" |
||||
|
||||
#else |
||||
|
||||
#ifdef __APPLE__ |
||||
#include <sys/sysctl.h> |
||||
#include "MacEthernetTap.hpp" |
||||
#include "MacKextEthernetTap.hpp" |
||||
#endif // __APPLE__
|
||||
|
||||
#ifdef __LINUX__ |
||||
#include "LinuxEthernetTap.hpp" |
||||
#endif // __LINUX__
|
||||
|
||||
#ifdef __WINDOWS__ |
||||
#include "WindowsEthernetTap.hpp" |
||||
#endif // __WINDOWS__
|
||||
|
||||
#ifdef __FreeBSD__ |
||||
#include "BSDEthernetTap.hpp" |
||||
#endif // __FreeBSD__
|
||||
|
||||
#ifdef __NetBSD__ |
||||
#include "NetBSDEthernetTap.hpp" |
||||
#endif // __NetBSD__
|
||||
|
||||
#ifdef __OpenBSD__ |
||||
#include "BSDEthernetTap.hpp" |
||||
#endif // __OpenBSD__
|
||||
|
||||
#endif |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
std::shared_ptr<EthernetTap> EthernetTap::newInstance( |
||||
const char *tapDeviceType, // OS-specific, NULL for default
|
||||
const char *homePath, |
||||
const MAC &mac, |
||||
unsigned int mtu, |
||||
unsigned int metric, |
||||
uint64_t nwid, |
||||
const char *friendlyName, |
||||
void (*handler)(void *,void *,uint64_t,const MAC &,const MAC &,unsigned int,unsigned int,const void *,unsigned int), |
||||
void *arg) |
||||
{ |
||||
|
||||
#ifdef ZT_SDK |
||||
|
||||
return std::shared_ptr<EthernetTap>(new VirtualTap(homePath,mac,mtu,metric,nwid,friendlyName,handler,arg)); |
||||
|
||||
#else // not ZT_SDK
|
||||
|
||||
#ifdef __APPLE__ |
||||
char osrelease[256]; |
||||
size_t size = sizeof(osrelease); |
||||
if (sysctlbyname("kern.osrelease",osrelease,&size,nullptr,0) == 0) { |
||||
char *dotAt = strchr(osrelease,'.'); |
||||
if (dotAt) { |
||||
*dotAt = (char)0; |
||||
// The "feth" virtual Ethernet device type appeared in Darwin 17.x.x. Older versions
|
||||
// (Sierra and earlier) must use the a kernel extension.
|
||||
if (strtol(osrelease,(char **)0,10) < 17) { |
||||
return std::shared_ptr<EthernetTap>(new MacKextEthernetTap(homePath,mac,mtu,metric,nwid,friendlyName,handler,arg)); |
||||
} else { |
||||
return std::shared_ptr<EthernetTap>(new MacEthernetTap(homePath,mac,mtu,metric,nwid,friendlyName,handler,arg)); |
||||
} |
||||
} |
||||
} |
||||
#endif // __APPLE__
|
||||
|
||||
#ifdef __LINUX__ |
||||
return std::shared_ptr<EthernetTap>(new LinuxEthernetTap(homePath,mac,mtu,metric,nwid,friendlyName,handler,arg)); |
||||
#endif // __LINUX__
|
||||
|
||||
#ifdef __WINDOWS__ |
||||
return std::shared_ptr<EthernetTap>(new WindowsEthernetTap(homePath,mac,mtu,metric,nwid,friendlyName,handler,arg)); |
||||
#endif // __WINDOWS__
|
||||
|
||||
#ifdef __FreeBSD__ |
||||
return std::shared_ptr<EthernetTap>(new BSDEthernetTap(homePath,mac,mtu,metric,nwid,friendlyName,handler,arg)); |
||||
#endif // __FreeBSD__
|
||||
|
||||
#ifdef __NetBSD__ |
||||
return std::shared_ptr<EthernetTap>(new NetBSDEthernetTap(homePath,mac,mtu,metric,nwid,friendlyName,handler,arg)); |
||||
#endif // __NetBSD__
|
||||
|
||||
#ifdef __OpenBSD__ |
||||
return std::shared_ptr<EthernetTap>(new BSDEthernetTap(homePath,mac,mtu,metric,nwid,friendlyName,handler,arg)); |
||||
#endif // __OpenBSD__
|
||||
|
||||
#endif // ZT_SDK?
|
||||
|
||||
return std::shared_ptr<EthernetTap>(); |
||||
} |
||||
|
||||
EthernetTap::EthernetTap() {} |
||||
EthernetTap::~EthernetTap() {} |
||||
|
||||
} // namespace ZeroTier
|
||||
@ -0,0 +1,72 @@
|
||||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere |
||||
* Copyright (C) 2011-2019 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 <http://www.gnu.org/licenses/>.
|
||||
* |
||||
* -- |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#ifndef ZT_ETHERNETTAP_HPP |
||||
#define ZT_ETHERNETTAP_HPP |
||||
|
||||
#include "../node/Constants.hpp" |
||||
#include "../node/MAC.hpp" |
||||
#include "../node/InetAddress.hpp" |
||||
#include "../node/MulticastGroup.hpp" |
||||
|
||||
#include <string> |
||||
#include <memory> |
||||
#include <vector> |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
class EthernetTap |
||||
{ |
||||
public: |
||||
static std::shared_ptr<EthernetTap> newInstance( |
||||
const char *tapDeviceType, // OS-specific, NULL for default
|
||||
const char *homePath, |
||||
const MAC &mac, |
||||
unsigned int mtu, |
||||
unsigned int metric, |
||||
uint64_t nwid, |
||||
const char *friendlyName, |
||||
void (*handler)(void *,void *,uint64_t,const MAC &,const MAC &,unsigned int,unsigned int,const void *,unsigned int), |
||||
void *arg); |
||||
|
||||
EthernetTap(); |
||||
virtual ~EthernetTap(); |
||||
|
||||
virtual void setEnabled(bool en) = 0; |
||||
virtual bool enabled() const = 0; |
||||
virtual bool addIp(const InetAddress &ip) = 0; |
||||
virtual bool removeIp(const InetAddress &ip) = 0; |
||||
virtual std::vector<InetAddress> ips() const = 0; |
||||
virtual void put(const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len) = 0; |
||||
virtual std::string deviceName() const = 0; |
||||
virtual void setFriendlyName(const char *friendlyName) = 0; |
||||
virtual void scanMulticastGroups(std::vector<MulticastGroup> &added,std::vector<MulticastGroup> &removed) = 0; |
||||
virtual void setMtu(unsigned int mtu) = 0; |
||||
}; |
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif |
||||
@ -0,0 +1,703 @@
|
||||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere |
||||
* Copyright (C) 2011-2018 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 <http://www.gnu.org/licenses/>.
|
||||
* |
||||
* -- |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <errno.h> |
||||
|
||||
#include <unistd.h> |
||||
#include <signal.h> |
||||
|
||||
#include <fcntl.h> |
||||
#include <sys/types.h> |
||||
#include <sys/stat.h> |
||||
#include <sys/ioctl.h> |
||||
#include <sys/wait.h> |
||||
#include <sys/select.h> |
||||
#include <sys/cdefs.h> |
||||
#include <sys/uio.h> |
||||
#include <sys/param.h> |
||||
#include <sys/ioctl.h> |
||||
#include <sys/socket.h> |
||||
#include <netinet/in.h> |
||||
#include <arpa/inet.h> |
||||
#include <net/route.h> |
||||
#include <net/if.h> |
||||
#include <net/if_arp.h> |
||||
#include <net/if_dl.h> |
||||
#include <net/if_media.h> |
||||
#include <sys/sysctl.h> |
||||
#include <netinet6/in6_var.h> |
||||
#include <netinet/in_var.h> |
||||
#include <netinet/icmp6.h> |
||||
|
||||
// OSX compile fix... in6_var defines this in a struct which namespaces it for C++ ... why?!?
|
||||
struct prf_ra { |
||||
u_char onlink : 1; |
||||
u_char autonomous : 1; |
||||
u_char reserved : 6; |
||||
} prf_ra; |
||||
|
||||
#include <netinet6/nd6.h> |
||||
#include <ifaddrs.h> |
||||
|
||||
// These are KERNEL_PRIVATE... why?
|
||||
#ifndef SIOCAUTOCONF_START |
||||
#define SIOCAUTOCONF_START _IOWR('i', 132, struct in6_ifreq) /* accept rtadvd on this interface */ |
||||
#endif |
||||
#ifndef SIOCAUTOCONF_STOP |
||||
#define SIOCAUTOCONF_STOP _IOWR('i', 133, struct in6_ifreq) /* stop accepting rtadv for this interface */ |
||||
#endif |
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// --------------------------------------------------------------------------
|
||||
// This source is from:
|
||||
// http://www.opensource.apple.com/source/Libinfo/Libinfo-406.17/gen.subproj/getifmaddrs.c?txt
|
||||
// It's here because OSX 10.6 does not have this convenience function.
|
||||
|
||||
#define SALIGN (sizeof(uint32_t) - 1) |
||||
#define SA_RLEN(sa) ((sa)->sa_len ? (((sa)->sa_len + SALIGN) & ~SALIGN) : \ |
||||
(SALIGN + 1)) |
||||
#define MAX_SYSCTL_TRY 5 |
||||
#define RTA_MASKS (RTA_GATEWAY | RTA_IFP | RTA_IFA) |
||||
|
||||
/* FreeBSD uses NET_RT_IFMALIST and RTM_NEWMADDR from <sys/socket.h> */ |
||||
/* We can use NET_RT_IFLIST2 and RTM_NEWMADDR2 on Darwin */ |
||||
//#define DARWIN_COMPAT
|
||||
|
||||
//#ifdef DARWIN_COMPAT
|
||||
#define GIM_SYSCTL_MIB NET_RT_IFLIST2 |
||||
#define GIM_RTM_ADDR RTM_NEWMADDR2 |
||||
//#else
|
||||
//#define GIM_SYSCTL_MIB NET_RT_IFMALIST
|
||||
//#define GIM_RTM_ADDR RTM_NEWMADDR
|
||||
//#endif
|
||||
|
||||
// Not in 10.6 includes so use our own
|
||||
struct _intl_ifmaddrs { |
||||
struct _intl_ifmaddrs *ifma_next; |
||||
struct sockaddr *ifma_name; |
||||
struct sockaddr *ifma_addr; |
||||
struct sockaddr *ifma_lladdr; |
||||
}; |
||||
|
||||
static inline int _intl_getifmaddrs(struct _intl_ifmaddrs **pif) |
||||
{ |
||||
int icnt = 1; |
||||
int dcnt = 0; |
||||
int ntry = 0; |
||||
size_t len; |
||||
size_t needed; |
||||
int mib[6]; |
||||
int i; |
||||
char *buf; |
||||
char *data; |
||||
char *next; |
||||
char *p; |
||||
struct ifma_msghdr2 *ifmam; |
||||
struct _intl_ifmaddrs *ifa, *ift; |
||||
struct rt_msghdr *rtm; |
||||
struct sockaddr *sa; |
||||
|
||||
mib[0] = CTL_NET; |
||||
mib[1] = PF_ROUTE; |
||||
mib[2] = 0; /* protocol */ |
||||
mib[3] = 0; /* wildcard address family */ |
||||
mib[4] = GIM_SYSCTL_MIB; |
||||
mib[5] = 0; /* no flags */ |
||||
do { |
||||
if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) |
||||
return (-1); |
||||
if ((buf = (char *)malloc(needed)) == NULL) |
||||
return (-1); |
||||
if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) { |
||||
if (errno != ENOMEM || ++ntry >= MAX_SYSCTL_TRY) { |
||||
free(buf); |
||||
return (-1); |
||||
} |
||||
free(buf); |
||||
buf = NULL; |
||||
} |
||||
} while (buf == NULL); |
||||
|
||||
for (next = buf; next < buf + needed; next += rtm->rtm_msglen) { |
||||
rtm = (struct rt_msghdr *)(void *)next; |
||||
if (rtm->rtm_version != RTM_VERSION) |
||||
continue; |
||||
switch (rtm->rtm_type) { |
||||
case GIM_RTM_ADDR: |
||||
ifmam = (struct ifma_msghdr2 *)(void *)rtm; |
||||
if ((ifmam->ifmam_addrs & RTA_IFA) == 0) |
||||
break; |
||||
icnt++; |
||||
p = (char *)(ifmam + 1); |
||||
for (i = 0; i < RTAX_MAX; i++) { |
||||
if ((RTA_MASKS & ifmam->ifmam_addrs & |
||||
(1 << i)) == 0) |
||||
continue; |
||||
sa = (struct sockaddr *)(void *)p; |
||||
len = SA_RLEN(sa); |
||||
dcnt += len; |
||||
p += len; |
||||
} |
||||
break; |
||||
} |
||||
} |
||||
|
||||
data = (char *)malloc(sizeof(struct _intl_ifmaddrs) * icnt + dcnt); |
||||
if (data == NULL) { |
||||
free(buf); |
||||
return (-1); |
||||
} |
||||
|
||||
ifa = (struct _intl_ifmaddrs *)(void *)data; |
||||
data += sizeof(struct _intl_ifmaddrs) * icnt; |
||||
|
||||
memset(ifa, 0, sizeof(struct _intl_ifmaddrs) * icnt); |
||||
ift = ifa; |
||||
|
||||
for (next = buf; next < buf + needed; next += rtm->rtm_msglen) { |
||||
rtm = (struct rt_msghdr *)(void *)next; |
||||
if (rtm->rtm_version != RTM_VERSION) |
||||
continue; |
||||
|
||||
switch (rtm->rtm_type) { |
||||
case GIM_RTM_ADDR: |
||||
ifmam = (struct ifma_msghdr2 *)(void *)rtm; |
||||
if ((ifmam->ifmam_addrs & RTA_IFA) == 0) |
||||
break; |
||||
|
||||
p = (char *)(ifmam + 1); |
||||
for (i = 0; i < RTAX_MAX; i++) { |
||||
if ((RTA_MASKS & ifmam->ifmam_addrs & |
||||
(1 << i)) == 0) |
||||
continue; |
||||
sa = (struct sockaddr *)(void *)p; |
||||
len = SA_RLEN(sa); |
||||
switch (i) { |
||||
case RTAX_GATEWAY: |
||||
ift->ifma_lladdr = |
||||
(struct sockaddr *)(void *)data; |
||||
memcpy(data, p, len); |
||||
data += len; |
||||
break; |
||||
|
||||
case RTAX_IFP: |
||||
ift->ifma_name = |
||||
(struct sockaddr *)(void *)data; |
||||
memcpy(data, p, len); |
||||
data += len; |
||||
break; |
||||
|
||||
case RTAX_IFA: |
||||
ift->ifma_addr = |
||||
(struct sockaddr *)(void *)data; |
||||
memcpy(data, p, len); |
||||
data += len; |
||||
break; |
||||
|
||||
default: |
||||
data += len; |
||||
break; |
||||
} |
||||
p += len; |
||||
} |
||||
ift->ifma_next = ift + 1; |
||||
ift = ift->ifma_next; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
free(buf); |
||||
|
||||
if (ift > ifa) { |
||||
ift--; |
||||
ift->ifma_next = NULL; |
||||
*pif = ifa; |
||||
} else { |
||||
*pif = NULL; |
||||
free(ifa); |
||||
} |
||||
return (0); |
||||
} |
||||
|
||||
static inline void _intl_freeifmaddrs(struct _intl_ifmaddrs *ifmp) |
||||
{ |
||||
free(ifmp); |
||||
} |
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
#include <string> |
||||
#include <map> |
||||
#include <set> |
||||
#include <algorithm> |
||||
|
||||
#include "../node/Constants.hpp" |
||||
#include "../node/Utils.hpp" |
||||
#include "../node/Mutex.hpp" |
||||
#include "../node/Dictionary.hpp" |
||||
#include "OSUtils.hpp" |
||||
#include "MacKextEthernetTap.hpp" |
||||
|
||||
// ff:ff:ff:ff:ff:ff with no ADI
|
||||
static const ZeroTier::MulticastGroup _blindWildcardMulticastGroup(ZeroTier::MAC(0xff),0); |
||||
|
||||
static inline bool _setIpv6Stuff(const char *ifname,bool performNUD,bool acceptRouterAdverts) |
||||
{ |
||||
struct in6_ndireq nd; |
||||
struct in6_ifreq ifr; |
||||
|
||||
int s = socket(AF_INET6,SOCK_DGRAM,0); |
||||
if (s <= 0) |
||||
return false; |
||||
|
||||
memset(&nd,0,sizeof(nd)); |
||||
strncpy(nd.ifname,ifname,sizeof(nd.ifname)); |
||||
|
||||
if (ioctl(s,SIOCGIFINFO_IN6,&nd)) { |
||||
close(s); |
||||
return false; |
||||
} |
||||
|
||||
unsigned long oldFlags = (unsigned long)nd.ndi.flags; |
||||
|
||||
if (performNUD) |
||||
nd.ndi.flags |= ND6_IFF_PERFORMNUD; |
||||
else nd.ndi.flags &= ~ND6_IFF_PERFORMNUD; |
||||
|
||||
if (oldFlags != (unsigned long)nd.ndi.flags) { |
||||
if (ioctl(s,SIOCSIFINFO_FLAGS,&nd)) { |
||||
close(s); |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
memset(&ifr,0,sizeof(ifr)); |
||||
strncpy(ifr.ifr_name,ifname,sizeof(ifr.ifr_name)); |
||||
if (ioctl(s,acceptRouterAdverts ? SIOCAUTOCONF_START : SIOCAUTOCONF_STOP,&ifr)) { |
||||
close(s); |
||||
return false; |
||||
} |
||||
|
||||
close(s); |
||||
return true; |
||||
} |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
static long globalTapsRunning = 0; |
||||
static Mutex globalTapCreateLock; |
||||
|
||||
MacKextEthernetTap::MacKextEthernetTap( |
||||
const char *homePath, |
||||
const MAC &mac, |
||||
unsigned int mtu, |
||||
unsigned int metric, |
||||
uint64_t nwid, |
||||
const char *friendlyName, |
||||
void (*handler)(void *,void *,uint64_t,const MAC &,const MAC &,unsigned int,unsigned int,const void *data,unsigned int len), |
||||
void *arg) : |
||||
_handler(handler), |
||||
_arg(arg), |
||||
_nwid(nwid), |
||||
_homePath(homePath), |
||||
_mtu(mtu), |
||||
_metric(metric), |
||||
_fd(0), |
||||
_enabled(true) |
||||
{ |
||||
char devpath[64],ethaddr[64],mtustr[32],metstr[32],nwids[32]; |
||||
struct stat stattmp; |
||||
|
||||
OSUtils::ztsnprintf(nwids,sizeof(nwids),"%.16llx",nwid); |
||||
|
||||
Mutex::Lock _gl(globalTapCreateLock); |
||||
|
||||
if (::stat("/dev/zt0",&stattmp)) { |
||||
long kextpid = (long)vfork(); |
||||
if (kextpid == 0) { |
||||
::chdir(homePath); |
||||
OSUtils::redirectUnixOutputs("/dev/null",(const char *)0); |
||||
::execl("/sbin/kextload","/sbin/kextload","-q","-repository",homePath,"tap.kext",(const char *)0); |
||||
::_exit(-1); |
||||
} else if (kextpid > 0) { |
||||
int exitcode = -1; |
||||
::waitpid(kextpid,&exitcode,0); |
||||
} |
||||
::usleep(500); // give tap device driver time to start up and try again
|
||||
if (::stat("/dev/zt0",&stattmp)) |
||||
throw std::runtime_error("/dev/zt# tap devices do not exist and cannot load tap.kext"); |
||||
} |
||||
|
||||
// Try to reopen the last device we had, if we had one and it's still unused.
|
||||
std::map<std::string,std::string> globalDeviceMap; |
||||
FILE *devmapf = fopen((_homePath + ZT_PATH_SEPARATOR_S + "devicemap").c_str(),"r"); |
||||
if (devmapf) { |
||||
char buf[256]; |
||||
while (fgets(buf,sizeof(buf),devmapf)) { |
||||
char *x = (char *)0; |
||||
char *y = (char *)0; |
||||
char *saveptr = (char *)0; |
||||
for(char *f=Utils::stok(buf,"\r\n=",&saveptr);(f);f=Utils::stok((char *)0,"\r\n=",&saveptr)) { |
||||
if (!x) x = f; |
||||
else if (!y) y = f; |
||||
else break; |
||||
} |
||||
if ((x)&&(y)&&(x[0])&&(y[0])) |
||||
globalDeviceMap[x] = y; |
||||
} |
||||
fclose(devmapf); |
||||
} |
||||
bool recalledDevice = false; |
||||
std::map<std::string,std::string>::const_iterator gdmEntry = globalDeviceMap.find(nwids); |
||||
if (gdmEntry != globalDeviceMap.end()) { |
||||
std::string devpath("/dev/"); devpath.append(gdmEntry->second); |
||||
if (stat(devpath.c_str(),&stattmp) == 0) { |
||||
_fd = ::open(devpath.c_str(),O_RDWR); |
||||
if (_fd > 0) { |
||||
_dev = gdmEntry->second; |
||||
recalledDevice = true; |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Open the first unused tap device if we didn't recall a previous one.
|
||||
if (!recalledDevice) { |
||||
for(int i=0;i<64;++i) { |
||||
OSUtils::ztsnprintf(devpath,sizeof(devpath),"/dev/zt%d",i); |
||||
if (stat(devpath,&stattmp)) |
||||
throw std::runtime_error("no more TAP devices available"); |
||||
_fd = ::open(devpath,O_RDWR); |
||||
if (_fd > 0) { |
||||
char foo[16]; |
||||
OSUtils::ztsnprintf(foo,sizeof(foo),"zt%d",i); |
||||
_dev = foo; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
if (_fd <= 0) |
||||
throw std::runtime_error("unable to open TAP device or no more devices available"); |
||||
|
||||
if (fcntl(_fd,F_SETFL,fcntl(_fd,F_GETFL) & ~O_NONBLOCK) == -1) { |
||||
::close(_fd); |
||||
throw std::runtime_error("unable to set flags on file descriptor for TAP device"); |
||||
} |
||||
|
||||
// Configure MAC address and MTU, bring interface up
|
||||
OSUtils::ztsnprintf(ethaddr,sizeof(ethaddr),"%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",(int)mac[0],(int)mac[1],(int)mac[2],(int)mac[3],(int)mac[4],(int)mac[5]); |
||||
OSUtils::ztsnprintf(mtustr,sizeof(mtustr),"%u",_mtu); |
||||
OSUtils::ztsnprintf(metstr,sizeof(metstr),"%u",_metric); |
||||
long cpid = (long)vfork(); |
||||
if (cpid == 0) { |
||||
::execl("/sbin/ifconfig","/sbin/ifconfig",_dev.c_str(),"lladdr",ethaddr,"mtu",mtustr,"metric",metstr,"up",(const char *)0); |
||||
::_exit(-1); |
||||
} else if (cpid > 0) { |
||||
int exitcode = -1; |
||||
::waitpid(cpid,&exitcode,0); |
||||
if (exitcode) { |
||||
::close(_fd); |
||||
throw std::runtime_error("ifconfig failure setting link-layer address and activating tap interface"); |
||||
} |
||||
} |
||||
|
||||
_setIpv6Stuff(_dev.c_str(),true,false); |
||||
|
||||
// Set close-on-exec so that devices cannot persist if we fork/exec for update
|
||||
fcntl(_fd,F_SETFD,fcntl(_fd,F_GETFD) | FD_CLOEXEC); |
||||
|
||||
::pipe(_shutdownSignalPipe); |
||||
|
||||
++globalTapsRunning; |
||||
|
||||
globalDeviceMap[nwids] = _dev; |
||||
devmapf = fopen((_homePath + ZT_PATH_SEPARATOR_S + "devicemap").c_str(),"w"); |
||||
if (devmapf) { |
||||
gdmEntry = globalDeviceMap.begin(); |
||||
while (gdmEntry != globalDeviceMap.end()) { |
||||
fprintf(devmapf,"%s=%s\n",gdmEntry->first.c_str(),gdmEntry->second.c_str()); |
||||
++gdmEntry; |
||||
} |
||||
fclose(devmapf); |
||||
} |
||||
|
||||
_thread = Thread::start(this); |
||||
} |
||||
|
||||
MacKextEthernetTap::~MacKextEthernetTap() |
||||
{ |
||||
::write(_shutdownSignalPipe[1],"\0",1); // causes thread to exit
|
||||
Thread::join(_thread); |
||||
|
||||
::close(_fd); |
||||
::close(_shutdownSignalPipe[0]); |
||||
::close(_shutdownSignalPipe[1]); |
||||
|
||||
{ |
||||
Mutex::Lock _gl(globalTapCreateLock); |
||||
if (--globalTapsRunning <= 0) { |
||||
globalTapsRunning = 0; // sanity check -- should not be possible
|
||||
|
||||
char tmp[16384]; |
||||
sprintf(tmp,"%s/%s",_homePath.c_str(),"tap.kext"); |
||||
long kextpid = (long)vfork(); |
||||
if (kextpid == 0) { |
||||
OSUtils::redirectUnixOutputs("/dev/null",(const char *)0); |
||||
::execl("/sbin/kextunload","/sbin/kextunload",tmp,(const char *)0); |
||||
::_exit(-1); |
||||
} else if (kextpid > 0) { |
||||
int exitcode = -1; |
||||
::waitpid(kextpid,&exitcode,0); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
void MacKextEthernetTap::setEnabled(bool en) |
||||
{ |
||||
_enabled = en; |
||||
// TODO: interface status change
|
||||
} |
||||
|
||||
bool MacKextEthernetTap::enabled() const |
||||
{ |
||||
return _enabled; |
||||
} |
||||
|
||||
bool MacKextEthernetTap::addIp(const InetAddress &ip) |
||||
{ |
||||
if (!ip) |
||||
return false; |
||||
|
||||
long cpid = (long)vfork(); |
||||
if (cpid == 0) { |
||||
char tmp[128]; |
||||
::execl("/sbin/ifconfig","/sbin/ifconfig",_dev.c_str(),(ip.ss_family == AF_INET6) ? "inet6" : "inet",ip.toString(tmp),"alias",(const char *)0); |
||||
::_exit(-1); |
||||
} else if (cpid > 0) { |
||||
int exitcode = -1; |
||||
::waitpid(cpid,&exitcode,0); |
||||
return (exitcode == 0); |
||||
} // else return false...
|
||||
|
||||
return false; |
||||
} |
||||
|
||||
bool MacKextEthernetTap::removeIp(const InetAddress &ip) |
||||
{ |
||||
if (!ip) |
||||
return true; |
||||
std::vector<InetAddress> allIps(ips()); |
||||
for(std::vector<InetAddress>::iterator i(allIps.begin());i!=allIps.end();++i) { |
||||
if (*i == ip) { |
||||
long cpid = (long)vfork(); |
||||
if (cpid == 0) { |
||||
char tmp[128]; |
||||
execl("/sbin/ifconfig","/sbin/ifconfig",_dev.c_str(),(ip.ss_family == AF_INET6) ? "inet6" : "inet",ip.toIpString(tmp),"-alias",(const char *)0); |
||||
_exit(-1); |
||||
} else if (cpid > 0) { |
||||
int exitcode = -1; |
||||
waitpid(cpid,&exitcode,0); |
||||
return (exitcode == 0); |
||||
} |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
std::vector<InetAddress> MacKextEthernetTap::ips() const |
||||
{ |
||||
struct ifaddrs *ifa = (struct ifaddrs *)0; |
||||
if (getifaddrs(&ifa)) |
||||
return std::vector<InetAddress>(); |
||||
|
||||
std::vector<InetAddress> r; |
||||
|
||||
struct ifaddrs *p = ifa; |
||||
while (p) { |
||||
if ((!strcmp(p->ifa_name,_dev.c_str()))&&(p->ifa_addr)&&(p->ifa_netmask)&&(p->ifa_addr->sa_family == p->ifa_netmask->sa_family)) { |
||||
switch(p->ifa_addr->sa_family) { |
||||
case AF_INET: { |
||||
struct sockaddr_in *sin = (struct sockaddr_in *)p->ifa_addr; |
||||
struct sockaddr_in *nm = (struct sockaddr_in *)p->ifa_netmask; |
||||
r.push_back(InetAddress(&(sin->sin_addr.s_addr),4,Utils::countBits((uint32_t)nm->sin_addr.s_addr))); |
||||
} break; |
||||
case AF_INET6: { |
||||
struct sockaddr_in6 *sin = (struct sockaddr_in6 *)p->ifa_addr; |
||||
struct sockaddr_in6 *nm = (struct sockaddr_in6 *)p->ifa_netmask; |
||||
uint32_t b[4]; |
||||
memcpy(b,nm->sin6_addr.s6_addr,sizeof(b)); |
||||
r.push_back(InetAddress(sin->sin6_addr.s6_addr,16,Utils::countBits(b[0]) + Utils::countBits(b[1]) + Utils::countBits(b[2]) + Utils::countBits(b[3]))); |
||||
} break; |
||||
} |
||||
} |
||||
p = p->ifa_next; |
||||
} |
||||
|
||||
if (ifa) |
||||
freeifaddrs(ifa); |
||||
|
||||
std::sort(r.begin(),r.end()); |
||||
r.erase(std::unique(r.begin(),r.end()),r.end()); |
||||
|
||||
return r; |
||||
} |
||||
|
||||
void MacKextEthernetTap::put(const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len) |
||||
{ |
||||
char putBuf[ZT_MAX_MTU + 64]; |
||||
if ((_fd > 0)&&(len <= _mtu)&&(_enabled)) { |
||||
to.copyTo(putBuf,6); |
||||
from.copyTo(putBuf + 6,6); |
||||
*((uint16_t *)(putBuf + 12)) = htons((uint16_t)etherType); |
||||
memcpy(putBuf + 14,data,len); |
||||
len += 14; |
||||
::write(_fd,putBuf,len); |
||||
} |
||||
} |
||||
|
||||
std::string MacKextEthernetTap::deviceName() const |
||||
{ |
||||
return _dev; |
||||
} |
||||
|
||||
void MacKextEthernetTap::setFriendlyName(const char *friendlyName) |
||||
{ |
||||
} |
||||
|
||||
void MacKextEthernetTap::scanMulticastGroups(std::vector<MulticastGroup> &added,std::vector<MulticastGroup> &removed) |
||||
{ |
||||
std::vector<MulticastGroup> newGroups; |
||||
|
||||
struct _intl_ifmaddrs *ifmap = (struct _intl_ifmaddrs *)0; |
||||
if (!_intl_getifmaddrs(&ifmap)) { |
||||
struct _intl_ifmaddrs *p = ifmap; |
||||
while (p) { |
||||
if (p->ifma_addr->sa_family == AF_LINK) { |
||||
struct sockaddr_dl *in = (struct sockaddr_dl *)p->ifma_name; |
||||
struct sockaddr_dl *la = (struct sockaddr_dl *)p->ifma_addr; |
||||
if ((la->sdl_alen == 6)&&(in->sdl_nlen <= _dev.length())&&(!memcmp(_dev.data(),in->sdl_data,in->sdl_nlen))) |
||||
newGroups.push_back(MulticastGroup(MAC(la->sdl_data + la->sdl_nlen,6),0)); |
||||
} |
||||
p = p->ifma_next; |
||||
} |
||||
_intl_freeifmaddrs(ifmap); |
||||
} |
||||
|
||||
std::vector<InetAddress> allIps(ips()); |
||||
for(std::vector<InetAddress>::iterator ip(allIps.begin());ip!=allIps.end();++ip) |
||||
newGroups.push_back(MulticastGroup::deriveMulticastGroupForAddressResolution(*ip)); |
||||
|
||||
std::sort(newGroups.begin(),newGroups.end()); |
||||
std::unique(newGroups.begin(),newGroups.end()); |
||||
|
||||
for(std::vector<MulticastGroup>::iterator m(newGroups.begin());m!=newGroups.end();++m) { |
||||
if (!std::binary_search(_multicastGroups.begin(),_multicastGroups.end(),*m)) |
||||
added.push_back(*m); |
||||
} |
||||
for(std::vector<MulticastGroup>::iterator m(_multicastGroups.begin());m!=_multicastGroups.end();++m) { |
||||
if (!std::binary_search(newGroups.begin(),newGroups.end(),*m)) |
||||
removed.push_back(*m); |
||||
} |
||||
|
||||
_multicastGroups.swap(newGroups); |
||||
} |
||||
|
||||
void MacKextEthernetTap::setMtu(unsigned int mtu) |
||||
{ |
||||
if (mtu != _mtu) { |
||||
_mtu = mtu; |
||||
long cpid = (long)vfork(); |
||||
if (cpid == 0) { |
||||
char tmp[64]; |
||||
OSUtils::ztsnprintf(tmp,sizeof(tmp),"%u",mtu); |
||||
execl("/sbin/ifconfig","/sbin/ifconfig",_dev.c_str(),"mtu",tmp,(const char *)0); |
||||
_exit(-1); |
||||
} else if (cpid > 0) { |
||||
int exitcode = -1; |
||||
waitpid(cpid,&exitcode,0); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void MacKextEthernetTap::threadMain() |
||||
throw() |
||||
{ |
||||
fd_set readfds,nullfds; |
||||
MAC to,from; |
||||
int n,nfds,r; |
||||
char getBuf[ZT_MAX_MTU + 64]; |
||||
|
||||
Thread::sleep(500); |
||||
|
||||
FD_ZERO(&readfds); |
||||
FD_ZERO(&nullfds); |
||||
nfds = (int)std::max(_shutdownSignalPipe[0],_fd) + 1; |
||||
|
||||
r = 0; |
||||
for(;;) { |
||||
FD_SET(_shutdownSignalPipe[0],&readfds); |
||||
FD_SET(_fd,&readfds); |
||||
select(nfds,&readfds,&nullfds,&nullfds,(struct timeval *)0); |
||||
|
||||
if (FD_ISSET(_shutdownSignalPipe[0],&readfds)) // writes to shutdown pipe terminate thread
|
||||
break; |
||||
|
||||
if (FD_ISSET(_fd,&readfds)) { |
||||
n = (int)::read(_fd,getBuf + r,sizeof(getBuf) - r); |
||||
if (n < 0) { |
||||
if ((errno != EINTR)&&(errno != ETIMEDOUT)) |
||||
break; |
||||
} else { |
||||
// Some tap drivers like to send the ethernet frame and the
|
||||
// payload in two chunks, so handle that by accumulating
|
||||
// data until we have at least a frame.
|
||||
r += n; |
||||
if (r > 14) { |
||||
if (r > ((int)_mtu + 14)) // sanity check for weird TAP behavior on some platforms
|
||||
r = _mtu + 14; |
||||
|
||||
if (_enabled) { |
||||
to.setTo(getBuf,6); |
||||
from.setTo(getBuf + 6,6); |
||||
unsigned int etherType = ntohs(((const uint16_t *)getBuf)[6]); |
||||
// TODO: VLAN support
|
||||
_handler(_arg,(void *)0,_nwid,from,to,etherType,0,(const void *)(getBuf + 14),r - 14); |
||||
} |
||||
|
||||
r = 0; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
} // namespace ZeroTier
|
||||
@ -0,0 +1,93 @@
|
||||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere |
||||
* Copyright (C) 2011-2018 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 <http://www.gnu.org/licenses/>.
|
||||
* |
||||
* -- |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#ifndef ZT_MacKextEthernetTap_HPP |
||||
#define ZT_MacKextEthernetTap_HPP |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
|
||||
#include <stdexcept> |
||||
#include <string> |
||||
#include <vector> |
||||
|
||||
#include "../node/Constants.hpp" |
||||
#include "../node/MAC.hpp" |
||||
#include "../node/InetAddress.hpp" |
||||
#include "../node/MulticastGroup.hpp" |
||||
|
||||
#include "Thread.hpp" |
||||
#include "EthernetTap.hpp" |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
class MacKextEthernetTap : public EthernetTap |
||||
{ |
||||
public: |
||||
MacKextEthernetTap( |
||||
const char *homePath, |
||||
const MAC &mac, |
||||
unsigned int mtu, |
||||
unsigned int metric, |
||||
uint64_t nwid, |
||||
const char *friendlyName, |
||||
void (*handler)(void *,void *,uint64_t,const MAC &,const MAC &,unsigned int,unsigned int,const void *,unsigned int), |
||||
void *arg); |
||||
|
||||
virtual ~MacKextEthernetTap(); |
||||
|
||||
virtual void setEnabled(bool en); |
||||
virtual bool enabled() const; |
||||
virtual bool addIp(const InetAddress &ip); |
||||
virtual bool removeIp(const InetAddress &ip); |
||||
virtual std::vector<InetAddress> ips() const; |
||||
virtual void put(const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len); |
||||
virtual std::string deviceName() const; |
||||
virtual void setFriendlyName(const char *friendlyName); |
||||
virtual void scanMulticastGroups(std::vector<MulticastGroup> &added,std::vector<MulticastGroup> &removed); |
||||
virtual void setMtu(unsigned int mtu); |
||||
|
||||
void threadMain() |
||||
throw(); |
||||
|
||||
private: |
||||
void (*_handler)(void *,void *,uint64_t,const MAC &,const MAC &,unsigned int,unsigned int,const void *,unsigned int); |
||||
void *_arg; |
||||
uint64_t _nwid; |
||||
Thread _thread; |
||||
std::string _homePath; |
||||
std::string _dev; |
||||
std::vector<MulticastGroup> _multicastGroups; |
||||
unsigned int _mtu; |
||||
unsigned int _metric; |
||||
int _fd; |
||||
int _shutdownSignalPipe[2]; |
||||
volatile bool _enabled; |
||||
}; |
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif |
||||
@ -1,161 +0,0 @@
|
||||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere |
||||
* Copyright (C) 2011-2019 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 <http://www.gnu.org/licenses/>.
|
||||
* |
||||
* -- |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#ifndef ZT_TESTETHERNETTAP_HPP |
||||
#define ZT_TESTETHERNETTAP_HPP |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <stdint.h> |
||||
#include <sys/types.h> |
||||
#include <sys/socket.h> |
||||
|
||||
#include <string> |
||||
#include <vector> |
||||
#include <stdexcept> |
||||
#include <set> |
||||
|
||||
#include "../node/Constants.hpp" |
||||
#include "../node/InetAddress.hpp" |
||||
#include "../node/MulticastGroup.hpp" |
||||
#include "../node/Mutex.hpp" |
||||
#include "../node/Utils.hpp" |
||||
#include "../osdep/OSUtils.hpp" |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
/**
|
||||
* Dummy test Ethernet tap that does not actually open a device on the system |
||||
*/ |
||||
class TestEthernetTap |
||||
{ |
||||
public: |
||||
TestEthernetTap( |
||||
const char *homePath, |
||||
const MAC &mac, |
||||
unsigned int mtu, |
||||
unsigned int metric, |
||||
uint64_t nwid, |
||||
const char *friendlyName, |
||||
void (*handler)(void *,void *,uint64_t,const MAC &,const MAC &,unsigned int,unsigned int,const void *,unsigned int), |
||||
void *arg) : |
||||
_nwid(nwid), |
||||
_dev("zt_test_"), |
||||
_enabled(true) |
||||
{ |
||||
char tmp[32]; |
||||
OSUtils::ztsnprintf(tmp,sizeof(tmp),"%.16llx",(unsigned long long)_nwid); |
||||
_dev.append(tmp); |
||||
#ifdef ZT_TEST_TAP_REPORT_TO |
||||
_reportTo.fromString(ZT_TEST_TAP_REPORT_TO); |
||||
if (_reportTo.ss_family == AF_INET) |
||||
_reportsock = socket(AF_INET,SOCK_DGRAM,0); |
||||
else if (_reportTo.ss_family == AF_INET6) |
||||
_reportsock = socket(AF_INET6,SOCK_DGRAM,0); |
||||
else _reportsock = -1; |
||||
#endif |
||||
} |
||||
|
||||
~TestEthernetTap() |
||||
{ |
||||
#ifdef ZT_TEST_TAP_REPORT_TO |
||||
if (_reportsock >= 0) |
||||
close(_reportsock); |
||||
#endif |
||||
} |
||||
|
||||
inline void setEnabled(bool en) { _enabled = en; } |
||||
inline bool enabled() const { return _enabled; } |
||||
|
||||
inline bool addIp(const InetAddress &ip) |
||||
{ |
||||
Mutex::Lock _l(_lock); |
||||
_ips.insert(ip); |
||||
return true; |
||||
} |
||||
|
||||
inline bool removeIp(const InetAddress &ip) |
||||
{ |
||||
Mutex::Lock _l(_lock); |
||||
_ips.erase(ip); |
||||
return true; |
||||
} |
||||
|
||||
inline std::vector<InetAddress> ips() const |
||||
{ |
||||
Mutex::Lock _l(_lock); |
||||
return std::vector<InetAddress>(_ips.begin(),_ips.end()); |
||||
} |
||||
|
||||
inline void put(const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len) |
||||
{ |
||||
#ifdef ZT_TEST_TAP_REPORT_TO |
||||
char tmp[10000]; |
||||
if ((_reportsock >= 0)&&(len < (sizeof(tmp) - 22))) { |
||||
const uint64_t nwid2 = Utils::hton(_nwid); |
||||
memcpy(tmp,&nwid2,8); |
||||
from.copyTo(tmp + 8,6); |
||||
to.copyTo(tmp + 14,6); |
||||
const uint16_t etherType2 = Utils::hton((uint16_t)etherType); |
||||
memcpy(tmp + 20,ðerType2,2); |
||||
memcpy(tmp + 22,data,len); |
||||
sendto(_reportsock,tmp,len + 22,0,reinterpret_cast<const struct sockaddr *>(&_reportTo),(_reportTo.ss_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6)); |
||||
} |
||||
#endif |
||||
} |
||||
|
||||
inline std::string deviceName() const |
||||
{ |
||||
return _dev; |
||||
} |
||||
|
||||
inline void setFriendlyName(const char *friendlyName) |
||||
{ |
||||
} |
||||
|
||||
inline void scanMulticastGroups(std::vector<MulticastGroup> &added,std::vector<MulticastGroup> &removed) |
||||
{ |
||||
} |
||||
|
||||
inline void setMtu(unsigned int mtu) |
||||
{ |
||||
} |
||||
|
||||
private: |
||||
uint64_t _nwid; |
||||
std::string _dev; |
||||
std::set<InetAddress> _ips; |
||||
InetAddress _reportTo; |
||||
#ifdef ZT_TEST_TAP_REPORT_TO |
||||
int _reportsock; |
||||
#endif |
||||
bool _enabled; |
||||
Mutex _lock; |
||||
}; |
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif |
||||
@ -0,0 +1,9 @@
|
||||
DEL "ZeroTier One.msi" |
||||
DEL zt1_update*.exe |
||||
RMDIR /Q /S windows\Build |
||||
RMDIR /Q /S windows\copyutil\bin |
||||
RMDIR /Q /S windows\copyutil\obj |
||||
RMDIR /Q /S windows\WinUI\bin |
||||
RMDIR /Q /S windows\WinUI\obj |
||||
RMDIR /Q /S windows\ZeroTierOne\Release |
||||
RMDIR /Q /S windows\ZeroTierOne\x64 |
||||
Loading…
Reference in new issue