ExternalVendorCode/ZeroTierOne
1
0
Fork 0
mirror of https://github.com/zerotier/ZeroTierOne.git synced 2025-01-18 02:40:13 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

New service, work in progress

Browse Source
This commit is contained in:
Adam Ierymenko 2019-09-20 09:09:05 -07:00
parent 3ceb2257e5
commit ae2120eb96
No known key found for this signature in database
GPG Key ID: C8877CF2D7A5D7F3
15 changed files with 852 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -141,7 +141,7 @@ endif()
add_subdirectory(node)
add_subdirectory(controller)
add_subdirectory(osdep)
add_subdirectory(service)
#add_subdirectory(service)
add_subdirectory(root)
if(WIN32)
@ -151,7 +151,7 @@ if(WIN32)
endif(WIN32)
set(libs
zt_service
# zt_service
zt_osdep
zt_core
zt_controller

30
attic/listaddrinfo.go Normal file
View File

@ -0,0 +1,30 @@
package main
import (
"fmt"
"net"
)
func main() {
ifs, err := net.Interfaces()
if err != nil {
fmt.Printf("Error: %s\n", err.Error())
return
}
for _, i := range ifs {
fmt.Printf("name: %s\n", i.Name)
fmt.Printf("hwaddr: %s\n", i.HardwareAddr.String())
fmt.Printf("index: %d\n", i.Index)
fmt.Printf("addrs:\n")
addrs, _ := i.Addrs()
for _, a := range addrs {
fmt.Printf(" %s\n", a.String())
}
fmt.Printf("multicast:\n")
mc, _ := i.MulticastAddrs()
for _, m := range mc {
fmt.Printf(" %s\n", m.String())
}
fmt.Printf("\n")
}
}

0
service/CMakeLists.txt → attic/service/CMakeLists.txt
View File

0
service/OneService.cpp → attic/service/OneService.cpp
View File

0
service/OneService.hpp → attic/service/OneService.hpp
View File

0
service/README.md → attic/service/README.md
View File

3
go/go.mod Normal file
View File

@ -0,0 +1,3 @@
module zerotier-go
go 1.13

13
go/native/CMakeLists.txt Normal file
View File

@ -0,0 +1,13 @@
cmake_minimum_required(VERSION 2.8)
project(zt_go_native)
set(src
GoNode.cpp
)
set(headers
GoNode.h
)
add_library(${PROJECT_NAME} STATIC ${src} ${headers})
target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_11)

493
go/native/GoNode.cpp Normal file
View File

@ -0,0 +1,493 @@
/*
* Copyright (c)2019 ZeroTier, Inc.
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file in the project's root directory.
*
* Change Date: 2023-01-01
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by vergnn 2.0 of the Apache License.
*/
/****/
#include "GoNode.h"
#include "../../node/Constants.hpp"
#include "../../node/InetAddress.hpp"
#include "../../node/Node.hpp"
#include "../../node/Utils.hpp"
#include "../../osdep/OSUtils.hpp"
#include "../../osdep/BlockingQueue.hpp"
#include "../../osdep/EthernetTap.hpp"
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#ifndef __WINDOWS__
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip6.h>
#include <netinet/tcp.h>
#ifdef __BSD__
#include <net/if.h>
#endif
#ifdef __LINUX__
#ifndef IPV6_DONTFRAG
#define IPV6_DONTFRAG 62
#endif
#endif
#endif // !__WINDOWS__
#include <thread>
#include <mutex>
#include <map>
#include <vector>
#include <array>
#include <set>
#ifdef __WINDOWS__
#define SETSOCKOPT_FLAG_TYPE BOOL
#define SETSOCKOPT_FLAG_TRUE TRUE
#define SETSOCKOPT_FLAG_FALSE FALSE
#else
#define SETSOCKOPT_FLAG_TYPE int
#define SETSOCKOPT_FLAG_TRUE 1
#define SETSOCKOPT_FLAG_FALSE 0
#endif
#ifndef MSG_DONTWAIT
#define MSG_DONTWAIT 0
#endif
using namespace ZeroTier;
struct ZT_GoNodeThread
{
std::string ip;
int port;
int af;
std::atomic_bool run;
std::thread thr;
};
struct ZT_GoNode_Impl
{
Node *node;
volatile int64_t nextBackgroundTaskDeadline;
int (*goPathCheckFunc)(ZT_GoNode *,ZT_Node *,uint64_t ztAddress,const void *);
int (*goPathLookupFunc)(ZT_GoNode *,ZT_Node *,int desiredAddressFamily,void *);
int (*goStateObjectGetFunc)(ZT_GoNode *,ZT_Node *,int objType,const uint64_t id[2],void *buf,unsigned int bufSize);
std::map< ZT_SOCKET,ZT_GoNodeThread > threads;
std::mutex threads_l;
BlockingQueue<ZT_GoNodeEvent> eq;
};
//////////////////////////////////////////////////////////////////////////////
static int ZT_GoNode_VirtualNetworkConfigFunction(
ZT_Node *node,
void *uptr,
void *tptr,
uint64_t nwid,
void **nptr,
enum ZT_VirtualNetworkConfigOperation op,
const ZT_VirtualNetworkConfig *cfg)
{
ZT_GoNodeEvent ev;
ev.type = ZT_GONODE_EVENT_NETWORK_CONFIG_UPDATE;
ev.data.nconf.op = op;
if (cfg)
ev.data.nconf.conf = *cfg;
reinterpret_cast<ZT_GoNode *>(uptr)->eq.post(ev);
}
static void ZT_GoNode_VirtualNetworkFrameFunction(
ZT_Node *node,
void *uptr,
void *tptr,
uint64_t nwid,
void **nptr,
uint64_t srcMac,
uint64_t destMac,
unsigned int etherType,
unsigned int vlanId,
const void *data,
unsigned int len)
{
if (*nptr)
reinterpret_cast<EthernetTap *>(*nptr)->put(MAC(srcMac),MAC(destMac),etherType,data,len);
}
static void ZT_GoNode_EventCallback(
ZT_Node *node,
void *uptr,
void *tptr,
enum ZT_Event et,
const void *data)
{
ZT_GoNodeEvent ev;
ev.type = ZT_GONODE_EVENT_ZTEVENT;
ev.data.zt.type = et;
reinterpret_cast<ZT_GoNode *>(uptr)->eq.post(ev);
}
static void ZT_GoNode_StatePutFunction(
ZT_Node *node,
void *uptr,
void *tptr,
enum ZT_StateObjectType objType,
const uint64_t id[2],
const void *data,
int len)
{
if (len < ZT_MAX_STATE_OBJECT_SIZE) { // sanity check
ZT_GoNodeEvent ev;
ev.type = (len >= 0) ? ZT_GONODE_EVENT_STATE_PUT : ZT_GONODE_EVENT_STATE_DELETE;
if (len > 0) {
memcpy(ev.data.sobj.data,data,len);
ev.data.sobj.len = (unsigned int)len;
}
ev.data.sobj.objType = objType;
ev.data.sobj.id[0] = id[0];
ev.data.sobj.id[1] = id[1];
reinterpret_cast<ZT_GoNode *>(uptr)->eq.post(ev);
}
}
static int ZT_GoNode_StateGetFunction(
ZT_Node *node,
void *uptr,
void *tptr,
enum ZT_StateObjectType objType,
const uint64_t id[2],
void *buf,
unsigned int buflen)
{
return reinterpret_cast<ZT_GoNode *>(uptr)->goStateObjectGetFunc(reinterpret_cast<ZT_GoNode *>(uptr),reinterpret_cast<ZT_GoNode *>(uptr)->node,(int)objType,id,buf,buflen);
}
static ZT_ALWAYS_INLINE void doUdpSend(ZT_SOCKET sock,const struct sockaddr_storage *addr,const void *data,const unsigned int len,const unsigned int ipTTL)
{
switch(addr->ss_family) {
case AF_INET:
if ((ipTTL > 0)&&(ipTTL < 255)) {
#ifdef __WINDOWS__
DWORD tmp = (DWORD)ipTTL;
#else
int tmp = (int)ipTTL;
#endif
setsockopt(sock,IPPROTO_IP,IP_TTL,&tmp,sizeof(tmp));
sendto(sock,data,len,MSG_DONTWAIT,(const sockaddr *)addr,sizeof(struct sockaddr_in));
tmp = 255;
setsockopt(sock,IPPROTO_IP,IP_TTL,&tmp,sizeof(tmp));
} else {
sendto(sock,data,len,MSG_DONTWAIT,(const sockaddr *)addr,sizeof(struct sockaddr_in));
}
break;
case AF_INET6:
// The ipTTL option isn't currently used with IPv6. It's only used
// with IPv4 "firewall opener" / "NAT buster" preamble packets as part
// of IPv4 NAT traversal.
sendto(sock,data,len,MSG_DONTWAIT,(const sockaddr *)addr,sizeof(struct sockaddr_in6));
break;
}
}
static void ZT_GoNode_WirePacketSendFunction(
ZT_Node *node,
void *uptr,
void *tptr,
int64_t localSocket,
const struct sockaddr_storage *addr,
const void *data,
unsigned int len,
unsigned int ipTTL)
{
if ((localSocket != -1)&&(localSocket != ZT_INVALID_SOCKET)) {
doUdpSend((ZT_SOCKET)localSocket,addr,data,len,ipTTL);
} else {
ZT_GoNode *const gn = reinterpret_cast<ZT_GoNode *>(uptr);
std::set<std::string> ipsSentFrom;
std::lock_guard<std::mutex> l(gn->threads_l);
for(auto t=gn->threads.begin();t!=gn->threads.end();++t) {
if (t->second.af == addr->ss_family) {
if (ipsSentFrom.insert(t->second.ip).second) {
doUdpSend(t->first,addr,data,len,ipTTL);
}
}
}
}
}
static int ZT_GoNode_PathCheckFunction(
ZT_Node *node,
void *uptr,
void *tptr,
uint64_t ztAddress,
int64_t localSocket,
const struct sockaddr_storage *sa)
{
return reinterpret_cast<ZT_GoNode *>(uptr)->goPathCheckFunc(reinterpret_cast<ZT_GoNode *>(uptr),reinterpret_cast<ZT_GoNode *>(uptr)->node,ztAddress,sa);
}
static int ZT_GoNode_PathLookupFunction(
ZT_Node *node,
void *uptr,
void *tptr,
uint64_t ztAddress,
int desiredAddressFamily,
struct sockaddr_storage *sa)
{
return reinterpret_cast<ZT_GoNode *>(uptr)->goPathLookupFunc(reinterpret_cast<ZT_GoNode *>(uptr),reinterpret_cast<ZT_GoNode *>(uptr)->node,desiredAddressFamily,sa);
}
static void ZT_GoNode_DNSResolver(
ZT_Node *node,
void *uptr,
void *tptr,
const enum ZT_DNSRecordType *types,
unsigned int numTypes,
const char *name,
uintptr_t requestId)
{
ZT_GoNodeEvent ev;
ev.type = ZT_GONODE_EVENT_DNS_GET_TXT;
Utils::scopy(ev.data.dns.dnsName,sizeof(ev.data.dns.dnsName),name);
reinterpret_cast<ZT_GoNode *>(uptr)->eq.post(ev);
}
//////////////////////////////////////////////////////////////////////////////
extern "C" ZT_GoNode *ZT_GoNode_new(
int (*goPathCheckFunc)(ZT_GoNode *,ZT_Node *,uint64_t ztAddress,const void *),
int (*goPathLookupFunc)(ZT_GoNode *,ZT_Node *,int desiredAddressFamily,void *),
int (*goStateObjectGetFunc)(ZT_GoNode *,ZT_Node *,int objType,const uint64_t id[2],void *buf,unsigned int bufSize)
)
{
try {
struct ZT_Node_Callbacks cb;
cb.virtualNetworkConfigFunction = &ZT_GoNode_VirtualNetworkConfigFunction;
cb.virtualNetworkFrameFunction = &ZT_GoNode_VirtualNetworkFrameFunction;
cb.eventCallback = &ZT_GoNode_EventCallback;
cb.statePutFunction = &ZT_GoNode_StatePutFunction;
cb.stateGetFunction = &ZT_GoNode_StateGetFunction;
cb.pathCheckFunction = &ZT_GoNode_PathCheckFunction;
cb.pathLookupFunction = &ZT_GoNode_PathLookupFunction;
cb.dnsResolver = &ZT_GoNode_DNSResolver;
ZT_GoNode_Impl *gn = new ZT_GoNode_Impl;
const int64_t now = OSUtils::now();
gn->node = new Node(reinterpret_cast<void *>(gn),nullptr,&cb,now);
gn->nextBackgroundTaskDeadline = now;
gn->goPathCheckFunc = goPathCheckFunc;
gn->goPathLookupFunc = goPathLookupFunc;
gn->goStateObjectGetFunc = goStateObjectGetFunc;
return gn;
} catch ( ... ) {
fprintf(stderr,"FATAL: unable to create new instance of Node (out of memory?)" ZT_EOL_S);
exit(1);
}
}
extern "C" void ZT_GoNode_delete(ZT_GoNode *gn)
{
ZT_GoNodeEvent sd;
sd.type = ZT_GONODE_EVENT_SHUTDOWN;
gn->eq.post(sd);
std::vector<std::thread> th;
gn->threads_l.lock();
for(auto t=gn->threads.begin();t!=gn->threads.end();++t) {
t->second.run = false;
shutdown(t->first,SHUT_RDWR);
close(t->first);
th.emplace_back(t->second.thr);
}
gn->threads_l.unlock();
for(auto t=th.begin();t!=th.end();++t)
t->join();
delete gn->node;
delete gn;
}
extern "C" ZT_Node *ZT_GoNode_getNode(ZT_GoNode *gn)
{
return gn->node;
}
// Sets flags and socket options common to both IPv4 and IPv6 UDP sockets
static void setCommonUdpSocketSettings(ZT_SOCKET udpSock,const char *dev)
{
int bufSize = 1048576;
while (bufSize > 131072) {
if (setsockopt(udpSock,SOL_SOCKET,SO_RCVBUF,(const char *)&bufSize,sizeof(bufSize)) == 0)
break;
bufSize -= 131072;
}
bufSize = 1048576;
while (bufSize > 131072) {
if (setsockopt(udpSock,SOL_SOCKET,SO_SNDBUF,(const char *)&bufSize,sizeof(bufSize)) == 0)
break;
bufSize -= 131072;
}
SETSOCKOPT_FLAG_TYPE fl;
#ifdef SO_REUSEPORT
fl = SETSOCKOPT_FLAG_TRUE;
setsockopt(udpSock,SOL_SOCKET,SO_REUSEPORT,(void *)&fl,sizeof(fl));
#endif
#ifndef __LINUX__ // linux wants just SO_REUSEPORT
fl = SETSOCKOPT_FLAG_TRUE;
setsockopt(udpSock,SOL_SOCKET,SO_REUSEADDR,(void *)&fl,sizeof(fl));
#endif
fl = SETSOCKOPT_FLAG_TRUE;
setsockopt(udpSock,SOL_SOCKET,SO_BROADCAST,(void *)&fl,sizeof(fl));
#ifdef IP_DONTFRAG
fl = SETSOCKOPT_FLAG_FALSE;
setsockopt(udpSock,IPPROTO_IP,IP_DONTFRAG,(void *)&fl,sizeof(fl));
#endif
#ifdef IP_MTU_DISCOVER
fl = SETSOCKOPT_FLAG_FALSE;
setsockopt(udpSock,IPPROTO_IP,IP_MTU_DISCOVER,(void *)&fl,sizeof(fl));
#endif
#ifdef SO_BINDTODEVICE
if ((dev)&&(strlen(dev)))
setsockopt(udpSock,SOL_SOCKET,SO_BINDTODEVICE,dev,strlen(dev));
#endif
#if defined(__BSD__) && defined(IP_BOUND_IF)
if ((dev)&&(strlen(dev))) {
int idx = if_nametoindex(dev);
if (idx != 0)
setsockopt(udpSock,IPPROTO_IP,IP_BOUND_IF,(void *)&idx,sizeof(idx));
}
#endif
}
extern "C" int ZT_GoNode_phyStartListen(ZT_GoNode *gn,const char *dev,const char *ip,const int port)
{
if (strchr(ip,':')) {
struct sockaddr_in6 in6;
memset(&in6,0,sizeof(in6));
in6.sin6_family = AF_INET6;
if (inet_pton(AF_INET6,ip,&(in6.sin6_addr)) <= 0)
return errno;
in6.sin6_port = htons((uint16_t)port);
ZT_SOCKET udpSock = socket(AF_INET6,SOCK_DGRAM,0);
if (udpSock == ZT_INVALID_SOCKET)
return errno;
setCommonUdpSocketSettings(udpSock,dev);
SETSOCKOPT_FLAG_TYPE fl = SETSOCKOPT_FLAG_TRUE;
setsockopt(udpSock,IPPROTO_IPV6,IPV6_V6ONLY,(const char *)&fl,sizeof(fl));
#ifdef IPV6_DONTFRAG
fl = SETSOCKOPT_FLAG_FALSE;
setsockopt(udpSock,IPPROTO_IPV6,IPV6_DONTFRAG,&fl,sizeof(fl));
#endif
if (bind(udpSock,reinterpret_cast<const struct sockaddr *>(&in6),sizeof(in6)) != 0)
return errno;
{
std::lock_guard<std::mutex> l(gn->threads_l);
ZT_GoNodeThread &gnt = gn->threads[udpSock];
gnt.ip = ip;
gnt.port = port;
gnt.af = AF_INET6;
gnt.run = true;
gnt.thr = std::thread([udpSock,gn,&gnt] {
struct sockaddr_in6 in6;
socklen_t salen;
char buf[16384];
while (gnt.run) {
salen = sizeof(in6);
int s = (int)recvfrom(udpSock,buf,sizeof(buf),0,reinterpret_cast<struct sockaddr *>(&in6),&salen);
if (s > 0) {
gn->node->processWirePacket(&gnt,OSUtils::now(),(int64_t)udpSock,reinterpret_cast<const struct sockaddr_storage *>(&in6),buf,(unsigned int)s,&(gn->nextBackgroundTaskDeadline));
}
}
});
}
} else {
struct sockaddr_in in;
memset(&in,0,sizeof(in));
in.sin_family = AF_INET;
if (inet_pton(AF_INET,ip,&(in.sin_addr)) <= 0)
return errno;
in.sin_port = htons((uint16_t)port);
ZT_SOCKET udpSock = socket(AF_INET,SOCK_DGRAM,0);
if (udpSock == ZT_INVALID_SOCKET)
return errno;
setCommonUdpSocketSettings(udpSock,dev);
#ifdef SO_NO_CHECK
SETSOCKOPT_FLAG_TYPE fl = SETSOCKOPT_FLAG_TRUE;
setsockopt(udpSock,SOL_SOCKET,SO_NO_CHECK,&fl,sizeof(fl));
#endif
if (bind(udpSock,reinterpret_cast<const struct sockaddr *>(&in),sizeof(in)) != 0)
return errno;
{
std::lock_guard<std::mutex> l(gn->threads_l);
ZT_GoNodeThread &gnt = gn->threads[udpSock];
gnt.ip = ip;
gnt.port = port;
gnt.af = AF_INET6;
gnt.run = true;
gnt.thr = std::thread([udpSock,gn,&gnt] {
struct sockaddr_in in4;
socklen_t salen;
char buf[16384];
while (gnt.run) {
salen = sizeof(in4);
int s = (int)recvfrom(udpSock,buf,sizeof(buf),0,reinterpret_cast<struct sockaddr *>(&in4),&salen);
if (s > 0) {
gn->node->processWirePacket(&gnt,OSUtils::now(),(int64_t)udpSock,reinterpret_cast<const struct sockaddr_storage *>(&in4),buf,(unsigned int)s,&(gn->nextBackgroundTaskDeadline));
}
}
});
}
}
return 0;
}
extern "C" int ZT_GoNode_phyStopListen(ZT_GoNode *gn,const char *dev,const char *ip,const int port)
{
{
std::lock_guard<std::mutex> l(gn->threads_l);
for(auto t=gn->threads.begin();t!=gn->threads.end();) {
if ((t->second.ip == ip)&&(t->second.port == port)) {
t->second.run = false;
shutdown(t->first,SHUT_RDWR);
close(t->first);
t->second.thr.join();
gn->threads.erase(t++);
} else ++t;
}
}
}
extern "C" int ZT_GoNode_waitForEvent(ZT_GoNode *gn,ZT_GoNodeEvent *ev)
{
gn->eq.get(*ev);
}

100
go/native/GoNode.h Normal file
View File

@ -0,0 +1,100 @@
/*
* Copyright (c)2019 ZeroTier, Inc.
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file in the project's root directory.
*
* Change Date: 2023-01-01
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by vergnn 2.0 of the Apache License.
*/
/****/
#ifndef ZT_GONODE_H
#define ZT_GONODE_H
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "../../include/ZeroTierCore.h"
struct ZT_GoNode_Impl;
typedef struct ZT_GoNode_Impl ZT_GoNode;
#define ZT_GONODE_EVENT_SHUTDOWN 0
#define ZT_GONODE_EVENT_ZTEVENT 1
#define ZT_GONODE_EVENT_DNS_GET_TXT 2
#define ZT_GONODE_EVENT_STATE_PUT 3
#define ZT_GONODE_EVENT_STATE_DELETE 4
#define ZT_GONODE_EVENT_NETWORK_CONFIG_UPDATE 5
/**
* Variant type for async core generated events pulled via waitForEvent
*/
struct ZT_GoNodeEvent_Impl
{
#ifdef __cplusplus
inline ZT_GoNodeEvent_Impl() { memset(reinterpret_cast<void *>(this),0,sizeof(ZT_GoNodeEvent_Impl)); }
inline ZT_GoNodeEvent_Impl(const ZT_GoNodeEvent &ev) { memcpy(reinterpret_cast<void *>(this),reinterpret_cast<const void *>(&ev),sizeof(ZT_GoNodeEvent_Impl)); }
inline ZT_GoNodeEvent_Impl &operator=(const ZT_GoNodeEvent_Impl &ev) { memcpy(reinterpret_cast<void *>(this),reinterpret_cast<const void *>(&ev),sizeof(ZT_GoNodeEvent_Impl)); return *this; }
#endif
int type;
union {
/* ZeroTier event of ZT_Event type */
struct {
int type;
} zt;
/* DNS resolution request */
struct {
uintptr_t requestId;
char dnsName[256];
} dns;
/* State object put or delete request */
struct {
uint8_t data[ZT_MAX_STATE_OBJECT_SIZE];
unsigned int len;
int objType;
uint64_t id[2];
} sobj;
/* Network configuration update event */
struct {
int op; /* ZT_VirtualNetworkConfigOperation */
ZT_VirtualNetworkConfig conf;
} nconf;
} data;
};
typedef struct ZT_GoNodeEvent_Impl ZT_GoNodeEvent;
#ifndef __cplusplus
extern "C" {
#endif
ZT_GoNode *ZT_GoNode_new(
int (*goPathCheckFunc)(ZT_GoNode *,ZT_Node *,uint64_t ztAddress,const void *),
int (*goPathLookupFunc)(ZT_GoNode *,ZT_Node *,int desiredAddressFamily,void *),
int (*goStateObjectGetFunc)(ZT_GoNode *,ZT_Node *,int objType,const uint64_t id[2],void *buf,unsigned int bufSize)
);
void ZT_GoNode_delete(ZT_GoNode *gn);
ZT_Node *ZT_GoNode_getNode(ZT_GoNode *gn);
int ZT_GoNode_phyStartListen(ZT_GoNode *gn,const char *dev,const char *ip,const int port);
int ZT_GoNode_phyStopListen(ZT_GoNode *gn,const char *dev,const char *ip,const int port);
int ZT_GoNode_waitForEvent(ZT_GoNode *gn,ZT_GoNodeEvent *ev);
#ifndef __cplusplus
}
#endif
#endif

122
go/pkg/ztnode/errors.go Normal file
View File

@ -0,0 +1,122 @@
/*
* Copyright (c)2019 ZeroTier, Inc.
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file in the project's root directory.
*
* Change Date: 2023-01-01
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by version 2.0 of the Apache License.
*/
/****/
package ztnode
/*
// errTypeName returns the type name of an error minus any leading * character.
func errTypeName(err error) string {
if err == nil {
return ""
}
et := reflect.TypeOf(err)
if et.Kind() == reflect.Ptr {
return et.Elem().Name()
}
return et.Name()
}
//////////////////////////////////////////////////////////////////////////////
// Err indicates a general LF error such as an invalid parameter or state.
type Err string
func (e Err) Error() string { return (string)(e) }
// General errors
const (
ErrInvalidPublicKey Err = "invalid public key"
ErrInvalidPrivateKey Err = "invalid private key"
ErrInvalidParameter Err = "invalid parameter"
ErrInvalidObject Err = "invalid object"
ErrUnsupportedType Err = "unsupported type"
ErrUnsupportedCurve Err = "unsupported ECC curve (for this purpose)"
ErrOutOfRange Err = "parameter out of range"
ErrWharrgarblFailed Err = "Wharrgarbl proof of work algorithm failed (out of memory?)"
ErrIO Err = "I/O error"
ErrIncorrectKey Err = "incorrect key"
ErrAlreadyConnected Err = "already connected"
ErrRecordNotFound Err = "record not found"
ErrRecordIsNewer Err = "record is newer than timestamp"
ErrPulseSpanExeceeded Err = "pulse is more than one year after record"
ErrDuplicateRecord Err = "duplicate record"
ErrPrivateKeyRequired Err = "private key required"
ErrInvalidMessageSize Err = "message size invalid"
ErrQueryRequiresSelectors Err = "query requires at least one selector"
ErrQueryInvalidSortOrder Err = "invalid sort order value"
ErrAlreadyMounted Err = "mount point already mounted"
)
//////////////////////////////////////////////////////////////////////////////
// ErrRecord indicates an error related to an invalid record or a record failing a check.
type ErrRecord string
func (e ErrRecord) Error() string { return (string)(e) }
// Errs indicating that a record is invalid
const (
ErrRecordInvalid ErrRecord = "record invalid"
ErrRecordOwnerSignatureCheckFailed ErrRecord = "owner signature check failed"
ErrRecordInsufficientWork ErrRecord = "insufficient work to pay for this record"
ErrRecordNotApproved ErrRecord = "record not currently approved (via proof of work and/or certificates)"
ErrRecordInsufficientLinks ErrRecord = "insufficient links"
ErrRecordTooManyLinks ErrRecord = "too many links"
ErrRecordInvalidLinks ErrRecord = "links must be sorted and unique"
ErrRecordTooManySelectors ErrRecord = "too many selectors"
ErrRecordUnsupportedAlgorithm ErrRecord = "unsupported algorithm or type"
ErrRecordTooLarge ErrRecord = "record too large"
ErrRecordValueTooLarge ErrRecord = "record value too large"
ErrRecordViolatesSpecialRelativity ErrRecord = "record timestamp too far in the future"
ErrRecordTooOld ErrRecord = "record older than network timestamp floor"
ErrRecordCertificateInvalid ErrRecord = "certificate invalid"
ErrRecordCertificateRequired ErrRecord = "certificate required"
ErrRecordProhibited ErrRecord = "record administratively prohibited"
)
//////////////////////////////////////////////////////////////////////////////
// ErrDatabase contains information about a database related problem.
type ErrDatabase struct {
// ErrCode is the error code returned by the C database module.
ErrCode int
// ErrMessage is an error message supplied by the C code or by Go (optional)
ErrMessage string
}
func (e ErrDatabase) Error() string {
return fmt.Sprintf("database error: %d (%s)", e.ErrCode, e.ErrMessage)
}
//////////////////////////////////////////////////////////////////////////////
// ErrAPI (response) indicates an error and is returned with non-200 responses.
type ErrAPI struct {
Code int `` // HTTP response code
Message string `json:",omitempty"` // Message indicating the reason for the error
ErrTypeName string `json:",omitempty"` // Name of LF native error or empty if HTTP or transport error
}
// Error implements the error interface, making APIError an 'error' in the Go sense.
func (e ErrAPI) Error() string {
if len(e.ErrTypeName) > 0 {
return fmt.Sprintf("%d:%s:%s", e.Code, e.ErrTypeName, e.Message)
}
return fmt.Sprintf("%d:%s", e.Code, e.Message)
}
//////////////////////////////////////////////////////////////////////////////
*/

19
go/pkg/ztnode/misc.go Normal file
View File

@ -0,0 +1,19 @@
/*
* Copyright (c)2019 ZeroTier, Inc.
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file in the project's root directory.
*
* Change Date: 2023-01-01
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by version 2.0 of the Apache License.
*/
/****/
package ztnode
import "time"
// TimeMs returns the time in milliseconds since epoch.
func TimeMs() int64 { return int64(time.Now().UnixNano()) / int64(1000000) }

48
go/pkg/ztnode/node.go Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (c)2019 ZeroTier, Inc.
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file in the project's root directory.
*
* Change Date: 2023-01-01
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by version 2.0 of the Apache License.
*/
/****/
package ztnode
//#cgo CFLAGS: -O3
//#cgo LDFLAGS: ${SRCDIR}/../../../build/node/libzt_core.a -lc++
//#define ZT_CGO 1
//#include <stdint.h>
//#include "../../../include/ZeroTierCore.h"
//#if __has_include("../../../version.h")
//#include "../../../version.h"
//#else
//#define ZEROTIER_ONE_VERSION_MAJOR 255
//#define ZEROTIER_ONE_VERSION_MINOR 255
//#define ZEROTIER_ONE_VERSION_REVISION 255
//#define ZEROTIER_ONE_VERSION_BUILD 255
//#endif
import "C"
const (
// CoreVersionMajor is the major version of the ZeroTier core
CoreVersionMajor int = C.ZEROTIER_ONE_VERSION_MAJOR
// CoreVersionMinor is the minor version of the ZeroTier core
CoreVersionMinor int = C.ZEROTIER_ONE_VERSION_MINOR
// CoreVersionRevision is the revision of the ZeroTier core
CoreVersionRevision int = C.ZEROTIER_ONE_VERSION_REVISION
// CoreVersionBuild is the build version of the ZeroTier core
CoreVersionBuild int = C.ZEROTIER_ONE_VERSION_BUILD
)
// Node is an instance of a ZeroTier node
type Node struct {
node *C.ZT_Node
}

7
include/ZeroTierCore.h
View File

@ -166,6 +166,11 @@ extern "C" {
*/
#define ZT_MAX_MULTICAST_SUBSCRIPTIONS 1024
/**
* Maximum size for a state object (via state object put/get callbacks/API)
*/
#define ZT_MAX_STATE_OBJECT_SIZE 4096
/**
* Maximum value for link quality (min is 0)
*/
@ -1319,7 +1324,7 @@ typedef struct
/**
* Whether this peer was ever reachable via an aggregate link
*/
bool hadAggregateLink;
int hadAggregateLink;
/**
* Known network paths to peer

31
osdep/BlockingQueue.hpp
View File

@ -18,8 +18,9 @@
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <atomic>
#include "Thread.hpp"
#include "../node/Constants.hpp"
namespace ZeroTier {
@ -32,16 +33,23 @@ template <class T>
class BlockingQueue
{
public:
BlockingQueue(void) : r(true) {}
enum TimedWaitResult
{
OK,
TIMED_OUT,
STOP
};
inline void post(T t)
ZT_ALWAYS_INLINE BlockingQueue(void) : r(true) {}
ZT_ALWAYS_INLINE void post(T t)
{
std::lock_guard<std::mutex> lock(m);
q.push(t);
c.notify_one();
}
inline void postLimit(T t,const unsigned long limit)
ZT_ALWAYS_INLINE void postLimit(T t,const unsigned long limit)
{
std::unique_lock<std::mutex> lock(m);
for(;;) {
@ -56,7 +64,7 @@ public:
}
}
inline void stop(void)
ZT_ALWAYS_INLINE void stop(void)
{
std::lock_guard<std::mutex> lock(m);
r = false;
@ -64,7 +72,7 @@ public:
gc.notify_all();
}
inline bool get(T &value)
ZT_ALWAYS_INLINE bool get(T &value)
{
std::unique_lock<std::mutex> lock(m);
if (!r) return false;
@ -81,14 +89,7 @@ public:
return true;
}
enum TimedWaitResult
{
OK,
TIMED_OUT,
STOP
};
inline TimedWaitResult get(T &value,const unsigned long ms)
ZT_ALWAYS_INLINE TimedWaitResult get(T &value,const unsigned long ms)
{
const std::chrono::milliseconds ms2{ms};
std::unique_lock<std::mutex> lock(m);
@ -105,7 +106,7 @@ public:
}
private:
volatile bool r;
std::atomic_bool r;
std::queue<T> q;
mutable std::mutex m;
mutable std::condition_variable c,gc;