gfwleak/zhangyang-libzt
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

various bug fixes

Browse Source
This commit is contained in:
Joseph Henry
2017-04-21 14:56:42 -07:00
parent 76abb3e0a2
commit 6a25abb757
16 changed files with 259 additions and 1312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
Makefile
View File

@@ -1,11 +1,10 @@
# Common makefile -- loads make rules for each platform
BUILD=build
INT=integrations
ZTO=zto
OSTYPE=$(shell uname -s)
BUILD=build/$(OSTYPE)
ZTO=zto
ifeq ($(OSTYPE),Darwin)
include make-mac.mk
endif

35
README.md
View File

@@ -3,29 +3,28 @@ ZeroTier SDK
[![irc](https://img.shields.io/badge/IRC-%23zerotier%20on%20freenode-orange.svg)](https://webchat.freenode.net/?channels=zerotier)
Embed ZeroTier directly into your app or service. Connect everything without worrying about how it's actually connected.
***
## Example
```
std::string str = "welcome to the machine";
zts_start(path);
while(!zts_service_running())
sleep(1);
zts_join_network(nwid);
int err, sockfd;
while(!zts_has_address(nwid))
sleep(1);
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
string str = "welcome to the machine";
zts_start("./zt");
while(!zts_service_running())
sleep(1);
zts_join_network(nwid);
int err, sockfd;
while(!zts_has_address(nwid))
sleep(1);
if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
}
if((err = zts_connect(fd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
}
int wrote = zts_write(fd, str.c_str(), str.length());
zts_close(fd);
```
Bindings also exist for [many popular languages]().

59
make-linux.mk
View File

@@ -14,24 +14,20 @@ endif
include objects.mk
OSTYPE = $(shell uname -s | tr '[A-Z]' '[a-z]')
# Target output filenames
STATIC_LIB_NAME = libzt.a
INTERCEPT_NAME = libztintercept.so
SDK_SERVICE_NAME = zerotier-sdk-service
ONE_SERVICE_NAME = zerotier-one
PICO_LIB_NAME = libpicotcp.a
#
STATIC_LIB = $(BUILD)/$(STATIC_LIB_NAME)
SDK_INTERCEPT = $(BUILD)/$(INTERCEPT_NAME)
SDK_SERVICE = $(BUILD)/$(SDK_SERVICE_NAME)
ONE_SERVICE = $(BUILD)/$(ONE_SERVICE_NAME)
PICO_LIB = ext/picotcp/build/lib/$(PICO_LIB_NAME)
TEST_BUILD_DIR = build/test
PICO_DIR = ext/picotcp
PICO_LIB = $(PICO_DIR)/build/lib/$(PICO_LIB_NAME)
#
TEST_BUILD_DIR = $(BUILD)/test
UNIT_TEST_SRC_DIR = test/unit
DUMB_TEST_SRC_DIR = test/dumb
##############################################################################
## General Configuration ##
##############################################################################
@@ -39,7 +35,6 @@ DUMB_TEST_SRC_DIR = test/dumb
# Debug output for ZeroTier service
ifeq ($(ZT_DEBUG),1)
DEFS+=-DZT_TRACE
#CFLAGS+=-Wall -fPIE -fvisibility=hidden -pthread $(INCLUDES) $(DEFS)
CFLAGS+=-Wall -g -pthread $(INCLUDES) $(DEFS)
STRIP=echo
# The following line enables optimization for the crypto code, since
@@ -68,6 +63,8 @@ INCLUDES+= -Iext \
-Iext/picotcp/include \
-Iext/picotcp/build/include
COMMON_LIBS = -lpthread
##############################################################################
## User Build Flags ##
##############################################################################
@@ -108,12 +105,12 @@ endif
STACK_DRIVER_FILES:=src/picoTCP.cpp
TAP_FILES:=src/SocketTap.cpp \
src/ZeroTierSDK.cpp \
src/Utils.cpp
src/Utilities.cpp
SDK_OBJS+= SocketTap.o \
picoTCP.o \
ZeroTierSDK.o \
Utils.o
Utilities.o
PICO_OBJS+= ext/picotcp/build/lib/pico_device.o \
ext/picotcp/build/lib/pico_frame.o \
@@ -133,15 +130,17 @@ tests: dumb_tests unit_tests
##############################################################################
picotcp:
cd ext/picotcp; make lib ARCH=shared IPV4=1 IPV6=1
cd $(PICO_DIR); make lib ARCH=shared IPV4=1 IPV6=1
##############################################################################
## Static Libraries ##
##############################################################################
static_lib: picotcp $(ZTO_OBJS)
@mkdir -p $(BUILD)
$(CXX) $(CXXFLAGS) $(SDK_FLAGS) $(TAP_FILES) $(STACK_DRIVER_FILES) -c -DSDK_STATIC
libtool -o $(STATIC_LIB) $(ZTO_OBJS) $(SDK_OBJS) $(PICO_LIB)
#libtool --mode=link $(STATIC_LIB) $(ZTO_OBJS) $(SDK_OBJS) $(PICO_LIB)
ar rcs -o $(STATIC_LIB) ext/picotcp/build/modules/*.o $(PICO_OBJS) $(ZTO_OBJS) $(SDK_OBJS)
jni_static_lib: picotcp $(ZTO_OBJS)
@@ -149,12 +148,12 @@ jni_static_lib: picotcp $(ZTO_OBJS)
## Unit Tests ##
##############################################################################
UNIT_TEST_SRC_FILES:=$(wildcard $(UNIT_TEST_SRC_DIR)/*.cpp)
UNIT_TEST_OBJ_FILES:=$(addprefix $(TEST_BUILD_DIR)/,$(notdir $(UNIT_TEST_SRC_FILES:.cpp=)))
UNIT_TEST_INCLUDES:=-Iinclude
UNIT_TEST_LIBS:=-Lbuild -lzt
UNIT_TEST_SRC_FILES := $(wildcard $(UNIT_TEST_SRC_DIR)/*.cpp)
UNIT_TEST_OBJ_FILES := $(addprefix $(TEST_BUILD_DIR)/,$(notdir $(UNIT_TEST_SRC_FILES:.cpp=)))
UNIT_TEST_INCLUDES := -Iinclude
UNIT_TEST_LIBS := -L$(BUILD) -lzt $(COMMON_LIBS)
$(TEST_BUILD_DIR)/%.out: $(UNIT_TEST_SRC_DIR)/%.cpp
$(TEST_BUILD_DIR)/%: $(UNIT_TEST_SRC_DIR)/%.cpp
@mkdir -p $(TEST_BUILD_DIR)
@-$(CXX) $(UNIT_TEST_INCLUDES) -o $@ $< $(UNIT_TEST_LIBS)
@-./check.sh $@
@@ -165,10 +164,10 @@ unit_tests: $(UNIT_TEST_OBJ_FILES)
## Non-ZT Client/Server Tests ##
##############################################################################
DUMB_TEST_SRC_FILES=$(wildcard $(DUMB_TEST_SRC_DIR)/*.cpp)
DUMB_TEST_OBJ_FILES := $(addprefix $(TEST_BUILD_DIR)/,$(notdir $(DUMB_TEST_SRC_FILES:.cpp=.out)))
DUMB_TEST_SRC_FILES := $(wildcard $(DUMB_TEST_SRC_DIR)/*.cpp)
DUMB_TEST_OBJ_FILES := $(addprefix $(TEST_BUILD_DIR)/,$(notdir $(DUMB_TEST_SRC_FILES:.cpp=)))
$(TEST_BUILD_DIR)/%.out: $(DUMB_TEST_SRC_DIR)/%.cpp
$(TEST_BUILD_DIR)/%: $(DUMB_TEST_SRC_DIR)/%.cpp
@mkdir -p $(TEST_BUILD_DIR)
@-$(CC) -o $@ $<
@-./check.sh $@
@@ -179,19 +178,19 @@ dumb_tests: $(DUMB_TEST_OBJ_FILES)
## Misc ##
##############################################################################
# Cleans only current $(OSTYPE)
clean:
-rm -rf $(BUILD)/*
-rm -rf zerotier-cli zerotier-idtool
-find . -type f \( -name $(ONE_SERVICE_NAME) -o -name $(SDK_SERVICE_NAME) \) -delete
-find $(PICO_DIR) -type f \( -name '*.o' -o -name '*.so' -o -name '*.a' \) -delete
-find . -type f \( -name '*.o' -o -name '*.so' -o -name '*.o.d' -o -name '*.out' -o -name '*.log' -o -name '*.dSYM' \) -delete
# Clean everything
nuke:
-rm -rf $(BUILD)/*
-find . -type f \( -name '*.o' -o -name '*.so' -o -name '*.a' -o -name '*.o.d' -o -name '*.out' -o -name '*.log' -o -name '*.dSYM' \) -delete
# Check for the presence of built frameworks/bundles/libaries
check:
-./check.sh $(PICO_LIB)
-./check.sh $(SDK_INTERCEPT)
-./check.sh $(ONE_SERVICE)
-./check.sh $(SDK_SERVICE)
-./check.sh $(STATIC_LIB)
-./check.sh $(STATIC_LIB)

49
make-mac.mk
View File

@@ -14,20 +14,17 @@ endif
include objects.mk
OSTYPE = $(shell uname -s | tr '[A-Z]' '[a-z]')
# Target output filenames
STATIC_LIB_NAME = libzt.a
INTERCEPT_NAME = libztintercept.so
SDK_SERVICE_NAME = zerotier-sdk-service
ONE_SERVICE_NAME = zerotier-one
PICO_LIB_NAME = libpicotcp.a
#
STATIC_LIB = $(BUILD)/$(STATIC_LIB_NAME)
SDK_INTERCEPT = $(BUILD)/$(INTERCEPT_NAME)
SDK_SERVICE = $(BUILD)/$(SDK_SERVICE_NAME)
ONE_SERVICE = $(BUILD)/$(ONE_SERVICE_NAME)
PICO_LIB = ext/picotcp/build/lib/$(PICO_LIB_NAME)
TEST_BUILD_DIR = build/test
PICO_DIR = ext/picotcp
PICO_LIB = $(PICO_DIR)/build/lib/$(PICO_LIB_NAME)
#
TEST_BUILD_DIR = $(BUILD)/test
UNIT_TEST_SRC_DIR = test/unit
DUMB_TEST_SRC_DIR = test/dumb
@@ -39,7 +36,6 @@ DUMB_TEST_SRC_DIR = test/dumb
# Debug output for ZeroTier service
ifeq ($(ZT_DEBUG),1)
DEFS+=-DZT_TRACE
#CFLAGS+=-Wall -fPIE -fvisibility=hidden -pthread $(INCLUDES) $(DEFS)
CFLAGS+=-Wall -g -pthread $(INCLUDES) $(DEFS)
STRIP=echo
# The following line enables optimization for the crypto code, since
@@ -108,12 +104,12 @@ endif
STACK_DRIVER_FILES:=src/picoTCP.cpp
TAP_FILES:=src/SocketTap.cpp \
src/ZeroTierSDK.cpp \
src/Utils.cpp
src/Utilities.cpp
SDK_OBJS+= SocketTap.o \
picoTCP.o \
ZeroTierSDK.o \
Utils.o
Utilities.o
PICO_OBJS+= ext/picotcp/build/lib/pico_device.o \
ext/picotcp/build/lib/pico_frame.o \
@@ -133,13 +129,14 @@ tests: dumb_tests unit_tests
##############################################################################
picotcp:
cd ext/picotcp; make lib ARCH=shared IPV4=1 IPV6=1
cd $(PICO_DIR); make lib ARCH=shared IPV4=1 IPV6=1
##############################################################################
## Static Libraries ##
##############################################################################
static_lib: picotcp $(ZTO_OBJS)
@mkdir -p $(BUILD)
$(CXX) $(CXXFLAGS) $(SDK_FLAGS) $(TAP_FILES) $(STACK_DRIVER_FILES) -c -DSDK_STATIC
libtool -static -o $(STATIC_LIB) $(ZTO_OBJS) $(SDK_OBJS) $(PICO_LIB)
@@ -149,10 +146,10 @@ jni_static_lib: picotcp $(ZTO_OBJS)
## Unit Tests ##
##############################################################################
UNIT_TEST_SRC_FILES:=$(wildcard $(UNIT_TEST_SRC_DIR)/*.cpp)
UNIT_TEST_OBJ_FILES:=$(addprefix $(TEST_BUILD_DIR)/,$(notdir $(UNIT_TEST_SRC_FILES:.cpp=)))
UNIT_TEST_INCLUDES:=-Iinclude
UNIT_TEST_LIBS:=-Lbuild -lzt
UNIT_TEST_SRC_FILES := $(wildcard $(UNIT_TEST_SRC_DIR)/*.cpp)
UNIT_TEST_OBJ_FILES := $(addprefix $(TEST_BUILD_DIR)/,$(notdir $(UNIT_TEST_SRC_FILES:.cpp=)))
UNIT_TEST_INCLUDES := -Iinclude
UNIT_TEST_LIBS := -L$(BUILD) -lzt
$(TEST_BUILD_DIR)/%: $(UNIT_TEST_SRC_DIR)/%.cpp
@mkdir -p $(TEST_BUILD_DIR)
@@ -165,7 +162,7 @@ unit_tests: $(UNIT_TEST_OBJ_FILES)
## Non-ZT Client/Server Tests ##
##############################################################################
DUMB_TEST_SRC_FILES=$(wildcard $(DUMB_TEST_SRC_DIR)/*.cpp)
DUMB_TEST_SRC_FILES := $(wildcard $(DUMB_TEST_SRC_DIR)/*.cpp)
DUMB_TEST_OBJ_FILES := $(addprefix $(TEST_BUILD_DIR)/,$(notdir $(DUMB_TEST_SRC_FILES:.cpp=)))
$(TEST_BUILD_DIR)/%: $(DUMB_TEST_SRC_DIR)/%.cpp
@@ -179,19 +176,19 @@ dumb_tests: $(DUMB_TEST_OBJ_FILES)
## Misc ##
##############################################################################
# Cleans only current $(OSTYPE)
clean:
-rm -rf $(BUILD)/*
-rm -rf zerotier-cli zerotier-idtool
-find . -type f \( -name $(ONE_SERVICE_NAME) -o -name $(SDK_SERVICE_NAME) \) -delete
-find . -type f \( -name '*.o' -o -name '*.so' -o -name '*.a' -o -name '*.o.d' -o -name '*.out' -o -name '*.log' -o -name '*.dSYM' \) -delete
-find $(PICO_DIR) -type f \( -name '*.o' -o -name '*.so' -o -name '*.a' \) -delete
-find . -type f \( -name '*.o' -o -name '*.so' -o -name '*.o.d' -o -name '*.out' -o -name '*.log' -o -name '*.dSYM' \) -delete
# Check for the presence of built frameworks/bundles/libaries
# Clean everything
nuke:
-rm -rf $(BUILD)/*
-find . -type f \( -name '*.o' -o -name '*.so' -o -name '*.a' -o -name '*.o.d' -o -name '*.out' -o -name '*.log' -o -name '*.dSYM' \) -delete
check:
-./check.sh $(PICO_LIB)
-./check.sh $(SDK_INTERCEPT)
-./check.sh $(ONE_SERVICE)
-./check.sh $(SDK_SERVICE)
-./check.sh $(STATIC_LIB)
-./check.sh $(STATIC_LIB)

8
src/Connection.hpp
View File

@@ -21,10 +21,13 @@
#include <sys/socket.h>
// picoTCP
#include "pico_socket.h"
// ZT
#include "Phy.hpp"
// SDK
#include "ZeroTierSDK.h"
#include "SocketTap.hpp"
@@ -59,6 +62,7 @@ namespace ZeroTier {
int state; // See ZeroTierSDK.h for (ZT_SOCK_STATE_*)
Connection() {
// DEBUG_INFO("Connection() this = %p", this);
ZT_PHY_SOCKFD_TYPE fdpair[2];
if(socketpair(PF_LOCAL, SOCK_STREAM, 0, fdpair) < 0) {
if(errno < 0) {
@@ -69,6 +73,10 @@ namespace ZeroTier {
sdk_fd = fdpair[0];
app_fd = fdpair[1];
}
~Connection()
{
// DEBUG_INFO("~Connection() this = %p", this);
}
};
/*

12
src/SocketTap.cpp
View File

@@ -16,6 +16,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// picoTCP
#include <algorithm>
#include <utility>
#include <dlfcn.h>
@@ -26,10 +27,12 @@
#include <sys/resource.h>
#include <sys/syscall.h>
// SDK
#include "SocketTap.hpp"
#include "ZeroTierSDK.h"
#include "picoTCP.hpp"
// ZT
#include "Utils.hpp"
#include "OSUtils.hpp"
#include "Constants.hpp"
@@ -89,7 +92,6 @@ namespace ZeroTier {
bool SocketTap::addIp(const InetAddress &ip)
{
DEBUG_INFO();
picostack->pico_init_interface(this, ip);
_ips.push_back(ip);
return true;
@@ -171,6 +173,7 @@ namespace ZeroTier {
void SocketTap::phyOnUnixData(PhySocket *sock, void **uptr, void *data, ssize_t len)
{
DEBUG_INFO();
Connection *conn = (Connection*)*uptr;
if(!conn)
return;
@@ -185,6 +188,7 @@ namespace ZeroTier {
void SocketTap::phyOnUnixWritable(PhySocket *sock,void **uptr,bool stack_invoked)
{
DEBUG_INFO();
Read(sock,uptr,stack_invoked);
}
@@ -202,9 +206,9 @@ namespace ZeroTier {
return picostack->pico_Bind(conn, fd, addr, addrlen);
}
void SocketTap::Listen(Connection *conn, int fd, int backlog) {
int SocketTap::Listen(Connection *conn, int fd, int backlog) {
Mutex::Lock _l(_tcpconns_m);
picostack->pico_Listen(conn, fd, backlog);
return picostack->pico_Listen(conn, fd, backlog);
}
int SocketTap::Accept(Connection *conn) {
@@ -213,7 +217,7 @@ namespace ZeroTier {
}
void SocketTap::Read(PhySocket *sock,void **uptr,bool stack_invoked) {
picostack->pico_Read(this, sock, uptr, stack_invoked);
picostack->pico_Read(this, sock, (Connection*)uptr, stack_invoked);
}
void SocketTap::Write(Connection *conn) {

2
src/SocketTap.hpp
View File

@@ -184,7 +184,7 @@ namespace ZeroTier {
/*
* Listen for a Connection
*/
void Listen(Connection *conn, int fd, int backlog);
int Listen(Connection *conn, int fd, int backlog);
/*
* Accepts an incoming Connection

0
src/Utils.cpp → src/Utilities.cpp
View File

4
src/Utils.hpp → src/Utilities.hpp
View File

@@ -16,8 +16,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SDK_UTILS_HPP
#define SDK_UTILS_HPP
#ifndef SDK_UTILITIES_HPP
#define SDK_UTILITIES_HPP
/*
* Print a stacktrace

76
src/ZeroTierSDK.cpp
View File

@@ -29,12 +29,14 @@
#include <sys/types.h>
#include <pthread.h>
// ZT
#include "OneService.hpp"
#include "Utils.hpp"
#include "OSUtils.hpp"
#include "InetAddress.hpp"
#include "ZeroTierOne.h"
// SDK
#include "SocketTap.hpp"
#include "ZeroTierSDK.h"
@@ -290,8 +292,18 @@ void zts_disable_http_control_plane()
/* bind() call. This enables multi-network support */
/****************************************************************************/
/*
socket fd = 0 (nwid=X)---\ /--- SocketTap=A // e.x. 172.27.0.0/?
\ /
socket fd = 1 (nwid=Y)--------Multiplexed z* calls-------- SocketTap=B // e.x. 192.168.0.1/16
/ \
socket fd = 2 (nwid=Z)---/ \--- SocketTap=C // e.x. 10.9.9.0/24
*/
int zts_socket(ZT_SOCKET_SIG) {
DEBUG_ERROR("UnassConn=%d, AssigFDs=%d", ZeroTier::UnassignedConnections.size(), ZeroTier::AssignedConnections.size());
DEBUG_INFO("UnassConn=%d, AssigFDs=%d", ZeroTier::UnassignedConnections.size(), ZeroTier::AssignedConnections.size());
DEBUG_INFO();
ZeroTier::_multiplexer_lock.lock();
ZeroTier::Connection *conn = new ZeroTier::Connection();
@@ -367,8 +379,7 @@ int zts_connect(ZT_CONNECT_SIG) {
else {
// pointer to tap we use in callbacks from the stack
conn->picosock->priv = new ZeroTier::ConnectionPair(tap, conn);
DEBUG_INFO("found appropriate SocketTap");
// TODO: Perhaps move this connect call outside of the lock
// DEBUG_INFO("found appropriate SocketTap");
// Semantically: tap->stack->connect
err = tap->Connect(conn, fd, addr, addrlen);
if(err == 0) {
@@ -377,7 +388,9 @@ int zts_connect(ZT_CONNECT_SIG) {
}
// Wrap the socketpair we created earlier
// For I/O loop participation and referencing the PhySocket's parent Connection in callbacks
conn->sock = tap->_phy.wrapSocket(conn->sdk_fd, conn);
conn->sock = tap->_phy.wrapSocket(conn->sdk_fd, conn);
DEBUG_INFO("wrapping conn->sdk_fd = %d", conn->sdk_fd);
DEBUG_INFO(" conn->app_fd = %d", conn->app_fd);
}
}
else {
@@ -402,10 +415,13 @@ int zts_connect(ZT_CONNECT_SIG) {
return -1;
}
// FIXME: Double check that accept/connect queues in multithreaded apps don't get mixed up
// blocking
if(err == 0 && true) {
while(true)
{
// FIXME: locking and unlocking so often might cause a performance bottleneck while outgoing connections
// are being established (also applies to accept())
usleep(ZT_CONNECT_RECHECK_DELAY * 1000);
tap->_tcpconns_m.lock();
for(int i=0; i<tap->_Connections.size(); i++)
@@ -443,12 +459,10 @@ int zts_bind(ZT_BIND_SIG) {
ZeroTier::InetAddress iaddr;
if(conn->socket_family == AF_INET) {
// FIXME: Fix this typecast mess
inet_ntop(AF_INET,
(const void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, ipstr, INET_ADDRSTRLEN);
}
if(conn->socket_family == AF_INET6) {
// FIXME: Fix this typecast mess
inet_ntop(AF_INET6,
(const void *)&((struct sockaddr_in6 *)addr)->sin6_addr.s6_addr, ipstr, INET6_ADDRSTRLEN);
}
@@ -466,10 +480,9 @@ int zts_bind(ZT_BIND_SIG) {
err = -1;
}
else {
DEBUG_INFO("found appropriate SocketTap");
DEBUG_INFO("conn->picosock = %p", conn->picosock);
//DEBUG_INFO("found appropriate SocketTap");
//DEBUG_INFO("conn->picosock = %p", conn->picosock);
conn->picosock->priv = new ZeroTier::ConnectionPair(tap, conn);
// TODO: Perhaps move this connect call outside of the lock
tap->_Connections.push_back(conn); // Give this Connection to the tap we decided on
err = tap->Bind(conn, fd, addr, addrlen); // Semantically: tap->stack->connect
conn->tap = tap;
@@ -498,7 +511,6 @@ int zts_listen(ZT_LISTEN_SIG) {
DEBUG_ERROR("unable to locate connection pair (did you zbind()?");
return -1;
}
ZeroTier::Connection *conn = p->first;
ZeroTier::SocketTap *tap = p->second;
@@ -506,24 +518,29 @@ int zts_listen(ZT_LISTEN_SIG) {
DEBUG_ERROR("unable to locate tap interface for file descriptor");
return -1;
}
tap->Listen(conn, fd, backlog);
err = 0;
DEBUG_INFO("put conn=%p into LISTENING state", conn);
err = tap->Listen(conn, fd, backlog);
DEBUG_INFO("put conn=%p into LISTENING state (err=%d)", conn, err);
ZeroTier::_multiplexer_lock.unlock();
return err;
}
int zts_accept(ZT_ACCEPT_SIG) {
DEBUG_INFO();
int err;
ZeroTier::Connection *conn = ZeroTier::AssignedConnections[fd]->first;
ZeroTier::SocketTap *tap = ZeroTier::AssignedConnections[fd]->second;
std::pair<ZeroTier::Connection*, ZeroTier::SocketTap*> *p = ZeroTier::AssignedConnections[fd];
if(!p) {
DEBUG_ERROR("unable to locate connection pair (did you zbind()?");
return -1;
}
ZeroTier::Connection *conn = p->first;
ZeroTier::SocketTap *tap = p->second;
// BLOCKING: loop and keep checking until we find a newly accepted connection
if(true) {
while(true) {
usleep(ZT_ACCEPT_RECHECK_DELAY * 1000);
err = tap->Accept(conn);
if(err >= 0)
return err;
return err; // accepted fd
}
}
// NON-BLOCKING: only check for a new connection once
@@ -535,6 +552,7 @@ int zts_accept(ZT_ACCEPT_SIG) {
#if defined(__linux__)
int zts_accept4(ZT_ACCEPT4_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
@@ -542,30 +560,35 @@ int zts_accept(ZT_ACCEPT_SIG) {
int zts_setsockopt(ZT_SETSOCKOPT_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
int zts_getsockopt(ZT_GETSOCKOPT_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
int zts_getsockname(ZT_GETSOCKNAME_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
int zts_getpeername(ZT_GETPEERNAME_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
int zts_close(ZT_CLOSE_SIG)
{
DEBUG_INFO();
ZeroTier::_multiplexer_lock.lock();
ZeroTier::Connection *conn = ZeroTier::AssignedConnections[fd]->first;
ZeroTier::SocketTap *tap = ZeroTier::AssignedConnections[fd]->second;
@@ -579,39 +602,46 @@ int zts_close(ZT_CLOSE_SIG)
int zts_fcntl(ZT_FCNTL_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
ssize_t zts_sendto(ZT_SENDTO_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
ssize_t zts_sendmsg(ZT_SENDMSG_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
ssize_t zts_recvfrom(ZT_RECVFROM_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
ssize_t zts_recvmsg(ZT_RECVMSG_SIG)
{
DEBUG_INFO();
// TODO
return 0;
}
int zts_read(ZT_READ_SIG) {
DEBUG_INFO();
return read(fd, buf, len);
}
int zts_write(ZT_WRITE_SIG) {
DEBUG_INFO();
return write(fd, buf, len);
}
@@ -744,7 +774,7 @@ void *_start_service(void *thread_id) {
unsigned int randp = 0;
ZeroTier::Utils::getSecureRandom(&randp,sizeof(randp));
int servicePort = 9000 + (randp % 1000);
DEBUG_ERROR("servicePort = %d", servicePort);
DEBUG_INFO("servicePort = %d", servicePort);
for(;;) {
zt1Service = ZeroTier::OneService::newInstance(ZeroTier::homeDir.c_str(),servicePort);
@@ -782,3 +812,15 @@ void *_start_service(void *thread_id) {
#ifdef __cplusplus
}
#endif
/*
*
*
*
*
*
*/

87
src/picoTCP.cpp
View File

@@ -16,6 +16,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// picoTCP
#include "pico_eth.h"
#include "pico_stack.h"
#include "pico_ipv4.h"
@@ -26,11 +27,13 @@
#include "pico_device.h"
#include "pico_ipv6.h"
// SDK
#include "ZeroTierSDK.h"
#include "Utils.hpp"
#include "Utilities.hpp"
#include "SocketTap.hpp"
#include "picoTCP.hpp"
// ZT
#include "Utils.hpp"
#include "OSUtils.hpp"
#include "Mutex.hpp"
@@ -67,21 +70,8 @@ extern "C" struct pico_ipv6_link * pico_ipv6_link_add(PICO_IPV6_LINK_ADD_SIG);
namespace ZeroTier {
//extern ZeroTier::Mutex _accepted_connection_lock;
// Reference to the tap interface
// This is needed due to the fact that there's a lot going on in the tap interface
// that needs to be updated on each of the network stack's callbacks and not every
// network stack provides a mechanism for storing a reference to the tap.
//
// In future releases this will be replaced with a new structure of static pointers that
// will make it easier to maintain multiple active tap interfaces
struct pico_device picodev;
int pico_eth_send(struct pico_device *dev, void *buf, int len);
int pico_eth_poll(struct pico_device *dev, int loop_score);
void picoTCP::pico_init_interface(SocketTap *tap, const InetAddress &ip)
{
DEBUG_INFO();
@@ -96,7 +86,7 @@ namespace ZeroTier {
netmask.addr = *((uint32_t *)ip.netmask().rawIpData());
uint8_t mac[PICO_SIZE_ETH];
tap->_mac.copyTo(mac, PICO_SIZE_ETH);
DEBUG_ATTN("mac = %s", tap->_mac.toString().c_str());
// DEBUG_ATTN("mac = %s", tap->_mac.toString().c_str());
picodev.send = pico_eth_send; // tx
picodev.poll = pico_eth_poll; // rx
picodev.mtu = tap->_mtu;
@@ -106,8 +96,6 @@ namespace ZeroTier {
return;
}
pico_ipv4_link_add(&(picodev), ipaddr, netmask);
// DEBUG_INFO("device initialized as ipv4_addr = %s", ipv4_str);
// pico_icmp4_ping("10.8.8.1", 20, 1000, 10000, 64, cb_ping);
}
#elif defined(SDK_IPV6)
if(ip.isV6())
@@ -124,12 +112,11 @@ namespace ZeroTier {
picodev.tap = tap;
uint8_t mac[PICO_SIZE_ETH];
tap->_mac.copyTo(mac, PICO_SIZE_ETH);
DEBUG_ATTN("mac = %s", tap->_mac.toString().c_str());
// DEBUG_ATTN("mac = %s", tap->_mac.toString().c_str());
if( 0 != pico_device_init(&(picodev), "p0", mac)) {
DEBUG_ERROR("dev init failed");
return;
}
DEBUG_ATTN("addr = %s", ipv6_str);
}
#endif
}
@@ -160,9 +147,11 @@ namespace ZeroTier {
if(avail) {
r = pico_socket_recvfrom(s, conn->rxbuf + (conn->rxsz), ZT_SDK_MTU,
(void *)&peer.ip4.addr, &port);
tap->_phy.setNotifyWritable(conn->sock, true);
//tap->_phy.setNotifyWritable(conn->sock, true);
if (r > 0)
conn->rxsz += r;
picostack->pico_Read(tap, conn->sock, conn, true);
DEBUG_INFO("r = %d, conn->rxsz=%d, conn=%p, conn->sock = %p", r, conn->rxsz, conn, conn->sock);
}
else
DEBUG_ERROR("not enough space left on I/O RX buffer for pico_socket(%p)", s);
@@ -195,12 +184,6 @@ namespace ZeroTier {
int r = pico_socket_recvfrom(s, tmpbuf, ZT_SDK_MTU, (void *)&peer.ip4.addr, &port);
//DEBUG_FLOW(" [ RXBUF <- STACK] Receiving (%d) from stack, copying to receving buffer", r);
// Mutex::Lock _l2(tap->_rx_buf_m);
// struct sockaddr_in6 addr_in6;
// addr_in6.sin6_addr.s6_addr;
// addr_in6.sin6_port = Utils::ntoh(s->remote_port);
// DEBUG_ATTN("remote_port=%d, local_port=%d", s->remote_port, Utils::ntoh(s->local_port));
tap->_rx_buf_m.lock();
if(conn->rxsz == ZT_UDP_RX_BUF_SZ) { // if UDP buffer full
//DEBUG_FLOW(" [ RXBUF <- STACK] UDP RX buffer full. Discarding oldest payload segment");
memmove(conn->rxbuf, conn->rxbuf + ZT_SDK_MTU, ZT_UDP_RX_BUF_SZ - ZT_SDK_MTU);
@@ -214,7 +197,6 @@ namespace ZeroTier {
}
payload_pos = addr_pos + sizeof(struct sockaddr_storage) + sizeof(r);
memcpy(addr_pos, &addr_in, sizeof(struct sockaddr_storage));
memcpy(payload_pos, tmpbuf, r); // write payload to app's socket
// Adjust buffer size
@@ -228,6 +210,7 @@ namespace ZeroTier {
tap->_rx_buf_m.unlock();
// TODO: Revisit logic
// FIXME: simplify
if(r)
tap->phyOnUnixWritable(conn->sock, NULL, true);
//DEBUG_EXTRA(" Copied onto rxbuf (%d) from stack socket", r);
@@ -260,7 +243,7 @@ namespace ZeroTier {
#if DEBUG_LEVEL >= MSG_TRANSFER
int max = conn->socket_type == SOCK_STREAM ? ZT_TCP_TX_BUF_SZ : ZT_UDP_TX_BUF_SZ;
DEBUG_TRANS("[TCP TX] ---> :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
DEBUG_TRANS("[ TCP TX -> STACK] :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
(float)conn->txsz / (float)max, (float)conn->rxsz / max, conn->sock, r);
#endif
@@ -270,7 +253,6 @@ namespace ZeroTier {
void picoTCP::pico_cb_socket_activity(uint16_t ev, struct pico_socket *s)
{
DEBUG_INFO();
// TODO: Test API out of order so this check isn't necessary
if(!(SocketTap*)((ConnectionPair*)(s->priv)))
return;
@@ -282,7 +264,7 @@ namespace ZeroTier {
if(!conn) {
DEBUG_ERROR("invalid connection");
}
DEBUG_INFO("conn = %p", conn);
// accept()
if (ev & PICO_SOCK_EV_CONN) {
if(conn->state == ZT_SOCK_STATE_LISTENING)
@@ -312,9 +294,15 @@ namespace ZeroTier {
conn->_AcceptedConnections.push(newConn);
// For I/O loop participation and referencing the PhySocket's parent Connection in callbacks
newConn->sock = tap->_phy.wrapSocket(newConn->sdk_fd, newConn);
DEBUG_INFO("wrapping newConn->sdk_fd = %d", newConn->sdk_fd);
DEBUG_INFO(" newConn->app_fd = %d", newConn->app_fd);
DEBUG_INFO(" newConn->sock = %p", newConn->sock);
DEBUG_INFO(" conn = %p", conn);
DEBUG_INFO(" newConn = %p", newConn);
DEBUG_INFO(" oldConn->sock = %p", conn->sock);
}
if(conn->state != ZT_SOCK_STATE_LISTENING) {
// set state so blocking socket multiplexer logic will pick this up
// set state so socket multiplexer logic will pick this up
conn->state = ZT_SOCK_STATE_UNHANDLED_CONNECTED;
}
}
@@ -359,6 +347,7 @@ namespace ZeroTier {
dest_mac.setTo(ethhdr->daddr, 6);
tap->_handler(tap->_arg,NULL,tap->_nwid,src_mac,dest_mac,
Utils::ntoh((uint16_t)ethhdr->proto),0, ((char*)buf) + sizeof(struct pico_eth_hdr),len - sizeof(struct pico_eth_hdr));
//DEBUG_INFO("len = %d", len);
return len;
}
@@ -388,7 +377,7 @@ namespace ZeroTier {
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen), &ethhdr, sizeof(ethhdr)); // new eth header
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen) + sizeof(ethhdr), data, len); // frame data
tap->pico_frame_rxbuf_tot += newlen;
DEBUG_FLOW(" [ ZWIRE -> FBUF ] Move FRAME(sz=%d) into FBUF(sz=%d), data_len=%d", newlen, tap->pico_frame_rxbuf_tot, len);
DEBUG_FLOW("[ ZWIRE -> FBUF ] Move FRAME(sz=%d) into FBUF(sz=%d), data_len=%d", newlen, tap->pico_frame_rxbuf_tot, len);
}
int pico_eth_poll(struct pico_device *dev, int loop_score)
@@ -410,6 +399,7 @@ namespace ZeroTier {
memcpy(frame, tap->pico_frame_rxbuf + sizeof(len), len-(sizeof(len)) ); // get frame data
memmove(tap->pico_frame_rxbuf, tap->pico_frame_rxbuf + len, MAX_PICO_FRAME_RX_BUF_SZ-len); // shift buffer
err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(len)));
//DEBUG_INFO("recv = %d", err);
tap->pico_frame_rxbuf_tot-=len;
}
else {
@@ -457,6 +447,7 @@ namespace ZeroTier {
int picoTCP::pico_Bind(Connection *conn, int fd, const struct sockaddr *addr, socklen_t addrlen)
{
DEBUG_INFO();
int err;
#if defined(SDK_IPV4)
struct pico_ip4 zaddr;
@@ -464,8 +455,10 @@ namespace ZeroTier {
char ipv4_str[INET_ADDRSTRLEN];
inet_ntop(AF_INET, (const void *)&in4->sin_addr.s_addr, ipv4_str, INET_ADDRSTRLEN);
pico_string_to_ipv4(ipv4_str, &(zaddr.addr));
//DEBUG_ATTN("addr=%s:%d, physock=%p, picosock=%p", ipv4_str, Utils::ntoh(addr->sin_port), sock, (conn->picosock));
// DEBUG_ATTN("addr=%s: %d ntoh()=%d", ipv4_str, in4->sin_port, Utils::ntoh(in4->sin_port));
err = pico_socket_bind(conn->picosock, &zaddr, (uint16_t *)&(in4->sin_port));
#elif defined(SDK_IPV6)
struct pico_ip6 zaddr;
struct sockaddr_in6 *in6 = (struct sockaddr_in6*)addr;
@@ -528,11 +521,12 @@ namespace ZeroTier {
Connection *new_conn = conn->_AcceptedConnections.front();
conn->_AcceptedConnections.pop();
err = new_conn->app_fd;
DEBUG_INFO("wrapping new_conn->app_fd = %d", new_conn->app_fd);
}
return err;
}
void picoTCP::pico_Read(SocketTap *tap, PhySocket *sock, void **uptr, bool stack_invoked)
void picoTCP::pico_Read(SocketTap *tap, PhySocket *sock, Connection* conn, bool stack_invoked)
{
DEBUG_INFO();
if(!stack_invoked) {
@@ -542,9 +536,10 @@ namespace ZeroTier {
}
int tot = 0, n = -1, write_attempts = 0;
Connection *conn = (Connection*)uptr;
if(conn && conn->rxsz) {
//Connection *conn = (Connection*)uptr;
if(conn && conn->rxsz) {
DEBUG_INFO("conn = %p", conn);
//
if(conn->socket_type==SOCK_DGRAM) {
// Try to write ZT_SDK_MTU-sized chunk to app socket
@@ -552,7 +547,7 @@ namespace ZeroTier {
write_attempts++;
n = tap->_phy.streamSend(conn->sock, (conn->rxbuf)+tot, ZT_SDK_MTU);
tot += n;
DEBUG_FLOW(" [ ZTSOCK <- RXBUF] wrote = %d, errno=%d", n, errno);
DEBUG_FLOW("[ ZTSOCK <- RXBUF] wrote = %d, errno=%d", n, errno);
// If socket is unavailable, attempt to write N times before giving up
if(errno==35) {
if(write_attempts == 1024) {
@@ -566,19 +561,17 @@ namespace ZeroTier {
struct sockaddr_storage addr;
memcpy(&addr, conn->rxbuf, addr_sz_offset);
// adjust buffer
//DEBUG_FLOW(" [ ZTSOCK <- RXBUF] Copying data from receiving buffer to ZT-controlled app socket (n=%d, payload_sz=%d)", n, payload_sz);
if(conn->rxsz-n > 0) { // If more remains on buffer
memcpy(conn->rxbuf, conn->rxbuf+ZT_SDK_MTU, conn->rxsz - ZT_SDK_MTU);
//DEBUG_FLOW(" [ ZTSOCK <- RXBUF] Data(%d) still on buffer, moving it up by one MTU", conn->rxsz-n);
////memset(conn->rxbuf, 0, ZT_UDP_RX_BUF_SZ);
////conn->rxsz=ZT_SDK_MTU;
}
conn->rxsz -= ZT_SDK_MTU;
}
//
if(conn->socket_type==SOCK_STREAM) {
DEBUG_TRANS("writing to conn->sock = %p", conn->sock);
DEBUG_INFO("writing to conn->sock = %p, conn->sdk_fd=%d, conn->app_fd=%d", conn->sock, conn->sdk_fd, conn->app_fd);
n = tap->_phy.streamSend(conn->sock, conn->rxbuf, conn->rxsz);
// FIXME: Revisit the idea of writing directly to the app socketpair instead of using Phy I/O
// n = write(conn->sdk_fd, conn->rxbuf, conn->rxsz);
if(conn->rxsz-n > 0) // If more remains on buffer
memcpy(conn->rxbuf, conn->rxbuf+n, conn->rxsz - n);
conn->rxsz -= n;
@@ -586,10 +579,9 @@ namespace ZeroTier {
// Notify ZT I/O loop that it has new buffer contents
if(n) {
if(conn->socket_type==SOCK_STREAM) {
#if DEBUG_LEVEL >= MSG_TRANSFER
float max = conn->socket_type == SOCK_STREAM ? (float)ZT_TCP_RX_BUF_SZ : (float)ZT_UDP_RX_BUF_SZ;
DEBUG_TRANS("[TCP RX] <--- :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
DEBUG_TRANS("[ TCP RX <- STACK] :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
(float)conn->txsz / max, (float)conn->rxsz / max, conn->sock, n);
#endif
}
@@ -608,8 +600,7 @@ namespace ZeroTier {
tap->_tcpconns_m.unlock();
tap->_rx_buf_m.unlock();
}
// FIXME: Re-write debug traces
DEBUG_FLOW(" [ ZTSOCK <- RXBUF] Emitted (%d) from RXBUF(%d) to socket", tot, conn->rxsz);
DEBUG_FLOW("[ ZTSOCK <- RXBUF] Emitted (%d) from RXBUF(%d) to socket", tot, conn->rxsz);
}
void picoTCP::pico_Write(Connection *conn)
@@ -632,12 +623,12 @@ namespace ZeroTier {
if(conn->socket_type == SOCK_STREAM) {
max = ZT_TCP_TX_BUF_SZ;
DEBUG_TRANS("[TCP TX] ---> :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
DEBUG_TRANS("[ TCP TX -> STACK] :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
(float)conn->txsz / (float)max, (float)conn->rxsz / max, conn->sock, r);
}
if(conn->socket_type == SOCK_DGRAM) {
max = ZT_UDP_TX_BUF_SZ;
DEBUG_TRANS("[UDP TX] ---> :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
DEBUG_TRANS("[ UDP TX -> STACK] :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
(float)conn->txsz / (float)max, (float)conn->rxsz / max, conn->sock, r);
}
}

12
src/picoTCP.hpp
View File

@@ -62,6 +62,16 @@
namespace ZeroTier
{
/*
* Send raw frames from the stack to the ZeroTier virtual wire
*/
int pico_eth_send(struct pico_device *dev, void *buf, int len);
/*
* Read raw frames from RX frame buffer into the stack
*/
int pico_eth_poll(struct pico_device *dev, int loop_score);
class SocketTap;
struct Connection;
@@ -127,7 +137,7 @@ namespace ZeroTier
/*
* Read from RX buffer to application - Called from SocketTap
*/
void pico_Read(SocketTap *tap, ZeroTier::PhySocket *sock,void **uptr,bool stack_invoked);
void pico_Read(SocketTap *tap, ZeroTier::PhySocket *sock,Connection *conn,bool stack_invoked);
/*
* Write to userspace network stack - Called from SocketTap

554
test/unit/a.cpp
View File

@@ -1,554 +0,0 @@
// Comprehensive stress test for socket-like API
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <arpa/inet.h>
#include <string.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include "ZeroTierSDK.h"
#define PASSED 0
#define FAILED -1
std::string str = "welcome to the machine";
// [] random
// [OK] simple client ipv4
// [OK] simple server ipv4
// [?] simple client ipv6
// [?] simple server ipv6
// [OK] sustained client ipv4
// [OK] sustained server ipv4
// [?] sustained client ipv6
// [?] sustained server ipv6
// [] comprehensive client ipv4
// [] comprehensive server ipv6
// ---
// comprehensive client addr port
// comprehensive server port
// simple [4|6] client addr port
// simple [4|6] server port
/****************************************************************************/
/* SIMPLE CLIENT */
/****************************************************************************/
//
int ipv4_tcp_client_test(char *path, char *nwid, struct sockaddr_in *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
//
int ipv6_tcp_client_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
/****************************************************************************/
/* SIMPLE SERVER */
/****************************************************************************/
//
int ipv4_tcp_server_test(char *path, char *nwid, struct sockaddr_in *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_bind(sockfd, (struct sockaddr *)addr, sizeof(struct sockaddr_in)) < 0)) {
printf("error binding to interface (%d)\n", err);
exit(0);
}
if((err = zts_listen(sockfd, 1)) < 0) {
printf("error placing socket in LISTENING state (%d)\n", err);
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
//
int ipv6_tcp_server_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_bind(sockfd, (struct sockaddr *)addr, sizeof(struct sockaddr_in6)) < 0)) {
printf("error binding to interface (%d)\n", err);
exit(0);
}
if((err = zts_listen(sockfd, 1)) < 0) {
printf("error placing socket in LISTENING state (%d)\n", err);
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
/****************************************************************************/
/* SUSTAINED CLIENT */
/****************************************************************************/
// Maintain transfer for n_seconds OR n_times
int ipv4_tcp_client_sustained_test(char *path, char *nwid, struct sockaddr_in *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
int wrote = 0;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
if(n_seconds) {
/*
printf("testing for (%d) seconds\n", n_seconds);
int wrote;
for(int i=0; i<n_seconds; i++) {
wrote = zts_write(sockfd, str.c_str(), str.length());
printf("wrote = %d\n", wrote);
}
*/
}
if(n_times) {
printf("testing (%d) times\n", n_seconds);
for(int i=0; i<n_times; i++) {
wrote += zts_write(sockfd, str.c_str(), str.length());
printf("[%d] wrote = %d\n", i, wrote);
}
}
err = zts_close(sockfd);
return (wrote == (str.length()*n_times) && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
// Maintain transfer for n_seconds OR n_times
int ipv6_tcp_client_sustained_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
int wrote = 0;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
if(n_seconds) {
/*
printf("testing for (%d) seconds\n", n_seconds);
int wrote;
for(int i=0; i<n_seconds; i++) {
wrote = zts_write(sockfd, str.c_str(), str.length());
printf("wrote = %d\n", wrote);
}
*/
}
if(n_times) {
printf("testing (%d) times\n", n_seconds);
for(int i=0; i<n_times; i++) {
wrote += zts_write(sockfd, str.c_str(), str.length());
printf("[%d] wrote = %d\n", i, wrote);
}
}
err = zts_close(sockfd);
return (wrote == (str.length()*n_times) && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
/****************************************************************************/
/* SUSTAINED SERVER */
/****************************************************************************/
// Maintain transfer for n_seconds OR n_times
int ipv4_tcp_server_sustained_test(char *path, char *nwid, struct sockaddr_in *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
int wrote = 0;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_bind(sockfd, (struct sockaddr *)addr, (socklen_t)sizeof(struct sockaddr_in)) < 0)) {
printf("error binding to interface (%d)\n", err);
exit(0);
}
if((err = zts_listen(sockfd, 1)) < 0) {
printf("error placing socket in LISTENING state (%d)\n", err);
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
if(n_seconds) {
/*
printf("testing for (%d) seconds\n", n_seconds);
int wrote;
for(int i=0; i<n_seconds; i++) {
wrote = zts_write(sockfd, str.c_str(), str.length());
printf("wrote = %d\n", wrote);
}
*/
}
if(n_times) {
printf("testing (%d) times\n", n_seconds);
for(int i=0; i<n_times; i++) {
wrote += zts_write(sockfd, str.c_str(), str.length());
printf("[%d] wrote = %d\n", i, wrote);
}
}
err = zts_close(sockfd);
return (wrote == (str.length()*n_times) && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
// Maintain transfer for n_seconds OR n_times
int ipv6_tcp_server_sustained_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
int wrote = 0;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_bind(sockfd, (struct sockaddr *)addr, (socklen_t)sizeof(struct sockaddr_in6)) < 0)) {
printf("error binding to interface (%d)\n", err);
exit(0);
}
if((err = zts_listen(sockfd, 1)) < 0) {
printf("error placing socket in LISTENING state (%d)\n", err);
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
if(n_seconds) {
/*
printf("testing for (%d) seconds\n", n_seconds);
int wrote;
for(int i=0; i<n_seconds; i++) {
wrote = zts_write(sockfd, str.c_str(), str.length());
printf("wrote = %d\n", wrote);
}
*/
}
if(n_times) {
printf("testing (%d) times\n", n_seconds);
for(int i=0; i<n_times; i++) {
wrote += zts_write(sockfd, str.c_str(), str.length());
printf("[%d] wrote = %d\n", i, wrote);
}
}
err = zts_close(sockfd);
return (wrote == (str.length()*n_times) && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
/****************************************************************************/
/* main */
/****************************************************************************/
int main(int argc , char *argv[])
{
if(argc < 3) {
printf("invalid arguments\n");
return 1;
}
int port;
struct hostent *server;
std::string protocol;
std::string mode;
struct sockaddr_in6 addr6;
struct sockaddr_in addr;
char *path = (char*)"./zt";
int n_seconds = 10;
int n_times = 10000;
std::string nwid = argv[1]; // "ebcd7a7e120f4492"
std::string type = argv[2]; // simple, sustained, comprehensive
// If we're performing a non-random test, join the network we want to test on
// and wait until the service initializes the SocketTap and provides an address
if(type == "simple" || type == "sustained" || type == "comprehensive") {
zts_start(path);
while(!zts_service_running())
sleep(1);
zts_join_network(nwid.c_str());
while(!zts_has_address(nwid.c_str()))
sleep(1);
}
/****************************************************************************/
/* SIMPLE */
/****************************************************************************/
// SIMPLE
// performs a one-off test of a particular subset of the API
// For instance (ipv4 client, ipv6 server, etc)
if(type == "simple")
{
protocol = argv[3]; // 4, 6
mode = argv[4]; // client, server
// SIMPLE CLIENT
if(mode == "client")
{
port = atoi(argv[6]);
printf("connecting to %s on port %s\n", argv[5], argv[6]);
// IPv4
if(protocol == "4") {
addr.sin_addr.s_addr = inet_addr(argv[5]);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_client_test(path, (char*)nwid.c_str(), &addr, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
addr6.sin6_port = htons(port);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_client_test(path, (char*)nwid.c_str(), &addr6, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
}
// SIMPLE SERVER
if(mode == "server")
{
port = atoi(argv[5]);
printf("serving on port %s\n", argv[6]);
// IPv4
if(protocol == "4") {
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr("10.9.9.40");
// addr.sin_addr.s_addr = htons(INADDR_ANY);
addr.sin_family = AF_INET;
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_server_test(path, (char*)nwid.c_str(), &addr, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
addr6.sin6_port = htons(port);
addr6.sin6_addr = in6addr_any;
//memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_server_test(path, (char*)nwid.c_str(), &addr6, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
}
}
/****************************************************************************/
/* SUSTAINED */
/****************************************************************************/
// SUSTAINED
// Performs a stress test for benchmarking performance
if(type == "sustained")
{
protocol = argv[3]; // 4, 6
mode = argv[4]; // client, server
// SUSTAINED CLIENT
if(mode == "client")
{
port = atoi(argv[6]);
printf("connecting to %s on port %s\n", argv[5], argv[6]);
// IPv4
if(protocol == "4") {
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(argv[5]);
addr.sin_family = AF_INET;
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_client_sustained_test(path, (char*)nwid.c_str(), &addr, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
addr6.sin6_port = htons(port);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_client_sustained_test(path, (char*)nwid.c_str(), &addr6, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
}
// SUSTAINED SERVER
if(mode == "server")
{
port = atoi(argv[5]);
printf("serving on port %s\n", argv[6]);
// IPv4
if(protocol == "4") {
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr("10.9.9.0");
// addr.sin_addr.s_addr = htons(INADDR_ANY);
addr.sin_family = AF_INET;
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_server_sustained_test(path, (char*)nwid.c_str(), &addr, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
addr6.sin6_port = htons(port);
addr6.sin6_addr = in6addr_any;
//memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_server_sustained_test(path, (char*)nwid.c_str(), &addr6, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
}
}
/****************************************************************************/
/* COMPREHENSIVE */
/****************************************************************************/
// COMPREHENSIVE
// Tests ALL API calls
if(type == "comprehensive")
{
}
/****************************************************************************/
/* RANDOM */
/****************************************************************************/
// RANDOM
// performs random API calls with plausible (and random) arguments/data
if(type == "random")
{
}
printf("invalid configuration. exiting.\n");
return 0;
}

554
test/unit/b.cpp
View File

@@ -1,554 +0,0 @@
// Comprehensive stress test for socket-like API
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <arpa/inet.h>
#include <string.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include "ZeroTierSDK.h"
#define PASSED 0
#define FAILED -1
std::string str = "welcome to the machine";
// [] random
// [OK] simple client ipv4
// [OK] simple server ipv4
// [?] simple client ipv6
// [?] simple server ipv6
// [OK] sustained client ipv4
// [OK] sustained server ipv4
// [?] sustained client ipv6
// [?] sustained server ipv6
// [] comprehensive client ipv4
// [] comprehensive server ipv6
// ---
// comprehensive client addr port
// comprehensive server port
// simple [4|6] client addr port
// simple [4|6] server port
/****************************************************************************/
/* SIMPLE CLIENT */
/****************************************************************************/
//
int ipv4_tcp_client_test(char *path, char *nwid, struct sockaddr_in *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
//
int ipv6_tcp_client_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
/****************************************************************************/
/* SIMPLE SERVER */
/****************************************************************************/
//
int ipv4_tcp_server_test(char *path, char *nwid, struct sockaddr_in *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_bind(sockfd, (struct sockaddr *)addr, sizeof(struct sockaddr_in)) < 0)) {
printf("error binding to interface (%d)\n", err);
exit(0);
}
if((err = zts_listen(sockfd, 1)) < 0) {
printf("error placing socket in LISTENING state (%d)\n", err);
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
//
int ipv6_tcp_server_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_bind(sockfd, (struct sockaddr *)addr, sizeof(struct sockaddr_in6)) < 0)) {
printf("error binding to interface (%d)\n", err);
exit(0);
}
if((err = zts_listen(sockfd, 1)) < 0) {
printf("error placing socket in LISTENING state (%d)\n", err);
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
/****************************************************************************/
/* SUSTAINED CLIENT */
/****************************************************************************/
// Maintain transfer for n_seconds OR n_times
int ipv4_tcp_client_sustained_test(char *path, char *nwid, struct sockaddr_in *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
int wrote = 0;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
if(n_seconds) {
/*
printf("testing for (%d) seconds\n", n_seconds);
int wrote;
for(int i=0; i<n_seconds; i++) {
wrote = zts_write(sockfd, str.c_str(), str.length());
printf("wrote = %d\n", wrote);
}
*/
}
if(n_times) {
printf("testing (%d) times\n", n_seconds);
for(int i=0; i<n_times; i++) {
wrote += zts_write(sockfd, str.c_str(), str.length());
printf("[%d] wrote = %d\n", i, wrote);
}
}
err = zts_close(sockfd);
return (wrote == (str.length()*n_times) && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
// Maintain transfer for n_seconds OR n_times
int ipv6_tcp_client_sustained_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
int wrote = 0;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
if(n_seconds) {
/*
printf("testing for (%d) seconds\n", n_seconds);
int wrote;
for(int i=0; i<n_seconds; i++) {
wrote = zts_write(sockfd, str.c_str(), str.length());
printf("wrote = %d\n", wrote);
}
*/
}
if(n_times) {
printf("testing (%d) times\n", n_seconds);
for(int i=0; i<n_times; i++) {
wrote += zts_write(sockfd, str.c_str(), str.length());
printf("[%d] wrote = %d\n", i, wrote);
}
}
err = zts_close(sockfd);
return (wrote == (str.length()*n_times) && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
/****************************************************************************/
/* SUSTAINED SERVER */
/****************************************************************************/
// Maintain transfer for n_seconds OR n_times
int ipv4_tcp_server_sustained_test(char *path, char *nwid, struct sockaddr_in *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
int wrote = 0;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_bind(sockfd, (struct sockaddr *)addr, (socklen_t)sizeof(struct sockaddr_in)) < 0)) {
printf("error binding to interface (%d)\n", err);
exit(0);
}
if((err = zts_listen(sockfd, 1)) < 0) {
printf("error placing socket in LISTENING state (%d)\n", err);
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
if(n_seconds) {
/*
printf("testing for (%d) seconds\n", n_seconds);
int wrote;
for(int i=0; i<n_seconds; i++) {
wrote = zts_write(sockfd, str.c_str(), str.length());
printf("wrote = %d\n", wrote);
}
*/
}
if(n_times) {
printf("testing (%d) times\n", n_seconds);
for(int i=0; i<n_times; i++) {
wrote += zts_write(sockfd, str.c_str(), str.length());
printf("[%d] wrote = %d\n", i, wrote);
}
}
err = zts_close(sockfd);
return (wrote == (str.length()*n_times) && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
// Maintain transfer for n_seconds OR n_times
int ipv6_tcp_server_sustained_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
int wrote = 0;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error creating ZeroTier socket");
exit(0);
}
if((err = zts_bind(sockfd, (struct sockaddr *)addr, (socklen_t)sizeof(struct sockaddr_in6)) < 0)) {
printf("error binding to interface (%d)\n", err);
exit(0);
}
if((err = zts_listen(sockfd, 1)) < 0) {
printf("error placing socket in LISTENING state (%d)\n", err);
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
if(n_seconds) {
/*
printf("testing for (%d) seconds\n", n_seconds);
int wrote;
for(int i=0; i<n_seconds; i++) {
wrote = zts_write(sockfd, str.c_str(), str.length());
printf("wrote = %d\n", wrote);
}
*/
}
if(n_times) {
printf("testing (%d) times\n", n_seconds);
for(int i=0; i<n_times; i++) {
wrote += zts_write(sockfd, str.c_str(), str.length());
printf("[%d] wrote = %d\n", i, wrote);
}
}
err = zts_close(sockfd);
return (wrote == (str.length()*n_times) && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
/****************************************************************************/
/* main */
/****************************************************************************/
int main(int argc , char *argv[])
{
if(argc < 3) {
printf("invalid arguments\n");
return 1;
}
int port;
struct hostent *server;
std::string protocol;
std::string mode;
struct sockaddr_in6 addr6;
struct sockaddr_in addr;
char *path = (char*)"./zt";
int n_seconds = 10;
int n_times = 10000;
std::string nwid = argv[1]; // "ebcd7a7e120f4492"
std::string type = argv[2]; // simple, sustained, comprehensive
// If we're performing a non-random test, join the network we want to test on
// and wait until the service initializes the SocketTap and provides an address
if(type == "simple" || type == "sustained" || type == "comprehensive") {
zts_start(path);
while(!zts_service_running())
sleep(1);
zts_join_network(nwid.c_str());
while(!zts_has_address(nwid.c_str()))
sleep(1);
}
/****************************************************************************/
/* SIMPLE */
/****************************************************************************/
// SIMPLE
// performs a one-off test of a particular subset of the API
// For instance (ipv4 client, ipv6 server, etc)
if(type == "simple")
{
protocol = argv[3]; // 4, 6
mode = argv[4]; // client, server
// SIMPLE CLIENT
if(mode == "client")
{
port = atoi(argv[6]);
printf("connecting to %s on port %s\n", argv[5], argv[6]);
// IPv4
if(protocol == "4") {
addr.sin_addr.s_addr = inet_addr(argv[5]);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_client_test(path, (char*)nwid.c_str(), &addr, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
addr6.sin6_port = htons(port);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_client_test(path, (char*)nwid.c_str(), &addr6, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
}
// SIMPLE SERVER
if(mode == "server")
{
port = atoi(argv[5]);
printf("serving on port %s\n", argv[6]);
// IPv4
if(protocol == "4") {
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr("10.9.9.40");
// addr.sin_addr.s_addr = htons(INADDR_ANY);
addr.sin_family = AF_INET;
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_server_test(path, (char*)nwid.c_str(), &addr, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
addr6.sin6_port = htons(port);
addr6.sin6_addr = in6addr_any;
//memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_server_test(path, (char*)nwid.c_str(), &addr6, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
}
}
/****************************************************************************/
/* SUSTAINED */
/****************************************************************************/
// SUSTAINED
// Performs a stress test for benchmarking performance
if(type == "sustained")
{
protocol = argv[3]; // 4, 6
mode = argv[4]; // client, server
// SUSTAINED CLIENT
if(mode == "client")
{
port = atoi(argv[6]);
printf("connecting to %s on port %s\n", argv[5], argv[6]);
// IPv4
if(protocol == "4") {
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(argv[5]);
addr.sin_family = AF_INET;
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_client_sustained_test(path, (char*)nwid.c_str(), &addr, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
addr6.sin6_port = htons(port);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_client_sustained_test(path, (char*)nwid.c_str(), &addr6, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
}
// SUSTAINED SERVER
if(mode == "server")
{
port = atoi(argv[5]);
printf("serving on port %s\n", argv[6]);
// IPv4
if(protocol == "4") {
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr("10.9.9.0");
// addr.sin_addr.s_addr = htons(INADDR_ANY);
addr.sin_family = AF_INET;
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_server_sustained_test(path, (char*)nwid.c_str(), &addr, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
addr6.sin6_port = htons(port);
addr6.sin6_addr = in6addr_any;
//memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_server_sustained_test(path, (char*)nwid.c_str(), &addr6, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
return 0;
}
}
}
/****************************************************************************/
/* COMPREHENSIVE */
/****************************************************************************/
// COMPREHENSIVE
// Tests ALL API calls
if(type == "comprehensive")
{
}
/****************************************************************************/
/* RANDOM */
/****************************************************************************/
// RANDOM
// performs random API calls with plausible (and random) arguments/data
if(type == "random")
{
}
printf("invalid configuration. exiting.\n");
return 0;
}

106
test/unit/comprehensive.cpp
View File

@@ -42,7 +42,7 @@ std::string str = "welcome to the machine";
/****************************************************************************/
//
int ipv4_tcp_client_test(char *path, char *nwid, struct sockaddr_in *addr, int port)
int ipv4_tcp_client_test(struct sockaddr_in *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
@@ -53,13 +53,16 @@ int ipv4_tcp_client_test(char *path, char *nwid, struct sockaddr_in *addr, int p
printf("error connecting to remote host (%d)\n", err);
exit(0);
}
printf("sleeping... before writing to fd = %d\n", sockfd);
int wrote = zts_write(sockfd, str.c_str(), str.length());
while(1)
sleep(1);
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
}
//
int ipv6_tcp_client_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port)
int ipv6_tcp_client_test(struct sockaddr_in6 *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
@@ -83,7 +86,7 @@ int ipv6_tcp_client_test(char *path, char *nwid, struct sockaddr_in6 *addr, int
/****************************************************************************/
//
int ipv4_tcp_server_test(char *path, char *nwid, struct sockaddr_in *addr, int port)
int ipv4_tcp_server_test(struct sockaddr_in *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
@@ -94,22 +97,27 @@ int ipv4_tcp_server_test(char *path, char *nwid, struct sockaddr_in *addr, int p
printf("error binding to interface (%d)\n", err);
exit(0);
}
if((err = zts_listen(sockfd, 1)) < 0) {
if((err = zts_listen(sockfd, 100)) < 0) {
printf("error placing socket in LISTENING state (%d)\n", err);
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
int wrote = zts_write(sockfd, str.c_str(), str.length());
err = zts_close(sockfd);
return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
sleep(3);
printf("accept fd = %d\n", err);
char buf[32];
int read = zts_read(err, buf, sizeof buf);
printf("buf = %s\n", buf);
err = zts_close(err);
//return (wrote == str.length() && !err) ? PASSED : FAILED; // if wrote correct number of bytes
return err;
}
//
int ipv6_tcp_server_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port)
int ipv6_tcp_server_test(struct sockaddr_in6 *addr, int port)
{
int sockfd, err;
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
@@ -125,7 +133,7 @@ int ipv6_tcp_server_test(char *path, char *nwid, struct sockaddr_in6 *addr, int
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
@@ -143,7 +151,7 @@ int ipv6_tcp_server_test(char *path, char *nwid, struct sockaddr_in6 *addr, int
/****************************************************************************/
// Maintain transfer for n_seconds OR n_times
int ipv4_tcp_client_sustained_test(char *path, char *nwid, struct sockaddr_in *addr, int port, int n_seconds, int n_times)
int ipv4_tcp_client_sustained_test(struct sockaddr_in *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
@@ -178,7 +186,7 @@ int ipv4_tcp_client_sustained_test(char *path, char *nwid, struct sockaddr_in *a
}
// Maintain transfer for n_seconds OR n_times
int ipv6_tcp_client_sustained_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port, int n_seconds, int n_times)
int ipv6_tcp_client_sustained_test(struct sockaddr_in6 *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
@@ -221,7 +229,7 @@ int ipv6_tcp_client_sustained_test(char *path, char *nwid, struct sockaddr_in6 *
/****************************************************************************/
// Maintain transfer for n_seconds OR n_times
int ipv4_tcp_server_sustained_test(char *path, char *nwid, struct sockaddr_in *addr, int port, int n_seconds, int n_times)
int ipv4_tcp_server_sustained_test(struct sockaddr_in *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
@@ -239,7 +247,7 @@ int ipv4_tcp_server_sustained_test(char *path, char *nwid, struct sockaddr_in *a
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
@@ -265,7 +273,7 @@ int ipv4_tcp_server_sustained_test(char *path, char *nwid, struct sockaddr_in *a
}
// Maintain transfer for n_seconds OR n_times
int ipv6_tcp_server_sustained_test(char *path, char *nwid, struct sockaddr_in6 *addr, int port, int n_seconds, int n_times)
int ipv6_tcp_server_sustained_test(struct sockaddr_in6 *addr, int port, int n_seconds, int n_times)
{
int sockfd, err;
int msg_len = str.length();
@@ -283,7 +291,7 @@ int ipv6_tcp_server_sustained_test(char *path, char *nwid, struct sockaddr_in6 *
exit(0);
}
// TODO: handle new address
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr)) < 0)) {
if((err = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0) {
printf("error accepting connection (%d)\n", err);
exit(0);
}
@@ -329,18 +337,18 @@ int main(int argc , char *argv[])
std::string mode;
struct sockaddr_in6 addr6;
struct sockaddr_in addr;
char *path = (char*)"./zt";
int n_seconds = 10;
int n_times = 10000;
std::string nwid = argv[1]; // "ebcd7a7e120f4492"
std::string type = argv[2]; // simple, sustained, comprehensive
std::string path = argv[1]; // where ZeroTier conf files and keys are stored
std::string nwid = argv[2]; // "ebcd7a7e120f4492"
std::string type = argv[3]; // simple, sustained, comprehensive
// If we're performing a non-random test, join the network we want to test on
// and wait until the service initializes the SocketTap and provides an address
if(type == "simple" || type == "sustained" || type == "comprehensive") {
zts_start(path);
zts_start(path.c_str());
while(!zts_service_running())
sleep(1);
zts_join_network(nwid.c_str());
@@ -357,38 +365,40 @@ int main(int argc , char *argv[])
// For instance (ipv4 client, ipv6 server, etc)
if(type == "simple")
{
protocol = argv[3]; // 4, 6
mode = argv[4]; // client, server
protocol = argv[4]; // 4, 6
mode = argv[5]; // client, server
// SIMPLE CLIENT
if(mode == "client")
{
port = atoi(argv[6]);
printf("connecting to %s on port %s\n", argv[5], argv[6]);
port = atoi(argv[7]);
printf("connecting to %s on port %s\n", argv[6], argv[7]);
// IPv4
if(protocol == "4") {
addr.sin_addr.s_addr = inet_addr(argv[5]);
addr.sin_addr.s_addr = inet_addr(argv[6]);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_client_test(path, (char*)nwid.c_str(), &addr, port) == PASSED)
if(ipv4_tcp_client_test(&addr, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
while(1)
sleep(1);
return 0;
}
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
server = gethostbyname2(argv[6],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
addr6.sin6_port = htons(port);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_client_test(path, (char*)nwid.c_str(), &addr6, port) == PASSED)
if(ipv6_tcp_client_test(&addr6, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
@@ -399,17 +409,17 @@ int main(int argc , char *argv[])
// SIMPLE SERVER
if(mode == "server")
{
port = atoi(argv[5]);
printf("serving on port %s\n", argv[6]);
port = atoi(argv[7]);
printf("serving on port %s\n", argv[7]);
// IPv4
if(protocol == "4") {
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr("10.9.9.40");
addr.sin_addr.s_addr = inet_addr(argv[6]);
// addr.sin_addr.s_addr = htons(INADDR_ANY);
addr.sin_family = AF_INET;
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_server_test(path, (char*)nwid.c_str(), &addr, port) == PASSED)
if(ipv4_tcp_server_test(&addr, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
@@ -418,7 +428,7 @@ int main(int argc , char *argv[])
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
server = gethostbyname2(argv[6],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
@@ -428,7 +438,7 @@ int main(int argc , char *argv[])
//memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_server_test(path, (char*)nwid.c_str(), &addr6, port) == PASSED)
if(ipv6_tcp_server_test(&addr6, port) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
@@ -445,22 +455,22 @@ int main(int argc , char *argv[])
// Performs a stress test for benchmarking performance
if(type == "sustained")
{
protocol = argv[3]; // 4, 6
mode = argv[4]; // client, server
protocol = argv[4]; // 4, 6
mode = argv[5]; // client, server
// SUSTAINED CLIENT
if(mode == "client")
{
port = atoi(argv[6]);
printf("connecting to %s on port %s\n", argv[5], argv[6]);
port = atoi(argv[7]);
printf("connecting to %s on port %s\n", argv[6], argv[7]);
// IPv4
if(protocol == "4") {
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(argv[5]);
addr.sin_addr.s_addr = inet_addr(argv[6]);
addr.sin_family = AF_INET;
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_client_sustained_test(path, (char*)nwid.c_str(), &addr, port, n_seconds, n_times) == PASSED)
if(ipv4_tcp_client_sustained_test(&addr, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
@@ -469,14 +479,14 @@ int main(int argc , char *argv[])
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
server = gethostbyname2(argv[6],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
addr6.sin6_port = htons(port);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_client_sustained_test(path, (char*)nwid.c_str(), &addr6, port, n_seconds, n_times) == PASSED)
if(ipv6_tcp_client_sustained_test(&addr6, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
@@ -487,17 +497,17 @@ int main(int argc , char *argv[])
// SUSTAINED SERVER
if(mode == "server")
{
port = atoi(argv[5]);
printf("serving on port %s\n", argv[6]);
port = atoi(argv[7]);
printf("serving on port %s\n", argv[7]);
// IPv4
if(protocol == "4") {
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr("10.9.9.0");
addr.sin_addr.s_addr = inet_addr(argv[6]);
// addr.sin_addr.s_addr = htons(INADDR_ANY);
addr.sin_family = AF_INET;
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv4_tcp_server_sustained_test(path, (char*)nwid.c_str(), &addr, port, n_seconds, n_times) == PASSED)
if(ipv4_tcp_server_sustained_test(&addr, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");
@@ -506,7 +516,7 @@ int main(int argc , char *argv[])
// IPv6
if(protocol == "6") {
server = gethostbyname2(argv[1],AF_INET6);
server = gethostbyname2(argv[6],AF_INET6);
memset((char *) &addr6, 0, sizeof(addr6));
addr6.sin6_flowinfo = 0;
addr6.sin6_family = AF_INET6;
@@ -516,7 +526,7 @@ int main(int argc , char *argv[])
//memmove((char *) &addr6.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
printf(" running (%s) test as ipv=%s\n", mode.c_str(), protocol.c_str());
if(ipv6_tcp_server_sustained_test(path, (char*)nwid.c_str(), &addr6, port, n_seconds, n_times) == PASSED)
if(ipv6_tcp_server_sustained_test(&addr6, port, n_seconds, n_times) == PASSED)
printf("PASSED\n");
else
printf("FAILED\n");

6
zto/service/OneService.cpp
View File

@@ -1003,14 +1003,10 @@ public:
Mutex::Lock _l(_nets_m);
std::map<uint64_t,NetworkState>::iterator it;
for(it = _nets.begin(); it != _nets.end(); it++) {
printf("TEEEESTING....\n");
if(it->second.tap) {
printf("\tips = %d\n", it->second.tap->_ips.size());
for(int j=0; j<it->second.tap->_ips.size(); j++) {
printf("\tTESTING: %s\n", it->second.tap->_ips[j].toString().c_str());
printf("\t\tdoesn't contain: %s\n", addr.toString().c_str());
printf("\tChecking IP: %s\n", it->second.tap->_ips[j].toString().c_str());
if(it->second.tap->_ips[j].containsAddress(addr)) {
return it->second.tap;
}
}