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

Added basic DNS functionality, fixed stack smashing bug, organizational improvements

Browse Source
This commit is contained in:
Joseph Henry
2017-08-30 14:13:13 -07:00
parent be1d7082e9
commit ec323c9842
11 changed files with 599 additions and 396 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
examples/node/binding.cc
View File

@@ -23,8 +23,8 @@ struct ZT {
} }
static char* getIpV4Address(const char *nwid) { static char* getIpV4Address(const char *nwid) {
char* addr_str = new char [ZT_MAX_IPADDR_LEN]; char* addr_str = new char [INET_ADDRSTRLEN];
zts_get_ipv4_address(nwid, addr_str, ZT_MAX_IPADDR_LEN); zts_get_ipv4_address(nwid, addr_str, INET_ADDRSTRLEN);
return addr_str; return addr_str;
} }

6
ext/picotcp/modules/pico_dns_client.h
View File

@@ -37,6 +37,9 @@
#define PICO_DNS_RR_A_RDLENGTH 4 #define PICO_DNS_RR_A_RDLENGTH 4
#define PICO_DNS_RR_AAAA_RDLENGTH 16 #define PICO_DNS_RR_AAAA_RDLENGTH 16
#ifdef __cplusplus
extern "C" {
#endif
int pico_dns_client_init(void); int pico_dns_client_init(void);
/* flag is PICO_DNS_NS_DEL or PICO_DNS_NS_ADD */ /* flag is PICO_DNS_NS_DEL or PICO_DNS_NS_ADD */
int pico_dns_client_nameserver(struct pico_ip4 *ns, uint8_t flag); int pico_dns_client_nameserver(struct pico_ip4 *ns, uint8_t flag);
@@ -46,5 +49,8 @@ int pico_dns_client_getname(const char *ip, void (*callback)(char *url, void *ar
int pico_dns_client_getaddr6(const char *url, void (*callback)(char *, void *), void *arg); int pico_dns_client_getaddr6(const char *url, void (*callback)(char *, void *), void *arg);
int pico_dns_client_getname6(const char *url, void (*callback)(char *, void *), void *arg); int pico_dns_client_getname6(const char *url, void (*callback)(char *, void *), void *arg);
#endif #endif
#ifdef __cplusplus
}
#endif
#endif /* _INCLUDE_PICO_DNS_CLIENT */ #endif /* _INCLUDE_PICO_DNS_CLIENT */

12
include/libzt.h
View File

@@ -97,6 +97,11 @@ struct zts_ifreq {
/****************************************************************************/ /****************************************************************************/
#define ZT_SDK_MTU ZT_MAX_MTU #define ZT_SDK_MTU ZT_MAX_MTU
#define ZT_LEN_SZ 4
#define ZT_ADDR_SZ 128
#define ZT_SOCKET_MSG_BUF_SZ ZT_SDK_MTU + ZT_LEN_SZ + ZT_ADDR_SZ
#define ZT_PHY_POLL_INTERVAL 2 // ms #define ZT_PHY_POLL_INTERVAL 2 // ms
#define ZT_ACCEPT_RECHECK_DELAY 100 // ms (for blocking zts_accept() calls) #define ZT_ACCEPT_RECHECK_DELAY 100 // ms (for blocking zts_accept() calls)
#define ZT_CONNECT_RECHECK_DELAY 100 // ms (for blocking zts_connect() calls) #define ZT_CONNECT_RECHECK_DELAY 100 // ms (for blocking zts_connect() calls)
@@ -130,10 +135,10 @@ struct zts_ifreq {
#define ZT_LIB_VERSION_MINOR 1 #define ZT_LIB_VERSION_MINOR 1
#define ZT_LIB_VERSION_REVISION 4 #define ZT_LIB_VERSION_REVISION 4
#define ZT_MAX_IPADDR_LEN 64 #define ZT_ID_LEN 16
#define ZT_ID_LEN 10
#define ZT_VER_STR_LEN 6 #define ZT_VER_STR_LEN 6
#define ZT_HOME_PATH_MAX_LEN 128 #define ZT_HOME_PATH_MAX_LEN 128
#define ZT_MAC_ADDRSTRLEN 18
#define ZT_SOCK_STATE_NONE 100 #define ZT_SOCK_STATE_NONE 100
#define ZT_SOCK_STATE_UNHANDLED_CONNECTED 101 #define ZT_SOCK_STATE_UNHANDLED_CONNECTED 101
@@ -503,7 +508,7 @@ int zts_add_dns_nameserver(struct sockaddr *addr);
/* /*
* Removes a DNS nameserver * Removes a DNS nameserver
*/ */
int zts_remove_dns_nameserver(struct sockaddr *addr); int zts_del_dns_nameserver(struct sockaddr *addr);
/****************************************************************************/ /****************************************************************************/
/* SDK Socket API Helper functions/objects --- DONT CALL THESE DIRECTLY */ /* SDK Socket API Helper functions/objects --- DONT CALL THESE DIRECTLY */
@@ -558,6 +563,7 @@ ZeroTier::VirtualTap *getTapByNWID(uint64_t nwid);
ZeroTier::VirtualTap *getTapByAddr(ZeroTier::InetAddress *addr); ZeroTier::VirtualTap *getTapByAddr(ZeroTier::InetAddress *addr);
ZeroTier::VirtualTap *getTapByName(char *ifname); ZeroTier::VirtualTap *getTapByName(char *ifname);
ZeroTier::VirtualTap *getTapByIndex(int index); ZeroTier::VirtualTap *getTapByIndex(int index);
ZeroTier::VirtualTap *getAnyTap();
/* /*
* Returns a pointer to a VirtualSocket for a given fd * Returns a pointer to a VirtualSocket for a given fd

6
make-linux.mk
View File

@@ -64,12 +64,16 @@ ifeq ($(ZT_DEBUG),1)
else else
CFLAGS?=-Ofast -g -fstack-protector CFLAGS?=-Ofast -g -fstack-protector
CFLAGS+=-Wall -fPIE -fvisibility=hidden -pthread $(INCLUDES) $(DEFS) CFLAGS+=-Wall -fPIE -fvisibility=hidden -pthread $(INCLUDES) $(DEFS)
#CFLAGS+=$(ARCH_FLAGS) -Wall -flto -fPIC -pthread -mmacosx-version-min=10.7 -DNDEBUG -Wno-unused-private-field $(INCLUDES) $(DEFS)
STRIP=strip STRIP=strip
endif endif
CXXFLAGS=$(CFLAGS) -Wno-format -fno-rtti -std=c++11 -DZT_SOFTWARE_UPDATE_DEFAULT="\"disable\"" CXXFLAGS=$(CFLAGS) -Wno-format -fno-rtti -std=c++11 -DZT_SOFTWARE_UPDATE_DEFAULT="\"disable\""
# Build against address sanitization library for advanced debugging (clang)
ifeq ($(ZT_SANITIZE),1)
CXXFLAGS+=-x c++ -O -g -fsanitize=address -DASAN_OPTIONS=symbolize=1 -DASAN_SYMBOLIZER_PATH=$(shell which llvm-symbolizer)
endif
INCLUDES+= -Iext \ INCLUDES+= -Iext \
-I$(ZTO)/osdep \ -I$(ZTO)/osdep \
-I$(ZTO)/node \ -I$(ZTO)/node \

7
make-mac.mk
View File

@@ -70,6 +70,11 @@ endif
CXXFLAGS=$(CFLAGS) -Wno-format -fno-rtti -std=c++11 -DZT_SOFTWARE_UPDATE_DEFAULT="\"disable\"" CXXFLAGS=$(CFLAGS) -Wno-format -fno-rtti -std=c++11 -DZT_SOFTWARE_UPDATE_DEFAULT="\"disable\""
# Build against address sanitization library for advanced debugging (clang)
ifeq ($(ZT_SANITIZE),1)
CXXFLAGS+=-x c++ -O -g -fsanitize=address -DASAN_OPTIONS=symbolize=1 -DASAN_SYMBOLIZER_PATH=$(shell which llvm-symbolizer)
endif
INCLUDES+= -Iext \ INCLUDES+= -Iext \
-I$(ZTO)/osdep \ -I$(ZTO)/osdep \
-I$(ZTO)/node \ -I$(ZTO)/node \
@@ -209,7 +214,7 @@ static_lib: picotcp $(ZTO_OBJS)
$(CXX) $(CXXFLAGS) $(LIBZT_FILES) $(STACK_DRIVER_FILES) -c $(CXX) $(CXXFLAGS) $(LIBZT_FILES) $(STACK_DRIVER_FILES) -c
mv *.o obj mv *.o obj
#mv ext/picotcp/build/lib/*.o obj #mv ext/picotcp/build/lib/*.o obj
mv ext/picotcp/build/modules/*.o obj #mv ext/picotcp/build/modules/*.o obj
libtool -static -o $(STATIC_LIB) obj/*.o $(STACK_LIB) libtool -static -o $(STATIC_LIB) obj/*.o $(STACK_LIB)
endif endif
ifeq ($(STACK_LWIP),1) ifeq ($(STACK_LWIP),1)

66
src/VirtualTap.cpp
View File

@@ -62,7 +62,7 @@ class VirtualTap;
extern std::vector<void*> vtaps; extern std::vector<void*> vtaps;
static bool picodev_initialized; // static bool picodev_initialized;
namespace ZeroTier { namespace ZeroTier {
@@ -96,12 +96,19 @@ namespace ZeroTier {
_phy(this,false,true) _phy(this,false,true)
{ {
vtaps.push_back((void*)this); vtaps.push_back((void*)this);
// set interface name
char tmp3[64]; // set virtual tap interface name (full)
memset(vtap_full_name, 0, sizeof(vtap_full_name));
ifindex = devno; ifindex = devno;
snprintf(tmp3, 64, "libzt%d-%lx", devno++, _nwid); snprintf(vtap_full_name, sizeof(vtap_full_name), "libzt%d-%lx", devno++, _nwid);
_dev = tmp3; _dev = vtap_full_name;
DEBUG_INFO("set VirtualTap interface name to: %s", _dev.c_str()); DEBUG_INFO("set VirtualTap interface name to: %s", _dev.c_str());
// set virtual tap interface name (abbreviated)
memset(vtap_abbr_name, 0, sizeof(vtap_abbr_name));
snprintf(vtap_abbr_name, sizeof(vtap_abbr_name), "libzt%d", devno);
// start vtap thread and stack I/O loops
_thread = Thread::start(this); _thread = Thread::start(this);
} }
@@ -143,14 +150,14 @@ namespace ZeroTier {
bool VirtualTap::addIp(const InetAddress &ip) bool VirtualTap::addIp(const InetAddress &ip)
{ {
#if defined(NO_STACK) #if defined(NO_STACK)
char ipbuf[64]; char ipbuf[INET6_ADDRSTRLEN];
DEBUG_INFO("addIp (%s)", ip.toString(ipbuf)); DEBUG_INFO("addIp (%s)", ip.toString(ipbuf));
_ips.push_back(ip); _ips.push_back(ip);
std::sort(_ips.begin(),_ips.end()); std::sort(_ips.begin(),_ips.end());
return true; return true;
#endif #endif
#if defined(STACK_PICO) || defined(STACK_LWIP) #if defined(STACK_PICO) || defined(STACK_LWIP)
char ipbuf[64]; char ipbuf[INET6_ADDRSTRLEN];
DEBUG_INFO("addIp (%s)", ip.toString(ipbuf)); DEBUG_INFO("addIp (%s)", ip.toString(ipbuf));
if(registerIpWithStack(ip)) { if(registerIpWithStack(ip)) {
if (std::find(_ips.begin(),_ips.end(),ip) == _ips.end()) { if (std::find(_ips.begin(),_ips.end(),ip) == _ips.end()) {
@@ -207,7 +214,8 @@ namespace ZeroTier {
{ {
// TODO: This is inefficient and awkward, should be replaced with something more elegant // TODO: This is inefficient and awkward, should be replaced with something more elegant
if(zt1ServiceRef) { if(zt1ServiceRef) {
char id[ZT_ID_LEN+1]; char id[ZT_ID_LEN];
memset(id, 0, sizeof(id));
sprintf(id, "%lx",((ZeroTier::OneService *)zt1ServiceRef)->getNode()->address()); sprintf(id, "%lx",((ZeroTier::OneService *)zt1ServiceRef)->getNode()->address());
return std::string(id); return std::string(id);
} }
@@ -260,6 +268,10 @@ namespace ZeroTier {
if(picostack){ if(picostack){
picostack->pico_init_interface(this); picostack->pico_init_interface(this);
if(should_start_stack) { if(should_start_stack) {
// Add link to ipv4_link_add
//ZeroTier::InetAddress localhost;
//localhost.fromString("127.0.0.1");
//addIp(localhost); // Add a single link to localhost to the picoTCP device (TODO: should be placed elsewhere)
picostack->pico_loop(this); picostack->pico_loop(this);
} }
} }
@@ -353,6 +365,31 @@ namespace ZeroTier {
} }
} }
/****************************************************************************/
/* DNS */
/****************************************************************************/
int VirtualTap::add_DNS_Nameserver(struct sockaddr *addr)
{
#if defined(STACK_PICO)
return picostack->pico_add_dns_nameserver(addr);
#endif
#if defined(STACK_LWIP)
return lwipstack->lwip_add_dns_nameserver(addr);
#endif
}
int VirtualTap::del_DNS_Nameserver(struct sockaddr *addr)
{
#if defined(STACK_PICO)
return picostack->pico_del_dns_nameserver(addr);
#endif
#if defined(STACK_LWIP)
return lwipstack->lwip_del_dns_nameserver(addr);
#endif
}
/****************************************************************************/ /****************************************************************************/
/* SDK Socket API */ /* SDK Socket API */
/****************************************************************************/ /****************************************************************************/
@@ -532,20 +569,21 @@ namespace ZeroTier {
} }
void VirtualTap::Housekeeping() void VirtualTap::Housekeeping()
{ {/*
Mutex::Lock _l(_tcpconns_m); Mutex::Lock _l(_tcpconns_m);
std::time_t current_ts = std::time(nullptr); std::time_t current_ts = std::time(nullptr);
if(current_ts > last_housekeeping_ts + ZT_HOUSEKEEPING_INTERVAL) { if(current_ts > last_housekeeping_ts + ZT_HOUSEKEEPING_INTERVAL) {
// update managed routes (add/del from network stacks) // update managed routes (add/del from network stacks)
if(zt1ServiceRef) { ZeroTier::OneService *service = ((ZeroTier::OneService *)zt1ServiceRef);
std::vector<ZT_VirtualNetworkRoute> *managed_routes = ((ZeroTier::OneService *)zt1ServiceRef)->getRoutes(this->_nwid); if(service) {
std::vector<ZT_VirtualNetworkRoute> *managed_routes = service->getRoutes(this->_nwid);
ZeroTier::InetAddress target_addr; ZeroTier::InetAddress target_addr;
ZeroTier::InetAddress via_addr; ZeroTier::InetAddress via_addr;
ZeroTier::InetAddress null_addr; ZeroTier::InetAddress null_addr;
ZeroTier::InetAddress nm; ZeroTier::InetAddress nm;
null_addr.fromString(""); null_addr.fromString("");
bool found; bool found;
char ipbuf[64], ipbuf2[64], ipbuf3[64]; char ipbuf[INET6_ADDRSTRLEN], ipbuf2[INET6_ADDRSTRLEN], ipbuf3[INET6_ADDRSTRLEN];
// TODO: Rework this when we have time // TODO: Rework this when we have time
// check if pushed route exists in tap (add) // check if pushed route exists in tap (add)
for(int i=0; i<ZT_MAX_NETWORK_ROUTES; i++) { for(int i=0; i<ZT_MAX_NETWORK_ROUTES; i++) {
@@ -592,7 +630,9 @@ namespace ZeroTier {
// TODO: Clean up VirtualSocket objects // TODO: Clean up VirtualSocket objects
last_housekeeping_ts = std::time(nullptr); last_housekeeping_ts = std::time(nullptr);
} }
*/
} }
/****************************************************************************/ /****************************************************************************/

18
src/VirtualTap.hpp
View File

@@ -180,12 +180,25 @@ namespace ZeroTier {
*/ */
void removeVirtualSocket(VirtualSocket *vs); void removeVirtualSocket(VirtualSocket *vs);
/****************************************************************************/
/* DNS */
/****************************************************************************/
/*
* Registers a DNS nameserver with the network stack
*/
int add_DNS_Nameserver(struct sockaddr *addr);
/*
* Un-registers a DNS nameserver from the network stack
*/
int del_DNS_Nameserver(struct sockaddr *addr);
/****************************************************************************/ /****************************************************************************/
/* Vars */ /* Vars */
/****************************************************************************/ /****************************************************************************/
#if defined(STACK_PICO) #if defined(STACK_PICO)
bool should_start_stack = false; bool should_start_stack = false;
struct pico_device *picodev = NULL; struct pico_device *picodev = NULL;
@@ -206,6 +219,9 @@ namespace ZeroTier {
std::vector<std::pair<ZeroTier::InetAddress, ZeroTier::InetAddress>> routes; std::vector<std::pair<ZeroTier::InetAddress, ZeroTier::InetAddress>> routes;
void *zt1ServiceRef = NULL; void *zt1ServiceRef = NULL;
char vtap_full_name[64];
char vtap_abbr_name[16];
static int devno; static int devno;
int ifindex = 0; int ifindex = 0;

179
src/libzt.cpp
View File

@@ -35,6 +35,7 @@ for applications to use. See also: include/libzt.h */
#include <unistd.h> #include <unistd.h>
#include <errno.h> #include <errno.h>
#include <time.h> #include <time.h>
#include <stdint.h>
#if defined(__APPLE__) #if defined(__APPLE__)
#include <net/ethernet.h> #include <net/ethernet.h>
@@ -130,7 +131,7 @@ void zts_start(const char *path)
if(path) if(path)
ZeroTier::homeDir = path; ZeroTier::homeDir = path;
pthread_t service_thread; pthread_t service_thread;
pthread_create(&service_thread, NULL, zts_start_service, (void *)(path)); pthread_create(&service_thread, NULL, zts_start_service, NULL);
} }
void zts_simple_start(const char *path, const char *nwid) void zts_simple_start(const char *path, const char *nwid)
@@ -138,11 +139,9 @@ void zts_simple_start(const char *path, const char *nwid)
zts_start(path); zts_start(path);
while(!zts_running()) { while(!zts_running()) {
nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL); nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL);
//usleep(ZT_API_CHECK_INTERVAL * 1000);
} }
zts_join(nwid); zts_join(nwid);
while(!zts_has_address(nwid)) { while(!zts_has_address(nwid)) {
//usleep(ZT_API_CHECK_INTERVAL * 1000);
nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL); nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL);
} }
} }
@@ -219,9 +218,9 @@ void zts_lib_version(char *ver) {
int zts_get_device_id(char *devID) { int zts_get_device_id(char *devID) {
if(ZeroTier::zt1Service) { if(ZeroTier::zt1Service) {
char id[ZT_ID_LEN+1]; char id[ZT_ID_LEN];
sprintf(id, "%lx",ZeroTier::zt1Service->getNode()->address()); sprintf(id, "%lx",ZeroTier::zt1Service->getNode()->address());
memcpy(devID, id, ZT_ID_LEN+1); memcpy(devID, id, ZT_ID_LEN);
return 0; return 0;
} }
else // Service isn't online, try to read ID from file else // Service isn't online, try to read ID from file
@@ -245,17 +244,17 @@ int zts_running() {
int zts_has_ipv4_address(const char *nwid) int zts_has_ipv4_address(const char *nwid)
{ {
char ipv4_addr[ZT_MAX_IPADDR_LEN]; char ipv4_addr[INET_ADDRSTRLEN];
memset(ipv4_addr, 0, ZT_MAX_IPADDR_LEN); memset(ipv4_addr, 0, INET_ADDRSTRLEN);
zts_get_ipv4_address(nwid, ipv4_addr, ZT_MAX_IPADDR_LEN); zts_get_ipv4_address(nwid, ipv4_addr, INET_ADDRSTRLEN);
return strcmp(ipv4_addr, "\0"); return strcmp(ipv4_addr, "\0");
} }
int zts_has_ipv6_address(const char *nwid) int zts_has_ipv6_address(const char *nwid)
{ {
char ipv6_addr[ZT_MAX_IPADDR_LEN]; char ipv6_addr[INET6_ADDRSTRLEN];
memset(ipv6_addr, 0, ZT_MAX_IPADDR_LEN); memset(ipv6_addr, 0, INET6_ADDRSTRLEN);
zts_get_ipv6_address(nwid, ipv6_addr, ZT_MAX_IPADDR_LEN); zts_get_ipv6_address(nwid, ipv6_addr, INET6_ADDRSTRLEN);
return strcmp(ipv6_addr, "\0"); return strcmp(ipv6_addr, "\0");
} }
@@ -272,7 +271,7 @@ void zts_get_ipv4_address(const char *nwid, char *addrstr, const int addrlen)
if(tap && tap->_ips.size()){ if(tap && tap->_ips.size()){
for(int i=0; i<tap->_ips.size(); i++) { for(int i=0; i<tap->_ips.size(); i++) {
if(tap->_ips[i].isV4()) { if(tap->_ips[i].isV4()) {
char ipbuf[64]; char ipbuf[INET_ADDRSTRLEN];
std::string addr = tap->_ips[i].toString(ipbuf); std::string addr = tap->_ips[i].toString(ipbuf);
int len = addrlen < addr.length() ? addrlen : addr.length(); int len = addrlen < addr.length() ? addrlen : addr.length();
memset(addrstr, 0, len); memset(addrstr, 0, len);
@@ -294,7 +293,7 @@ void zts_get_ipv6_address(const char *nwid, char *addrstr, const int addrlen)
if(tap && tap->_ips.size()){ if(tap && tap->_ips.size()){
for(int i=0; i<tap->_ips.size(); i++) { for(int i=0; i<tap->_ips.size(); i++) {
if(tap->_ips[i].isV6()) { if(tap->_ips[i].isV6()) {
char ipbuf[64]; char ipbuf[INET6_ADDRSTRLEN];
std::string addr = tap->_ips[i].toString(ipbuf); std::string addr = tap->_ips[i].toString(ipbuf);
int len = addrlen < addr.length() ? addrlen : addr.length(); int len = addrlen < addr.length() ? addrlen : addr.length();
memset(addrstr, 0, len); memset(addrstr, 0, len);
@@ -312,7 +311,7 @@ void zts_get_6plane_addr(char *addr, const char *nwid, const char *devID)
{ {
ZeroTier::InetAddress _6planeAddr = ZeroTier::InetAddress::makeIpv66plane( ZeroTier::InetAddress _6planeAddr = ZeroTier::InetAddress::makeIpv66plane(
ZeroTier::Utils::hexStrToU64(nwid),ZeroTier::Utils::hexStrToU64(devID)); ZeroTier::Utils::hexStrToU64(nwid),ZeroTier::Utils::hexStrToU64(devID));
char ipbuf[64]; char ipbuf[INET6_ADDRSTRLEN];
memcpy(addr, _6planeAddr.toIpString(ipbuf), 40); memcpy(addr, _6planeAddr.toIpString(ipbuf), 40);
} }
@@ -320,7 +319,7 @@ void zts_get_rfc4193_addr(char *addr, const char *nwid, const char *devID)
{ {
ZeroTier::InetAddress _6planeAddr = ZeroTier::InetAddress::makeIpv6rfc4193( ZeroTier::InetAddress _6planeAddr = ZeroTier::InetAddress::makeIpv6rfc4193(
ZeroTier::Utils::hexStrToU64(nwid),ZeroTier::Utils::hexStrToU64(devID)); ZeroTier::Utils::hexStrToU64(nwid),ZeroTier::Utils::hexStrToU64(devID));
char ipbuf[64]; char ipbuf[INET6_ADDRSTRLEN];
memcpy(addr, _6planeAddr.toIpString(ipbuf), 40); memcpy(addr, _6planeAddr.toIpString(ipbuf), 40);
} }
@@ -576,7 +575,6 @@ int zts_connect(ZT_CONNECT_SIG) {
{ {
// FIXME: locking and unlocking so often might cause a performance bottleneck while outgoing VirtualSockets // FIXME: locking and unlocking so often might cause a performance bottleneck while outgoing VirtualSockets
// are being established (also applies to accept()) // are being established (also applies to accept())
//usleep(ZT_CONNECT_RECHECK_DELAY * 1000);
nanosleep((const struct timespec[]){{0, (ZT_CONNECT_RECHECK_DELAY * 1000000)}}, NULL); nanosleep((const struct timespec[]){{0, (ZT_CONNECT_RECHECK_DELAY * 1000000)}}, NULL);
tap->_tcpconns_m.lock(); tap->_tcpconns_m.lock();
for(int i=0; i<tap->_VirtualSockets.size(); i++) for(int i=0; i<tap->_VirtualSockets.size(); i++)
@@ -619,7 +617,6 @@ Darwin:
address space. address space.
*/ */
int zts_bind(ZT_BIND_SIG) { int zts_bind(ZT_BIND_SIG) {
DEBUG_INFO();
int err = errno = 0; int err = errno = 0;
if(fd < 0) { if(fd < 0) {
errno = EBADF; errno = EBADF;
@@ -643,26 +640,31 @@ int zts_bind(ZT_BIND_SIG) {
if(vs->socket_family == AF_INET) { if(vs->socket_family == AF_INET) {
struct sockaddr_in *in4 = (struct sockaddr_in *)addr; struct sockaddr_in *in4 = (struct sockaddr_in *)addr;
if(in4->sin_addr.s_addr == INADDR_ANY) { if(in4->sin_addr.s_addr == INADDR_ANY) {
DEBUG_INFO("AF_INET, INADDR_ANY, binding to all interfaces"); DEBUG_EXTRA("AF_INET, INADDR_ANY, binding to all interfaces");
// grab first vtap // grab first vtap
if(ZeroTier::vtaps.size()) { if(ZeroTier::vtaps.size()) {
tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]); tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]); // pick any vtap
}
}
if(in4->sin_addr.s_addr == 0x7f000001) {
DEBUG_EXTRA("127.0.0.1, will bind to appropriate vtap when connection is inbound");
if(ZeroTier::vtaps.size()) {
tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]); // pick any vtap
} }
} }
} }
if(vs->socket_family == AF_INET6) { if(vs->socket_family == AF_INET6) {
struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr; struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr;
if(memcmp((void*)&(in6->sin6_addr), (void*)&(in6addr_any), sizeof(in6addr_any)) == 0) { if(memcmp((void*)&(in6->sin6_addr), (void*)&(in6addr_any), sizeof(in6addr_any)) == 0) {
DEBUG_INFO("AF_INET6, in6addr_any, binding to all interfaces"); DEBUG_EXTRA("AF_INET6, in6addr_any, binding to all interfaces");
if(ZeroTier::vtaps.size()) { if(ZeroTier::vtaps.size()) {
tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]); tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]); // pick any vtap
} }
} }
} }
ZeroTier::InetAddress inet; ZeroTier::InetAddress inet;
sockaddr2inet(vs->socket_family, addr, &inet); sockaddr2inet(vs->socket_family, addr, &inet);
char buf3[64];
if(!tap) if(!tap)
tap = getTapByAddr(&inet); tap = getTapByAddr(&inet);
@@ -793,7 +795,6 @@ int zts_accept(ZT_ACCEPT_SIG) {
} }
else { // blocking else { // blocking
while(true) { while(true) {
//usleep(ZT_ACCEPT_RECHECK_DELAY * 1000);
nanosleep((const struct timespec[]){{0, (ZT_ACCEPT_RECHECK_DELAY * 1000000)}}, NULL); nanosleep((const struct timespec[]){{0, (ZT_ACCEPT_RECHECK_DELAY * 1000000)}}, NULL);
accepted_vs = tap->Accept(vs); accepted_vs = tap->Accept(vs);
if(accepted_vs) if(accepted_vs)
@@ -1036,7 +1037,7 @@ Linux / Darwin:
int zts_close(ZT_CLOSE_SIG) int zts_close(ZT_CLOSE_SIG)
{ {
int err = errno = 0; int err = errno = 0;
DEBUG_EXTRA("fd=%d", fd); //DEBUG_EXTRA("fd=%d", fd);
if(fd < 0) { if(fd < 0) {
errno = EBADF; errno = EBADF;
return -1; return -1;
@@ -1192,7 +1193,7 @@ Linux:
*/ */
ssize_t zts_sendto(ZT_SENDTO_SIG) ssize_t zts_sendto(ZT_SENDTO_SIG)
{ {
//DEBUG_INFO(); DEBUG_TRANS("fd=%d", fd);
int err = errno = 0; int err = errno = 0;
if(fd < 0) { if(fd < 0) {
errno = EBADF; errno = EBADF;
@@ -1208,26 +1209,27 @@ ssize_t zts_sendto(ZT_SENDTO_SIG)
ZeroTier::InetAddress iaddr; ZeroTier::InetAddress iaddr;
ZeroTier::VirtualTap *tap; ZeroTier::VirtualTap *tap;
char ipstr[INET6_ADDRSTRLEN];
// int port;
memset(ipstr, 0, INET6_ADDRSTRLEN);
if(vs->socket_type == SOCK_DGRAM) { if(vs->socket_type == SOCK_DGRAM)
// form addresses {
if(vs->socket_family == AF_INET) { if(vs->socket_family == AF_INET)
{
char ipstr[INET_ADDRSTRLEN];
memset(ipstr, 0, INET_ADDRSTRLEN);
inet_ntop(AF_INET, inet_ntop(AF_INET,
(const void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, ipstr, INET_ADDRSTRLEN); (const void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, ipstr, INET_ADDRSTRLEN);
iaddr.fromString(ipstr); iaddr.fromString(ipstr);
// port = ((struct sockaddr_in*)addr)->sin_port;
} }
if(vs->socket_family == AF_INET6) { if(vs->socket_family == AF_INET6)
{
char ipstr[INET6_ADDRSTRLEN];
memset(ipstr, 0, INET6_ADDRSTRLEN);
inet_ntop(AF_INET6, inet_ntop(AF_INET6,
(const void *)&((struct sockaddr_in6 *)addr)->sin6_addr.s6_addr, ipstr, INET6_ADDRSTRLEN); (const void *)&((struct sockaddr_in6 *)addr)->sin6_addr.s6_addr, ipstr, INET6_ADDRSTRLEN);
// TODO: This is a hack, determine a proper way to do this // TODO: This is a hack, determine a proper way to do this
char addrstr[64]; char addrstr[INET6_ADDRSTRLEN];
sprintf(addrstr, "%s%s", ipstr, std::string("/40").c_str()); sprintf(addrstr, "%s%s", ipstr, std::string("/40").c_str());
iaddr.fromString(addrstr); iaddr.fromString(addrstr);
// port = ((struct sockaddr_in6*)addr)->sin6_port;
} }
// get tap // get tap
tap = getTapByAddr(&iaddr); tap = getTapByAddr(&iaddr);
@@ -1242,7 +1244,8 @@ ssize_t zts_sendto(ZT_SENDTO_SIG)
errno = EINVAL; // TODO: Not correct, but what else could we use? errno = EINVAL; // TODO: Not correct, but what else could we use?
} }
} }
if(vs->socket_type == SOCK_RAW) { if(vs->socket_type == SOCK_RAW)
{
struct sockaddr_ll *socket_address = (struct sockaddr_ll *)addr; struct sockaddr_ll *socket_address = (struct sockaddr_ll *)addr;
ZeroTier::VirtualTap *tap = getTapByIndex(socket_address->sll_ifindex); ZeroTier::VirtualTap *tap = getTapByIndex(socket_address->sll_ifindex);
if(tap) { if(tap) {
@@ -1308,6 +1311,7 @@ ssize_t zts_sendto(ZT_SENDTO_SIG)
*/ */
ssize_t zts_send(ZT_SEND_SIG) ssize_t zts_send(ZT_SEND_SIG)
{ {
DEBUG_TRANS("fd=%d", fd);
int err = errno = 0; int err = errno = 0;
ZeroTier::VirtualSocket *vs = get_virtual_socket(fd); ZeroTier::VirtualSocket *vs = get_virtual_socket(fd);
if(!vs) { if(!vs) {
@@ -1375,7 +1379,7 @@ ssize_t zts_send(ZT_SEND_SIG)
// TODO // TODO
ssize_t zts_sendmsg(ZT_SENDMSG_SIG) ssize_t zts_sendmsg(ZT_SENDMSG_SIG)
{ {
DEBUG_INFO("fd = %d", fd); DEBUG_TRANS("fd=%d", fd);
int err = errno = 0; int err = errno = 0;
if(fd < 0) { if(fd < 0) {
errno = EBADF; errno = EBADF;
@@ -1413,6 +1417,7 @@ ssize_t zts_sendmsg(ZT_SENDMSG_SIG)
*/ */
ssize_t zts_recv(ZT_RECV_SIG) ssize_t zts_recv(ZT_RECV_SIG)
{ {
DEBUG_TRANS("fd=%d", fd);
int err = errno = 0; int err = errno = 0;
ZeroTier::VirtualSocket *vs = get_virtual_socket(fd); ZeroTier::VirtualSocket *vs = get_virtual_socket(fd);
if(!vs) { if(!vs) {
@@ -1500,21 +1505,31 @@ ssize_t zts_recv(ZT_RECV_SIG)
*/ */
ssize_t zts_recvfrom(ZT_RECVFROM_SIG) ssize_t zts_recvfrom(ZT_RECVFROM_SIG)
{ {
//DEBUG_INFO(); DEBUG_TRANS("fd=%d", fd);
int r = 0, err = errno = 0; int32_t r = 0;
errno = 0;
if(fd < 0) { if(fd < 0) {
errno = EBADF; errno = EBADF;
return -1; return -1;
} }
char udp_msg_buf[ZT_MAX_MTU]; char udp_msg_buf[ZT_SOCKET_MSG_BUF_SZ];
r = read(fd, udp_msg_buf, sizeof(udp_msg_buf)); char *msg_ptr = udp_msg_buf;
r = read(fd, msg_ptr, sizeof(udp_msg_buf));
if(r > 0) { if(r > 0) {
int udp_msg_len = 0; *addrlen = sizeof(struct sockaddr_storage);
memcpy(&udp_msg_len, udp_msg_buf, sizeof(udp_msg_len));
memcpy(addr, udp_msg_buf + sizeof(int), sizeof(struct sockaddr_in)); // get message length
*addrlen = sizeof(struct sockaddr_in); int32_t udp_msg_len = 0;
int payload_sz = udp_msg_len - sizeof(struct sockaddr_in); memcpy(&udp_msg_len, msg_ptr, sizeof(udp_msg_len));
memcpy(buf, udp_msg_buf + sizeof(int) + sizeof(struct sockaddr_in), payload_sz); msg_ptr+=sizeof(int32_t);
// get address
memcpy(addr, msg_ptr, *addrlen);
msg_ptr+=*addrlen;
// get payload
int32_t payload_sz = udp_msg_len - *addrlen;
memcpy(buf, msg_ptr, payload_sz);
r = payload_sz; r = payload_sz;
} }
return r; return r;
@@ -1523,7 +1538,7 @@ ssize_t zts_recvfrom(ZT_RECVFROM_SIG)
// TODO // TODO
ssize_t zts_recvmsg(ZT_RECVMSG_SIG) ssize_t zts_recvmsg(ZT_RECVMSG_SIG)
{ {
DEBUG_INFO("fd=%d", fd); DEBUG_TRANS("fd=%d", fd);
int err = errno = 0; int err = errno = 0;
if(fd < 0) { if(fd < 0) {
errno = EBADF; errno = EBADF;
@@ -1536,12 +1551,12 @@ ssize_t zts_recvmsg(ZT_RECVMSG_SIG)
} }
int zts_read(ZT_READ_SIG) { int zts_read(ZT_READ_SIG) {
//DEBUG_INFO("fd = %d", fd); DEBUG_TRANS("fd=%d", fd);
return read(fd, buf, len); return read(fd, buf, len);
} }
int zts_write(ZT_WRITE_SIG) { int zts_write(ZT_WRITE_SIG) {
// DEBUG_INFO("fd = %d", fd); DEBUG_TRANS("fd=%d", fd);
return write(fd, buf, len); return write(fd, buf, len);
} }
@@ -1616,7 +1631,6 @@ int zts_shutdown(ZT_SHUTDOWN_SIG)
for(int i=0; i<ZT_SDK_CLTIME; i++) { for(int i=0; i<ZT_SDK_CLTIME; i++) {
if(vs->TXbuf->count() == 0) if(vs->TXbuf->count() == 0)
break; break;
//usleep(ZT_API_CHECK_INTERVAL * 1000);
nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL); nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL);
} }
@@ -1635,21 +1649,29 @@ int zts_shutdown(ZT_SHUTDOWN_SIG)
return 0; return 0;
} }
int zts_add_dns_nameserver(struct sockaddr *addr) int zts_add_dns_nameserver(struct sockaddr *addr)
{ {
errno = 0; ZeroTier::VirtualTap *vtap = getAnyTap();
return 0; if(vtap){
return vtap->add_DNS_Nameserver(addr);
}
DEBUG_ERROR("unable to locate virtual tap to add DNS nameserver");
return -1;
} }
int zts_remove_dns_nameserver(struct sockaddr *addr) int zts_del_dns_nameserver(struct sockaddr *addr)
{ {
errno = 0; ZeroTier::VirtualTap *vtap = getAnyTap();
return 0; if(vtap){
return vtap->del_DNS_Nameserver(addr);
}
DEBUG_ERROR("unable to locate virtual tap to remove DNS nameserver");
return -1;
} }
/****************************************************************************/ /****************************************************************************/
/* SDK Socket API (Java Native Interface JNI) /* JNI naming convention: Java_PACKAGENAME_CLASSNAME_METHODNAME */ /* SDK Socket API (Java Native Interface JNI) */
/* JNI naming convention: Java_PACKAGENAME_CLASSNAME_METHODNAME */
/****************************************************************************/ /****************************************************************************/
@@ -1659,7 +1681,7 @@ namespace ZeroTier {
#include <jni.h> #include <jni.h>
JNIEXPORT int JNICALL Java_zerotier_ZeroTier_ztjni_1start(JNIEnv *env, jobject thisObj, jstring path) { JNIEXPORT void JNICALL Java_zerotier_ZeroTier_ztjni_1start(JNIEnv *env, jobject thisObj, jstring path) {
if(path) { if(path) {
homeDir = env->GetStringUTFChars(path, NULL); homeDir = env->GetStringUTFChars(path, NULL);
zts_start(homeDir.c_str()); zts_start(homeDir.c_str());
@@ -1711,9 +1733,9 @@ namespace ZeroTier {
JNIEnv *env, jobject thisObj, jstring nwid) JNIEnv *env, jobject thisObj, jstring nwid)
{ {
const char *nwid_str = env->GetStringUTFChars(nwid, NULL); const char *nwid_str = env->GetStringUTFChars(nwid, NULL);
char address_string[32]; char address_string[INET_ADDRSTRLEN];
memset(address_string, 0, 32); memset(address_string, 0, INET_ADDRSTRLEN);
zts_get_ipv4_address(nwid_str, address_string, ZT_MAX_IPADDR_LEN); zts_get_ipv4_address(nwid_str, address_string, INET_ADDRSTRLEN);
jclass clazz = (*env).FindClass("java/util/ArrayList"); jclass clazz = (*env).FindClass("java/util/ArrayList");
jobject addresses = (*env).NewObject(clazz, (*env).GetMethodID(clazz, "<init>", "()V")); jobject addresses = (*env).NewObject(clazz, (*env).GetMethodID(clazz, "<init>", "()V"));
jstring _str = (*env).NewStringUTF(address_string); jstring _str = (*env).NewStringUTF(address_string);
@@ -1725,9 +1747,9 @@ namespace ZeroTier {
JNIEnv *env, jobject thisObj, jstring nwid) JNIEnv *env, jobject thisObj, jstring nwid)
{ {
const char *nwid_str = env->GetStringUTFChars(nwid, NULL); const char *nwid_str = env->GetStringUTFChars(nwid, NULL);
char address_string[32]; char address_string[INET6_ADDRSTRLEN];
memset(address_string, 0, 32); memset(address_string, 0, INET6_ADDRSTRLEN);
zts_get_ipv6_address(nwid_str, address_string, ZT_MAX_IPADDR_LEN); zts_get_ipv6_address(nwid_str, address_string, INET6_ADDRSTRLEN);
jclass clazz = (*env).FindClass("java/util/ArrayList"); jclass clazz = (*env).FindClass("java/util/ArrayList");
jobject addresses = (*env).NewObject(clazz, (*env).GetMethodID(clazz, "<init>", "()V")); jobject addresses = (*env).NewObject(clazz, (*env).GetMethodID(clazz, "<init>", "()V"));
jstring _str = (*env).NewStringUTF(address_string); jstring _str = (*env).NewStringUTF(address_string);
@@ -1778,7 +1800,7 @@ namespace ZeroTier {
struct sockaddr_in addr; struct sockaddr_in addr;
jbyte *body = (*env).GetByteArrayElements( buf, 0); jbyte *body = (*env).GetByteArrayElements( buf, 0);
unsigned char buffer[ZT_SDK_MTU]; unsigned char buffer[ZT_SDK_MTU];
int payload_offset = sizeof(int) + sizeof(struct sockaddr_storage); int payload_offset = sizeof(int32_t) + sizeof(struct sockaddr_storage);
int rxbytes = zts_recvfrom(fd, &buffer, len, flags, (struct sockaddr *)&addr, (socklen_t *)sizeof(struct sockaddr_storage)); int rxbytes = zts_recvfrom(fd, &buffer, len, flags, (struct sockaddr *)&addr, (socklen_t *)sizeof(struct sockaddr_storage));
if(rxbytes > 0) if(rxbytes > 0)
memcpy(body, (jbyte*)buffer + payload_offset, rxbytes); memcpy(body, (jbyte*)buffer + payload_offset, rxbytes);
@@ -1909,18 +1931,6 @@ namespace ZeroTier {
/* SDK Socket API Helper functions --- DON'T CALL THESE DIRECTLY */ /* SDK Socket API Helper functions --- DON'T CALL THESE DIRECTLY */
/****************************************************************************/ /****************************************************************************/
void zts_start_dns_client()
{
// Coming soon
/*
struct pico_ip4 *ns;
uint8_t flag = PICO_DNS_NS_ADD; // PICO_DNS_NS_DEL, PICO_DNS_NS_ADD
pico_dns_client_nameserver(ns, flag);
*/
}
#if defined(STACK_PICO) #if defined(STACK_PICO)
int zts_get_pico_socket(int fd, struct pico_socket **s) int zts_get_pico_socket(int fd, struct pico_socket **s)
{ {
@@ -2025,7 +2035,7 @@ ZeroTier::VirtualTap *getTapByAddr(ZeroTier::InetAddress *addr)
{ {
ZeroTier::_vtaps_lock.lock(); ZeroTier::_vtaps_lock.lock();
ZeroTier::VirtualTap *s, *tap = nullptr; ZeroTier::VirtualTap *s, *tap = nullptr;
char ipbuf[64], ipbuf2[64], ipbuf3[64]; //char ipbuf[64], ipbuf2[64], ipbuf3[64];
for(int i=0; i<ZeroTier::vtaps.size(); i++) { for(int i=0; i<ZeroTier::vtaps.size(); i++) {
s = (ZeroTier::VirtualTap*)ZeroTier::vtaps[i]; s = (ZeroTier::VirtualTap*)ZeroTier::vtaps[i];
// check address schemes // check address schemes
@@ -2092,6 +2102,17 @@ ZeroTier::VirtualTap *getTapByIndex(int index)
return tap; return tap;
} }
ZeroTier::VirtualTap *getAnyTap()
{
ZeroTier::_vtaps_lock.lock();
ZeroTier::VirtualTap *vtap = NULL;
if(ZeroTier::vtaps.size()) {
vtap = (ZeroTier::VirtualTap *)ZeroTier::vtaps[0];
}
ZeroTier::_vtaps_lock.unlock();
return vtap;
}
/****************************************************************************/ /****************************************************************************/
/* VirtualSocket / VirtualTap helper functions - DON'T CALL THESE DIRECTLY */ /* VirtualSocket / VirtualTap helper functions - DON'T CALL THESE DIRECTLY */
/****************************************************************************/ /****************************************************************************/

452
src/picoTCP.cpp
View File

@@ -25,6 +25,7 @@
*/ */
#include <ctime> #include <ctime>
#include <stdint.h>
#include "pico_eth.h" #include "pico_eth.h"
#include "pico_stack.h" #include "pico_stack.h"
@@ -36,6 +37,7 @@
#include "pico_device.h" #include "pico_device.h"
#include "pico_ipv6.h" #include "pico_ipv6.h"
#include "pico_tcp.h" #include "pico_tcp.h"
#include "pico_dns_client.h"
#include "libzt.h" #include "libzt.h"
#include "Utilities.hpp" #include "Utilities.hpp"
@@ -65,6 +67,7 @@ extern "C" int pico_socket_listen(PICO_SOCKET_LISTEN_SIG);
extern "C" int pico_socket_write(PICO_SOCKET_WRITE_SIG); extern "C" int pico_socket_write(PICO_SOCKET_WRITE_SIG);
extern "C" int pico_socket_close(PICO_SOCKET_CLOSE_SIG); extern "C" int pico_socket_close(PICO_SOCKET_CLOSE_SIG);
extern "C" struct pico_ipv6_link * pico_ipv6_link_add(PICO_IPV6_LINK_ADD_SIG); extern "C" struct pico_ipv6_link * pico_ipv6_link_add(PICO_IPV6_LINK_ADD_SIG);
extern "C" int pico_dns_client_nameserver(PICO_DNS_CLIENT_NAMESERVER_SIG);
/* /*
int pico_stack_recv(PICO_STACK_RECV_SIG); int pico_stack_recv(PICO_STACK_RECV_SIG);
@@ -106,7 +109,7 @@ namespace ZeroTier {
picodev.tap = tap; picodev.tap = tap;
uint8_t mac[PICO_SIZE_ETH]; uint8_t mac[PICO_SIZE_ETH];
tap->_mac.copyTo(mac, PICO_SIZE_ETH); tap->_mac.copyTo(mac, PICO_SIZE_ETH);
if(pico_device_init(&picodev, tap->_dev.c_str(), mac) != 0) { if(pico_device_init(&picodev, tap->vtap_abbr_name, mac) != 0) {
DEBUG_ERROR("dev init failed"); DEBUG_ERROR("dev init failed");
handle_general_failure(); handle_general_failure();
err = false; err = false;
@@ -122,7 +125,7 @@ namespace ZeroTier {
{ {
_picostack_driver_lock.lock(); _picostack_driver_lock.lock();
bool err = false; bool err = false;
char ipbuf[64]; char ipbuf[INET6_ADDRSTRLEN];
uint8_t hwaddr[6]; uint8_t hwaddr[6];
// register addresses // register addresses
if(ip.isV4()) { if(ip.isV4()) {
@@ -132,8 +135,8 @@ namespace ZeroTier {
pico_ipv4_link_add(&picodev, ipaddr, netmask); pico_ipv4_link_add(&picodev, ipaddr, netmask);
DEBUG_INFO("addr=%s", ip.toString(ipbuf)); DEBUG_INFO("addr=%s", ip.toString(ipbuf));
tap->_mac.copyTo(hwaddr, 6); tap->_mac.copyTo(hwaddr, 6);
char macbuf[18]; char macbuf[ZT_MAC_ADDRSTRLEN];
mac2str(macbuf, sizeof(macbuf), hwaddr); mac2str(macbuf, ZT_MAC_ADDRSTRLEN, hwaddr);
DEBUG_INFO("mac=%s", macbuf); DEBUG_INFO("mac=%s", macbuf);
err = true; err = true;
} }
@@ -147,8 +150,8 @@ namespace ZeroTier {
pico_ipv6_link_add(&picodev, ipaddr, netmask); pico_ipv6_link_add(&picodev, ipaddr, netmask);
DEBUG_INFO("addr=%s", ipv6_str); DEBUG_INFO("addr=%s", ipv6_str);
tap->_mac.copyTo(hwaddr, 6); tap->_mac.copyTo(hwaddr, 6);
char macbuf[18]; char macbuf[ZT_MAC_ADDRSTRLEN];
mac2str(macbuf, sizeof(macbuf), hwaddr); mac2str(macbuf, ZT_MAC_ADDRSTRLEN, hwaddr);
DEBUG_INFO("mac=%s", macbuf); DEBUG_INFO("mac=%s", macbuf);
err = true; err = true;
} }
@@ -188,7 +191,46 @@ namespace ZeroTier {
} }
return err; return err;
} }
int picoTCP::pico_add_dns_nameserver(struct sockaddr *addr)
{
int err = errno = 0;
// TODO: De-complexify this
struct pico_ip4 ns;
memset(&ns, 0, sizeof (struct pico_ip4));
struct sockaddr_in *in4 = (struct sockaddr_in*)addr;
char ipv4_str[INET_ADDRSTRLEN];
inet_ntop(AF_INET, (const void *)&in4->sin_addr.s_addr, ipv4_str, INET_ADDRSTRLEN);
uint32_t ipval = 0;
pico_string_to_ipv4(ipv4_str, &ipval);
ns.addr = ipval;
if((err = pico_dns_client_nameserver(&ns, PICO_DNS_NS_ADD)) < 0) {
DEBUG_ERROR("error while adding DNS nameserver, err=%d, pico_err=%d, %s",
err, pico_err, beautify_pico_error(pico_err));
map_pico_err_to_errno(pico_err);
}
return err;
}
int picoTCP::pico_del_dns_nameserver(struct sockaddr *addr)
{
int err = errno = 0;
// TODO: De-complexify this
struct pico_ip4 ns;
memset(&ns, 0, sizeof (struct pico_ip4));
struct sockaddr_in *in4 = (struct sockaddr_in*)addr;
char ipv4_str[INET_ADDRSTRLEN];
inet_ntop(AF_INET, (const void *)&in4->sin_addr.s_addr, ipv4_str, INET_ADDRSTRLEN);
uint32_t ipval = 0;
pico_string_to_ipv4(ipv4_str, &ipval);
ns.addr = ipval;
if((err = pico_dns_client_nameserver(&ns, PICO_DNS_NS_DEL)) < 0) {
DEBUG_ERROR("error while removing DNS nameserver, err=%d, pico_err=%d, %s",
err, pico_err, beautify_pico_error(pico_err));
}
return err;
}
void picoTCP::pico_loop(VirtualTap *tap) void picoTCP::pico_loop(VirtualTap *tap)
{ {
while(tap->_run) while(tap->_run)
@@ -232,28 +274,17 @@ namespace ZeroTier {
do { do {
n = 0; n = 0;
//DEBUG_INFO("RXbuf->count() = %d", vs->RXbuf->count());
int avail = ZT_TCP_RX_BUF_SZ - vs->RXbuf->count(); int avail = ZT_TCP_RX_BUF_SZ - vs->RXbuf->count();
if(avail) { if(avail) {
DEBUG_INFO("vs->RXbuf->get_buf()= %p", vs->RXbuf->get_buf());
DEBUG_INFO("vs->RXbuf->count() = %d", vs->RXbuf->count());
DEBUG_INFO("s = %p", s);
DEBUG_INFO("avail = %d", avail);
DEBUG_INFO("tap = %p", tap);
DEBUG_INFO("peer.ip4.addr = %p", peer.ip4.addr);
r = pico_socket_recvfrom(s, vs->RXbuf->get_buf(), ZT_STACK_SOCKET_RD_MAX, r = pico_socket_recvfrom(s, vs->RXbuf->get_buf(), ZT_STACK_SOCKET_RD_MAX,
(void *)&peer.ip4.addr, &port); (void *)&peer.ip4.addr, &port);
if (r > 0) if (r > 0)
{ {
vs->RXbuf->produce(r); vs->RXbuf->produce(r);
//DEBUG_INFO("RXbuf->count() = %d", vs->RXbuf->count());
n = tap->_phy.streamSend(vs->sock, vs->RXbuf->get_buf(), r); n = tap->_phy.streamSend(vs->sock, vs->RXbuf->get_buf(), r);
if(n>0) if(n>0)
vs->RXbuf->consume(n); vs->RXbuf->consume(n);
//DEBUG_INFO("pico_recv = %d, streamSend = %d, rxsz = %d, tot = %d", r, n, vs->RXbuf->count(), vs->tot);
//DEBUG_TRANS("[ TCP RX <- STACK] :: vs = %p, len = %d", vs, n);
} }
if(vs->RXbuf->count() == 0) { if(vs->RXbuf->count() == 0) {
tap->_phy.setNotifyWritable(vs->sock, false); tap->_phy.setNotifyWritable(vs->sock, false);
@@ -311,12 +342,12 @@ namespace ZeroTier {
in4.sin_port = port; in4.sin_port = port;
// immediately attempt to write addr and payload to app socket. The idea is that the zts_recvfrom() has // immediately attempt to write addr and payload to app socket. The idea is that the zts_recvfrom() has
// been called and will pick this up and correctly handle it // been called and will pick this up and correctly handle it
char udp_msg_buf[ZT_MAX_MTU]; // [sz : addr : payload] char udp_msg_buf[ZT_SOCKET_MSG_BUF_SZ]; // [sz : addr : payload]
int len = sizeof(struct sockaddr_in) + r; int32_t len = sizeof(struct sockaddr_storage) + r;
int tot_len = sizeof(len) + len; int32_t tot_len = sizeof(int32_t) + len;
memcpy(udp_msg_buf, &len, sizeof(len)); // len: sockaddr+payload memcpy(udp_msg_buf, &len, sizeof(int32_t)); // len: sockaddr+payload
memcpy(udp_msg_buf + sizeof(len), &in4, sizeof(in4)); // sockaddr memcpy(udp_msg_buf + sizeof(int32_t), &in4, sizeof(struct sockaddr_storage)); // sockaddr
memcpy(udp_msg_buf + sizeof(len) + sizeof(in4), &udp_payload_buf, r); // payload memcpy(udp_msg_buf + sizeof(int32_t) + sizeof(struct sockaddr_storage), &udp_payload_buf, r); // payload
if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) { if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
DEBUG_ERROR("write()=%d, errno=%d", w, errno); DEBUG_ERROR("write()=%d, errno=%d", w, errno);
} }
@@ -331,12 +362,12 @@ namespace ZeroTier {
in6.sin6_port = port; in6.sin6_port = port;
// immediately attempt to write addr and payload to app socket. The idea is that the zts_recvfrom() has // immediately attempt to write addr and payload to app socket. The idea is that the zts_recvfrom() has
// been called and will pick this up and correctly handle it // been called and will pick this up and correctly handle it
char udp_msg_buf[ZT_MAX_MTU]; // [sz : addr : payload] char udp_msg_buf[ZT_SOCKET_MSG_BUF_SZ]; // [sz : addr : payload]
int len = sizeof(struct sockaddr_in6) + r; int32_t len = sizeof(struct sockaddr_storage) + r;
int tot_len = sizeof(len) + len; int32_t tot_len = sizeof(int32_t) + len;
memcpy(udp_msg_buf, &len, sizeof(len)); // len: sockaddr+payload memcpy(udp_msg_buf, &len, sizeof(int32_t)); // len: sockaddr+payload
memcpy(udp_msg_buf + sizeof(len), &in6, sizeof(in6)); // sockaddr memcpy(udp_msg_buf + sizeof(int32_t), &in6, sizeof(struct sockaddr_storage)); // sockaddr
memcpy(udp_msg_buf + sizeof(len) + sizeof(in6), &udp_payload_buf, r); // payload memcpy(udp_msg_buf + sizeof(int32_t) + sizeof(struct sockaddr_storage), &udp_payload_buf, r); // payload
if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) { if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
DEBUG_ERROR("write()=%d, errno=%d", w, errno); DEBUG_ERROR("write()=%d, errno=%d", w, errno);
} }
@@ -364,17 +395,16 @@ namespace ZeroTier {
int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX); int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX);
if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) { if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
DEBUG_ERROR("unable to write to picosock=%p, r=%d", vs->picosock, r); DEBUG_ERROR("unable to write to pico_socket=%p, err=%d, pico_err=%d, %s",
vs->picosock, r, pico_err, beautify_pico_error(pico_err));
handle_general_failure(); handle_general_failure();
return; return;
} }
if(vs->socket_type == SOCK_STREAM) { if(vs->socket_type == SOCK_STREAM) {
//DEBUG_TRANS("[ TCP TX -> STACK] :: vs = %p, len = %d", vs, r); DEBUG_TRANS("len=%5d, [app(buf) --> network_stack(vs=%p)] proto=0x%04x (TCP)", r, vs, PICO_PROTO_TCP);
}
if(vs->socket_type == SOCK_DGRAM) {
//DEBUG_TRANS("[ UDP TX -> STACK] :: vs = %p, len = %d", vs, r);
} }
if(r == 0) { if(r == 0) {
// DEBUG_ERROR("err=%d, pico_err=%d, %s", r, pico_err, beautify_pico_error(pico_err));
// This is a peciliarity of the picoTCP network stack, if we receive no error code, and the size of // This is a peciliarity of the picoTCP network stack, if we receive no error code, and the size of
// the byte stream written is 0, this is an indication that the buffer for this pico_socket is too small // the byte stream written is 0, this is an indication that the buffer for this pico_socket is too small
// DEBUG_ERROR("pico_socket buffer is too small (adjust ZT_STACK_SOCKET_TX_SZ, ZT_STACK_SOCKET_RX_SZ)"); // DEBUG_ERROR("pico_socket buffer is too small (adjust ZT_STACK_SOCKET_TX_SZ, ZT_STACK_SOCKET_RX_SZ)");
@@ -386,7 +416,44 @@ namespace ZeroTier {
void picoTCP::pico_cb_socket_ev(uint16_t ev, struct pico_socket *s) void picoTCP::pico_cb_socket_ev(uint16_t ev, struct pico_socket *s)
{ {
int err = 0;
//DEBUG_EXTRA("s=%p, s->state=%d %s", s, s->state, beautify_pico_state(s->state)); //DEBUG_EXTRA("s=%p, s->state=%d %s", s, s->state, beautify_pico_state(s->state));
// --- handle error events ---
// PICO_SOCK_EV_FIN - triggered when the socket is closed. No further communication is
// possible from this point on the socket.
if (ev & PICO_SOCK_EV_FIN) {
DEBUG_EXTRA("PICO_SOCK_EV_FIN (socket closed), picosock=%p", s);
//DEBUG_EXTRA("PICO_SOCK_EV_FIN (socket closed), picosock=%p, vs=%p, app_fd=%d, sdk_fd=%d", s, vs, vs->app_fd, vs->sdk_fd);
//vs->closure_ts = std::time(nullptr);
}
// PICO_SOCK_EV_ERR - triggered when an error occurs.
if (ev & PICO_SOCK_EV_ERR) {
if(pico_err == PICO_ERR_ECONNRESET) {
DEBUG_ERROR("PICO_ERR_ECONNRESET");
}
//DEBUG_ERROR("PICO_SOCK_EV_ERR, err=%s, picosock=%p, app_fd=%d, sdk_fd=%d",
// beautify_pico_error(pico_err), s, vs->app_fd, vs->sdk_fd);
}
// PICO_SOCK_EV_CLOSE - triggered when a FIN segment is received (TCP only). This event
// indicates that the oher endpont has closed the VirtualSocket, so the local TCP layer is only
// allowed to send new data until a local shutdown or close is initiated. PicoTCP is able to
// keep the VirtualSocket half-open (only for sending) after the FIN packet has been received,
// allowing new data to be sent in the TCP CLOSE WAIT state.
if (ev & PICO_SOCK_EV_CLOSE) {
if((err = pico_socket_close(s)) < 0) {
DEBUG_ERROR("pico_socket_close()=%d, pico_err=%d, %s", err, pico_err, beautify_pico_error(pico_err));
}
DEBUG_EXTRA("PICO_SOCK_EV_CLOSE (socket closure) err=%d (%s), picosock=%p", pico_err, beautify_pico_error(pico_err), s);
//DEBUG_EXTRA("PICO_SOCK_EV_CLOSE (socket closure) err = %d, picosock=%p, vs=%p, app_fd=%d, sdk_fd=%d", err, s, vs, vs->app_fd, vs->sdk_fd);
//vs->closure_ts = std::time(nullptr);
return;
}
// --- handle non-error events ---
VirtualBindingPair *vbp = (VirtualBindingPair*)(s->priv); VirtualBindingPair *vbp = (VirtualBindingPair*)(s->priv);
if(!vbp) { if(!vbp) {
DEBUG_ERROR("s->priv yielded no valid VirtualBindingPair"); DEBUG_ERROR("s->priv yielded no valid VirtualBindingPair");
@@ -395,7 +462,6 @@ namespace ZeroTier {
} }
VirtualTap *tap = static_cast<VirtualTap*>(vbp->tap); VirtualTap *tap = static_cast<VirtualTap*>(vbp->tap);
VirtualSocket *vs = static_cast<VirtualSocket*>(vbp->vs); VirtualSocket *vs = static_cast<VirtualSocket*>(vbp->vs);
int err = 0;
if(!vs) { if(!vs) {
DEBUG_ERROR("invalid VirtualSocket"); DEBUG_ERROR("invalid VirtualSocket");
handle_general_failure(); handle_general_failure();
@@ -406,7 +472,7 @@ namespace ZeroTier {
// has been established, or on a listening socket, indicating that a call to pico socket accept // has been established, or on a listening socket, indicating that a call to pico socket accept
// may now be issued in order to accept the incoming VirtualSocket from a remote host. // may now be issued in order to accept the incoming VirtualSocket from a remote host.
if (ev & PICO_SOCK_EV_CONN) { if (ev & PICO_SOCK_EV_CONN) {
//DEBUG_EXTRA("PICO_SOCK_EV_CONN"); DEBUG_EXTRA("PICO_SOCK_EV_CONN");
if(vs->state == ZT_SOCK_STATE_LISTENING) if(vs->state == ZT_SOCK_STATE_LISTENING)
{ {
uint16_t port; uint16_t port;
@@ -420,9 +486,8 @@ namespace ZeroTier {
if(vs->socket_family == AF_INET6) { // NOTE: p->net->proto_number == PICO_PROTO_IPV4 if(vs->socket_family == AF_INET6) { // NOTE: p->net->proto_number == PICO_PROTO_IPV4
client_psock = pico_socket_accept(s, &orig6, &port); client_psock = pico_socket_accept(s, &orig6, &port);
} }
if(!client_psock) { if(!client_psock) {
DEBUG_ERROR("pico_err=%s, picosock=%p", beautify_pico_error(pico_err), s); DEBUG_ERROR("pico_socket_accept(): pico_socket=%p, pico_err=%d, %s", s, pico_err, beautify_pico_error(pico_err));
return; return;
} }
@@ -435,19 +500,21 @@ namespace ZeroTier {
new_vs->picosock = client_psock; new_vs->picosock = client_psock;
// TODO: Condense this // TODO: Condense this
char addrstr[INET6_ADDRSTRLEN];
if(vs->socket_family == AF_INET) { if(vs->socket_family == AF_INET) {
struct sockaddr_in in4; char addrstr[INET_ADDRSTRLEN];
in4.sin_addr.s_addr = orig4.addr; struct sockaddr_storage ss4;
in4.sin_port = Utils::hton(port); struct sockaddr_in *in4 = (struct sockaddr_in *)&ss4;
memcpy(&(new_vs->peer_addr), &in4, sizeof(new_vs->peer_addr)); in4->sin_addr.s_addr = orig4.addr;
inet_ntop(AF_INET, &(in4.sin_addr), addrstr, INET6_ADDRSTRLEN); in4->sin_port = Utils::hton(port);
memcpy(&(new_vs->peer_addr), in4, sizeof(new_vs->peer_addr));
inet_ntop(AF_INET, &(in4->sin_addr), addrstr, INET_ADDRSTRLEN);
DEBUG_EXTRA("accepted connection from: %s : %d", addrstr, port); DEBUG_EXTRA("accepted connection from: %s : %d", addrstr, port);
ZeroTier::InetAddress inet; ZeroTier::InetAddress inet;
inet.fromString(addrstr); inet.fromString(addrstr);
new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
} }
if(vs->socket_family == AF_INET6) { if(vs->socket_family == AF_INET6) {
char addrstr[INET6_ADDRSTRLEN];
struct sockaddr_in6 in6; struct sockaddr_in6 in6;
memcpy(&(in6.sin6_addr.s6_addr), &orig6, sizeof(in6.sin6_addr.s6_addr)); memcpy(&(in6.sin6_addr.s6_addr), &orig6, sizeof(in6.sin6_addr.s6_addr));
in6.sin6_port = Utils::hton(port); in6.sin6_port = Utils::hton(port);
@@ -459,7 +526,7 @@ namespace ZeroTier {
new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
} }
if(!new_vs->tap) { if(!new_vs->tap) {
DEBUG_ERROR("no valid VirtualTap could be found for this incoming connect address <%s>", addrstr); DEBUG_ERROR("no valid VirtualTap could be found");
handle_general_failure(); handle_general_failure();
return; return;
} }
@@ -474,36 +541,6 @@ namespace ZeroTier {
vs->state = ZT_SOCK_STATE_UNHANDLED_CONNECTED; vs->state = ZT_SOCK_STATE_UNHANDLED_CONNECTED;
} }
} }
// PICO_SOCK_EV_FIN - triggered when the socket is closed. No further communication is
// possible from this point on the socket.
if (ev & PICO_SOCK_EV_FIN) {
//DEBUG_EXTRA("PICO_SOCK_EV_FIN (socket closed), picosock=%p, vs=%p, app_fd=%d, sdk_fd=%d", s, vs, vs->app_fd, vs->sdk_fd);
vs->closure_ts = std::time(nullptr);
}
// PICO_SOCK_EV_ERR - triggered when an error occurs.
if (ev & PICO_SOCK_EV_ERR) {
if(pico_err == PICO_ERR_ECONNRESET) {
DEBUG_ERROR("PICO_ERR_ECONNRESET");
vs->state = PICO_ERR_ECONNRESET;
}
DEBUG_ERROR("PICO_SOCK_EV_ERR, err=%s, picosock=%p, app_fd=%d, sdk_fd=%d",
beautify_pico_error(pico_err), s, vs->app_fd, vs->sdk_fd);
}
// PICO_SOCK_EV_CLOSE - triggered when a FIN segment is received (TCP only). This event
// indicates that the oher endpont has closed the VirtualSocket, so the local TCP layer is only
// allowed to send new data until a local shutdown or close is initiated. PicoTCP is able to
// keep the VirtualSocket half-open (only for sending) after the FIN packet has been received,
// allowing new data to be sent in the TCP CLOSE WAIT state.
if (ev & PICO_SOCK_EV_CLOSE) {
if((err = pico_socket_close(s)) < 0) {
DEBUG_ERROR("pico_socket_close()=%d, %s", err, beautify_pico_error(pico_err));
}
//DEBUG_INFO("PICO_SOCK_EV_CLOSE (socket closure) err = %d, picosock=%p, vs=%p, app_fd=%d, sdk_fd=%d", err, s, vs, vs->app_fd, vs->sdk_fd);
vs->closure_ts = std::time(nullptr);
return;
}
// PICO_SOCK_EV_RD - triggered when new data arrives on the socket. A new receive action // PICO_SOCK_EV_RD - triggered when new data arrives on the socket. A new receive action
// can be taken by the socket owner because this event indicates there is new data to receive. // can be taken by the socket owner because this event indicates there is new data to receive.
if (ev & PICO_SOCK_EV_RD) { if (ev & PICO_SOCK_EV_RD) {
@@ -522,7 +559,6 @@ namespace ZeroTier {
int pico_eth_tx(struct pico_device *dev, void *buf, int len) int pico_eth_tx(struct pico_device *dev, void *buf, int len)
{ {
//_picostack_driver_lock.lock(); //_picostack_driver_lock.lock();
//DEBUG_INFO("len = %d", len);
VirtualTap *tap = static_cast<VirtualTap*>(dev->tap); VirtualTap *tap = static_cast<VirtualTap*>(dev->tap);
if(!tap) { if(!tap) {
DEBUG_ERROR("invalid dev->tap"); DEBUG_ERROR("invalid dev->tap");
@@ -536,8 +572,8 @@ namespace ZeroTier {
src_mac.setTo(ethhdr->saddr, 6); src_mac.setTo(ethhdr->saddr, 6);
dest_mac.setTo(ethhdr->daddr, 6); dest_mac.setTo(ethhdr->daddr, 6);
if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) { if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
char macBuf[18], nodeBuf[11]; char macBuf[ZT_MAC_ADDRSTRLEN], nodeBuf[ZT_ID_LEN];
mac2str(macBuf, sizeof(macBuf), ethhdr->daddr); mac2str(macBuf, ZT_MAC_ADDRSTRLEN, ethhdr->daddr);
ZeroTier::MAC mac; ZeroTier::MAC mac;
mac.setTo(ethhdr->daddr, 6); mac.setTo(ethhdr->daddr, 6);
mac.toAddress(tap->_nwid).toString(nodeBuf); mac.toAddress(tap->_nwid).toString(nodeBuf);
@@ -564,31 +600,34 @@ namespace ZeroTier {
ext/picotcp/build/include/pico_tcp.h:#define PICO_TCP_RSTACK (PICO_TCP_RST | PICO_TCP_ACK) ext/picotcp/build/include/pico_tcp.h:#define PICO_TCP_RSTACK (PICO_TCP_RST | PICO_TCP_ACK)
*/ */
char *flag_ptr = flagbuf; if(hdr) {
char *flag_ptr = flagbuf;
if (hdr->flags & PICO_TCP_PSH) { if (hdr->flags & PICO_TCP_PSH) {
sprintf(flag_ptr, "PSH "); sprintf(flag_ptr, "PSH ");
flag_ptr+=4; flag_ptr+=4;
} }
if (hdr->flags & PICO_TCP_SYN) { if (hdr->flags & PICO_TCP_SYN) {
sprintf(flag_ptr, "SYN "); sprintf(flag_ptr, "SYN ");
flag_ptr+=4; flag_ptr+=4;
} }
if (hdr->flags & PICO_TCP_ACK) { if (hdr->flags & PICO_TCP_ACK) {
sprintf(flag_ptr, "ACK "); sprintf(flag_ptr, "ACK ");
flag_ptr+=4; flag_ptr+=4;
} }
if (hdr->flags & PICO_TCP_FIN) { if (hdr->flags & PICO_TCP_FIN) {
sprintf(flag_ptr, "FIN "); sprintf(flag_ptr, "FIN ");
flag_ptr+=4; flag_ptr+=4;
} }
if (hdr->flags & PICO_TCP_RST) { if (hdr->flags & PICO_TCP_RST) {
sprintf(flag_ptr, "RST "); sprintf(flag_ptr, "RST ");
flag_ptr+=4; flag_ptr+=4;
}
} }
} }
//DEBUG_TRANS("len=%5d dst=%s [%s TX <-- %s] proto=0x%04x %s %s", len, macBuf, nodeBuf, tap->nodeId().c_str(), Utils::ntoh(ethhdr->proto), beautify_eth_proto_nums(Utils::ntoh(ethhdr->proto)), flagbuf); DEBUG_TRANS("len=%5d dst=%s [%s TX <-- %s] proto=0x%04x %s %s", len, macBuf, nodeBuf, tap->nodeId().c_str(),
Utils::ntoh(ethhdr->proto), beautify_eth_proto_nums(Utils::ntoh(ethhdr->proto)), flagbuf);
} }
tap->_handler(tap->_arg,NULL,tap->_nwid,src_mac,dest_mac, tap->_handler(tap->_arg,NULL,tap->_nwid,src_mac,dest_mac,
Utils::ntoh((uint16_t)ethhdr->proto),0, ((char*)buf) Utils::ntoh((uint16_t)ethhdr->proto),0, ((char*)buf)
@@ -615,10 +654,10 @@ namespace ZeroTier {
from.copyTo(ethhdr.saddr, 6); from.copyTo(ethhdr.saddr, 6);
to.copyTo(ethhdr.daddr, 6); to.copyTo(ethhdr.daddr, 6);
ethhdr.proto = Utils::hton((uint16_t)etherType); ethhdr.proto = Utils::hton((uint16_t)etherType);
int newlen = len + sizeof(int) + sizeof(struct pico_eth_hdr); int32_t msg_len = len + sizeof(int32_t) + sizeof(struct pico_eth_hdr);
if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) { if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
char macBuf[18], nodeBuf[11]; char macBuf[ZT_MAC_ADDRSTRLEN], nodeBuf[ZT_ID_LEN];
mac2str(macBuf, sizeof(macBuf), ethhdr.saddr); mac2str(macBuf, sizeof(macBuf), ethhdr.saddr);
ZeroTier::MAC mac; ZeroTier::MAC mac;
mac.setTo(ethhdr.saddr, 6); mac.setTo(ethhdr.saddr, 6);
@@ -637,37 +676,39 @@ namespace ZeroTier {
{ {
tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR; tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
hdr = (struct pico_tcp_hdr *)tcp_hdr_ptr; hdr = (struct pico_tcp_hdr *)tcp_hdr_ptr;
if(hdr) {
char *flag_ptr = flagbuf; char *flag_ptr = flagbuf;
if (hdr->flags & PICO_TCP_PSH) { if (hdr->flags & PICO_TCP_PSH) {
sprintf(flag_ptr, "PSH "); sprintf(flag_ptr, "PSH ");
flag_ptr+=4; flag_ptr+=4;
} }
if (hdr->flags & PICO_TCP_SYN) { if (hdr->flags & PICO_TCP_SYN) {
sprintf(flag_ptr, "SYN "); sprintf(flag_ptr, "SYN ");
flag_ptr+=4; flag_ptr+=4;
} }
if (hdr->flags & PICO_TCP_ACK) { if (hdr->flags & PICO_TCP_ACK) {
sprintf(flag_ptr, "ACK "); sprintf(flag_ptr, "ACK ");
flag_ptr+=4; flag_ptr+=4;
} }
if (hdr->flags & PICO_TCP_FIN) { if (hdr->flags & PICO_TCP_FIN) {
sprintf(flag_ptr, "FIN "); sprintf(flag_ptr, "FIN ");
flag_ptr+=4; flag_ptr+=4;
} }
if (hdr->flags & PICO_TCP_RST) { if (hdr->flags & PICO_TCP_RST) {
sprintf(flag_ptr, "RST "); sprintf(flag_ptr, "RST ");
flag_ptr+=4; flag_ptr+=4;
}
} }
} }
//DEBUG_TRANS("len=%5d src=%s [%s RX --> %s] proto=0x%04x %s %s", len, macBuf, nodeBuf, tap->nodeId().c_str(), etherType, beautify_eth_proto_nums(etherType), flagbuf); DEBUG_TRANS("len=%5d src=%s [%s RX --> %s] proto=0x%04x %s %s", len, macBuf, nodeBuf, tap->nodeId().c_str(),
etherType, beautify_eth_proto_nums(etherType), flagbuf);
} }
// write virtual ethernet frame to guarded buffer (emptied by pico_eth_poll()) // write virtual ethernet frame to guarded buffer (emptied by pico_eth_poll())
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot, &newlen, sizeof(newlen)); // size of frame + meta memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot, &msg_len, sizeof(int32_t)); // size of frame + meta
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(int32_t), &ethhdr, sizeof(ethhdr)); // new eth header
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen) + sizeof(ethhdr), data, len); // frame data memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(int32_t) + sizeof(ethhdr), data, len); // frame data
tap->pico_frame_rxbuf_tot += newlen; tap->pico_frame_rxbuf_tot += msg_len;
//_picostack_driver_lock.unlock(); //_picostack_driver_lock.unlock();
} }
@@ -680,22 +721,21 @@ namespace ZeroTier {
handle_general_failure(); handle_general_failure();
return ZT_ERR_GENERAL_FAILURE; return ZT_ERR_GENERAL_FAILURE;
} }
// TODO: Optimize // TODO: Optimize (use Ringbuffer)
Mutex::Lock _l(tap->_pico_frame_rxbuf_m); Mutex::Lock _l(tap->_pico_frame_rxbuf_m);
unsigned char frame[ZT_SDK_MTU]; unsigned char frame[ZT_SDK_MTU];
int len, err = 0; int32_t len, err = 0;
while (tap->pico_frame_rxbuf_tot > 0 && loop_score > 0) { while (tap->pico_frame_rxbuf_tot > 0 && loop_score > 0) {
//DEBUG_FLOW(" [ FBUF -> STACK] Frame buffer SZ=%d", tap->pico_frame_rxbuf_tot);
memset(frame, 0, sizeof(frame)); memset(frame, 0, sizeof(frame));
len = 0; len = 0;
memcpy(&len, tap->pico_frame_rxbuf, sizeof(len)); // get frame len // get frame len
if(len > sizeof(len)) { // meaning, since we package the len in the msg, we don't want to recv a 0-(sizeof(int)) sized frame memcpy(&len, tap->pico_frame_rxbuf, sizeof(int32_t));
//DEBUG_FLOW(" [ FBUF -> STACK] Moving FRAME of size (%d) from FBUF(sz=%d) into stack",len, tap->pico_frame_rxbuf_tot-len); if(len > sizeof(int32_t)) { // meaning, since we package the len in the msg, we don't want to recv a 0-(sizeof(int32_t)) sized frame
memcpy(frame, tap->pico_frame_rxbuf + sizeof(len), len-(sizeof(len)) ); // get frame data memcpy(frame, tap->pico_frame_rxbuf + sizeof(int32_t), len-(sizeof(int32_t)) ); // get frame data
memmove(tap->pico_frame_rxbuf, tap->pico_frame_rxbuf + len, MAX_PICO_FRAME_RX_BUF_SZ-len); // shift buffer memmove(tap->pico_frame_rxbuf, tap->pico_frame_rxbuf + len, MAX_PICO_FRAME_RX_BUF_SZ-len); // shift buffer
if((err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(len)))) < 0) { if((err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(int32_t)))) < 0) {
if(picostack) { if(picostack) {
DEBUG_ERROR("pico_stack_recv()=%d, %s", err, picostack->beautify_pico_error(pico_err)); DEBUG_ERROR("pico_stack_recv(), err=%d, pico_err=%d, %s", err, pico_err, picostack->beautify_pico_error(pico_err));
} }
} }
tap->pico_frame_rxbuf_tot-=len; tap->pico_frame_rxbuf_tot-=len;
@@ -727,33 +767,37 @@ namespace ZeroTier {
protocol_version = PICO_PROTO_IPV6; protocol_version = PICO_PROTO_IPV6;
if(socket_type == SOCK_DGRAM) { if(socket_type == SOCK_DGRAM) {
DEBUG_INFO("SOCK_DGRAM");
psock = pico_socket_open( psock = pico_socket_open(
protocol_version, PICO_PROTO_UDP, &ZeroTier::picoTCP::pico_cb_socket_ev); protocol_version, PICO_PROTO_UDP, &ZeroTier::picoTCP::pico_cb_socket_ev);
if(psock) { // configure size of UDP SND/RCV buffers if(psock) {
// configure size of UDP SND/RCV buffers
// TODO // TODO
} }
} }
if(socket_type == SOCK_STREAM) { if(socket_type == SOCK_STREAM) {
psock = pico_socket_open( psock = pico_socket_open(
protocol_version, PICO_PROTO_TCP, &ZeroTier::picoTCP::pico_cb_socket_ev); protocol_version, PICO_PROTO_TCP, &ZeroTier::picoTCP::pico_cb_socket_ev);
if(psock) { // configure size of TCP SND/RCV buffers if(psock) {
// configure size of TCP SND/RCV buffers
int tx_buf_sz = ZT_STACK_TCP_SOCKET_TX_SZ; int tx_buf_sz = ZT_STACK_TCP_SOCKET_TX_SZ;
int rx_buf_sz = ZT_STACK_TCP_SOCKET_RX_SZ; int rx_buf_sz = ZT_STACK_TCP_SOCKET_RX_SZ;
int t_err = 0; int t_err = 0;
//int value = 1; // int value = 1;
// pico_socket_setoption(psock, PICO_TCP_NODELAY, &value); // pico_socket_setoption(psock, PICO_TCP_NODELAY, &value);
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_SNDBUF, &tx_buf_sz)) < 0) if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_SNDBUF, &tx_buf_sz)) < 0)
DEBUG_ERROR("unable to set SNDBUF size, err=%d, pico_err=%d", t_err, pico_err); DEBUG_ERROR("unable to set SNDBUF size, err=%d, pico_err=%d, %s",
t_err, pico_err, beautify_pico_error(pico_err));
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_RCVBUF, &rx_buf_sz)) < 0) if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_RCVBUF, &rx_buf_sz)) < 0)
DEBUG_ERROR("unable to set RCVBUF size, err=%d, pico_err=%d", t_err, pico_err); DEBUG_ERROR("unable to set RCVBUF size, err=%d, pico_err=%d, %s",
t_err, pico_err, beautify_pico_error(pico_err));
if(ZT_SOCK_BEHAVIOR_LINGER) { if(ZT_SOCK_BEHAVIOR_LINGER) {
int linger_time_ms = ZT_SOCK_BEHAVIOR_LINGER_TIME; int linger_time_ms = ZT_SOCK_BEHAVIOR_LINGER_TIME;
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_LINGER, &linger_time_ms)) < 0) if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_LINGER, &linger_time_ms)) < 0)
DEBUG_ERROR("unable to set LINGER, err=%d, pico_err=%d", t_err, pico_err); DEBUG_ERROR("unable to set LINGER, err=%d, pico_err=%d, %s",
t_err, pico_err, beautify_pico_error(pico_err));
} }
} }
} }
@@ -779,7 +823,9 @@ namespace ZeroTier {
uint32_t ipval = 0; uint32_t ipval = 0;
pico_string_to_ipv4(ipv4_str, &ipval); pico_string_to_ipv4(ipv4_str, &ipval);
zaddr.addr = ipval; zaddr.addr = ipval;
//DEBUG_EXTRA("connecting to addr=%s port=%d", ipv4_str, Utils::ntoh(in4->sin_port)); if(vs->socket_type == SOCK_STREAM) { // connect is an implicit call for non-connection-based VirtualSockets
DEBUG_EXTRA("connecting to addr=%s port=%d", ipv4_str, Utils::ntoh(in4->sin_port));
}
err = pico_socket_connect(vs->picosock, &zaddr, in4->sin_port); err = pico_socket_connect(vs->picosock, &zaddr, in4->sin_port);
} }
if(vs->socket_family == AF_INET6) { if(vs->socket_family == AF_INET6) {
@@ -788,26 +834,22 @@ namespace ZeroTier {
char ipv6_str[INET6_ADDRSTRLEN]; char ipv6_str[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN); inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN);
pico_string_to_ipv6(ipv6_str, zaddr.addr); pico_string_to_ipv6(ipv6_str, zaddr.addr);
//DEBUG_EXTRA("connecting to addr=%s port=%d", ipv6_str, Utils::ntoh(in6->sin6_port)); if(vs->socket_type == SOCK_STREAM) {
DEBUG_EXTRA("connecting to addr=%s port=%d", ipv6_str, Utils::ntoh(in6->sin6_port));
}
err = pico_socket_connect(vs->picosock, &zaddr, in6->sin6_port); err = pico_socket_connect(vs->picosock, &zaddr, in6->sin6_port);
} }
if(err) { if(err) {
DEBUG_ERROR("err=%d, %s", err, beautify_pico_error(pico_err)); DEBUG_ERROR("error connecting pico_socket=%p, err=%d, pico_err=%d, %s",
vs->picosock, err, pico_err, beautify_pico_error(pico_err));
return map_pico_err_to_errno(pico_err);
} }
memcpy(&(vs->peer_addr), &addr, sizeof(struct sockaddr_storage)); memcpy(&(vs->peer_addr), &addr, sizeof(struct sockaddr_storage));
if(err == PICO_ERR_EPROTONOSUPPORT)
DEBUG_ERROR("PICO_ERR_EPROTONOSUPPORT");
if(err == PICO_ERR_EINVAL)
DEBUG_ERROR("PICO_ERR_EINVAL");
if(err == PICO_ERR_EHOSTUNREACH)
DEBUG_ERROR("PICO_ERR_EHOSTUNREACH");
return err; return err;
} }
int picoTCP::pico_Bind(VirtualSocket *vs, const struct sockaddr *addr, socklen_t addrlen) int picoTCP::pico_Bind(VirtualSocket *vs, const struct sockaddr *addr, socklen_t addrlen)
{ {
//DEBUG_INFO();
if(!vs || !vs->picosock) { if(!vs || !vs->picosock) {
DEBUG_ERROR("invalid vs or vs->picosock"); DEBUG_ERROR("invalid vs or vs->picosock");
handle_general_failure(); handle_general_failure();
@@ -837,49 +879,25 @@ namespace ZeroTier {
err = pico_socket_bind(vs->picosock, &pip6, (uint16_t *)&(in6->sin6_port)); err = pico_socket_bind(vs->picosock, &pip6, (uint16_t *)&(in6->sin6_port));
} }
if(err < 0) { if(err < 0) {
if(pico_err < 0) DEBUG_ERROR("unable to bind pico_socket=%p, err=%d, pico_err=%d, %s",
DEBUG_ERROR("pico_err = %d", pico_err); (vs->picosock), err, pico_err, beautify_pico_error(pico_err));
DEBUG_ERROR("unable to bind pico_socket(%p), err=%d", (vs->picosock), err); return map_pico_err_to_errno(pico_err);
if(err == PICO_ERR_EINVAL) {
DEBUG_ERROR("PICO_ERR_EINVAL - invalid argument");
errno = EINVAL;
return -1;
}
if(err == PICO_ERR_ENOMEM) {
DEBUG_ERROR("PICO_ERR_ENOMEM - not enough space");
errno = ENOMEM;
return -1;
}
if(err == PICO_ERR_ENXIO) {
DEBUG_ERROR("PICO_ERR_ENXIO - no such device or address");
errno = ENXIO;
return -1;
}
} }
return err; return err;
} }
int picoTCP::pico_Listen(VirtualSocket *vs, int backlog) int picoTCP::pico_Listen(VirtualSocket *vs, int backlog)
{ {
//DEBUG_INFO();
if(!vs || !vs->picosock) { if(!vs || !vs->picosock) {
DEBUG_ERROR("invalid vs or vs->picosock"); DEBUG_ERROR("invalid vs or vs->picosock");
handle_general_failure(); handle_general_failure();
return ZT_ERR_GENERAL_FAILURE; return ZT_ERR_GENERAL_FAILURE;
} }
int err = 0; int err = 0;
if((err = pico_socket_listen(vs->picosock, backlog)) < 0) if((err = pico_socket_listen(vs->picosock, backlog)) < 0) {
{ DEBUG_ERROR("error putting pico_socket=%p into listening state. err=%d, pico_err=%d, %s",
if(err == PICO_ERR_EINVAL) { vs->picosock, err, pico_err, beautify_pico_error(pico_err));
DEBUG_ERROR("PICO_ERR_EINVAL"); return map_pico_err_to_errno(pico_err);
errno = EINVAL;
return -1;
}
if(err == PICO_ERR_EISCONN) {
DEBUG_ERROR("PICO_ERR_EISCONN");
errno = EISCONN;
return -1;
}
} }
vs->state = ZT_SOCK_STATE_LISTENING; vs->state = ZT_SOCK_STATE_LISTENING;
return ZT_ERR_OK; return ZT_ERR_OK;
@@ -936,7 +954,7 @@ namespace ZeroTier {
if(vs->socket_type == SOCK_DGRAM) { if(vs->socket_type == SOCK_DGRAM) {
int r; int r;
if((r = pico_socket_write(vs->picosock, data, len)) < 0) { if((r = pico_socket_write(vs->picosock, data, len)) < 0) {
DEBUG_ERROR("unable to write to picosock=%p, err=%d (%s)", DEBUG_ERROR("unable to write to picosock=%p, err=%d, pico_err=%d, %s",
vs->picosock, r, pico_err, beautify_pico_error(pico_err)); vs->picosock, r, pico_err, beautify_pico_error(pico_err));
err = -1; err = -1;
} }
@@ -962,7 +980,8 @@ namespace ZeroTier {
int txsz = vs->TXbuf->count(); int txsz = vs->TXbuf->count();
int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX); int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX);
if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) { if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
DEBUG_ERROR("unable to write to picosock=%p, r=%d", vs->picosock, r); DEBUG_ERROR("unable to write to picosock=%p, err=%d, pico_err=%d, %s",
vs->picosock, r, pico_err, beautify_pico_error(pico_err));
err = -1; err = -1;
} }
else { else {
@@ -971,7 +990,12 @@ namespace ZeroTier {
if(r>0){ if(r>0){
vs->TXbuf->consume(r); vs->TXbuf->consume(r);
} }
DEBUG_TRANS("[ TCP TX -> STACK] :: vs=%p, len=%d", vs, r); if(vs->socket_type == SOCK_STREAM) {
DEBUG_TRANS("len=%5d, [app(buf) --> network_stack(vs=%p)] proto=0x%04x (TCP)", r, vs, PICO_PROTO_TCP);
}
if(vs->socket_type == SOCK_DGRAM) {
DEBUG_TRANS("len=%5d, [app(buf) --> network_stack(vs=%p)] proto=0x%04x (TCP)", r, vs, PICO_PROTO_UDP);
}
} }
return err; return err;
} }
@@ -983,7 +1007,7 @@ namespace ZeroTier {
handle_general_failure(); handle_general_failure();
return ZT_ERR_GENERAL_FAILURE; return ZT_ERR_GENERAL_FAILURE;
} }
DEBUG_INFO("vs=%p, picosock=%p, fd=%d", vs, vs->picosock, vs->app_fd); DEBUG_EXTRA("vs=%p, picosock=%p, fd=%d", vs, vs->picosock, vs->app_fd);
if(!vs || !vs->picosock) if(!vs || !vs->picosock)
return ZT_ERR_GENERAL_FAILURE; return ZT_ERR_GENERAL_FAILURE;
int err = 0; int err = 0;
@@ -992,11 +1016,47 @@ namespace ZeroTier {
return ZT_ERR_OK; return ZT_ERR_OK;
if((err = pico_socket_close(vs->picosock)) < 0) { if((err = pico_socket_close(vs->picosock)) < 0) {
errno = pico_err; errno = pico_err;
DEBUG_ERROR("error closing pico_socket(%p)", (void*)(vs->picosock)); DEBUG_ERROR("error closing pico_socket(%p), err=%d, pico_err=%s, %s",
(void*)(vs->picosock), err, pico_err, beautify_pico_error(pico_err));
} }
return err; return err;
} }
int picoTCP::map_pico_err_to_errno(int err)
{
if(err == PICO_ERR_NOERR) { errno = 0; return 0; } //
if(err == PICO_ERR_EPERM) { errno = ENXIO; }
if(err == PICO_ERR_ENOENT) { errno = ENXIO; }
if(err == PICO_ERR_EINTR) { errno = ENXIO; }
if(err == PICO_ERR_EIO) { errno = ENXIO; }
if(err == PICO_ERR_ENXIO) { errno = ENXIO; } //
if(err == PICO_ERR_EAGAIN) { errno = ENXIO; }
if(err == PICO_ERR_ENOMEM) { errno = ENOMEM; } //
if(err == PICO_ERR_EACCESS) { errno = ENXIO; }
if(err == PICO_ERR_EFAULT) { errno = ENXIO; }
if(err == PICO_ERR_EBUSY) { errno = ENXIO; }
if(err == PICO_ERR_EEXIST) { errno = ENXIO; }
if(err == PICO_ERR_EINVAL) { errno = EINVAL; } //
if(err == PICO_ERR_ENONET) { errno = ENXIO; }
if(err == PICO_ERR_EPROTO) { errno = ENXIO; }
if(err == PICO_ERR_ENOPROTOOPT) { errno = ENXIO; }
if(err == PICO_ERR_EPROTONOSUPPORT) { errno = ENXIO; }
if(err == PICO_ERR_EOPNOTSUPP) { errno = ENXIO; }
if(err == PICO_ERR_EADDRINUSE) { errno = ENXIO; }
if(err == PICO_ERR_EADDRNOTAVAIL) { errno = ENXIO; }
if(err == PICO_ERR_ENETDOWN) { errno = ENXIO; }
if(err == PICO_ERR_ENETUNREACH) { errno = ENXIO; }
if(err == PICO_ERR_ECONNRESET) { errno = ENXIO; }
if(err == PICO_ERR_EISCONN) { errno = ENXIO; }
if(err == PICO_ERR_ENOTCONN) { errno = ENXIO; }
if(err == PICO_ERR_ESHUTDOWN) { errno = ENXIO; }
if(err == PICO_ERR_ETIMEDOUT) { errno = ENXIO; }
if(err == PICO_ERR_ECONNREFUSED) { errno = ENXIO; }
if(err == PICO_ERR_EHOSTDOWN) { errno = ENXIO; }
if(err == PICO_ERR_EHOSTUNREACH) { errno = ENXIO; }
return -1;
}
char *picoTCP::beautify_pico_error(int err) char *picoTCP::beautify_pico_error(int err)
{ {
if(err== 0) return (char*)"PICO_ERR_NOERR"; if(err== 0) return (char*)"PICO_ERR_NOERR";
@@ -1005,17 +1065,17 @@ namespace ZeroTier {
// ... // ...
if(err== 4) return (char*)"PICO_ERR_EINTR"; if(err== 4) return (char*)"PICO_ERR_EINTR";
if(err== 5) return (char*)"PICO_ERR_EIO"; if(err== 5) return (char*)"PICO_ERR_EIO";
if(err== 6) return (char*)"PICO_ERR_ENXIO"; if(err== 6) return (char*)"PICO_ERR_ENXIO (no such device or address)";
// ... // ...
if(err== 11) return (char*)"PICO_ERR_EAGAIN"; if(err== 11) return (char*)"PICO_ERR_EAGAIN";
if(err== 12) return (char*)"PICO_ERR_ENOMEM"; if(err== 12) return (char*)"PICO_ERR_ENOMEM (not enough space)";
if(err== 13) return (char*)"PICO_ERR_EACCESS"; if(err== 13) return (char*)"PICO_ERR_EACCESS";
if(err== 14) return (char*)"PICO_ERR_EFAULT"; if(err== 14) return (char*)"PICO_ERR_EFAULT";
// ... // ...
if(err== 16) return (char*)"PICO_ERR_EBUSY"; if(err== 16) return (char*)"PICO_ERR_EBUSY";
if(err== 17) return (char*)"PICO_ERR_EEXIST"; if(err== 17) return (char*)"PICO_ERR_EEXIST";
// ... // ...
if(err== 22) return (char*)"PICO_ERR_EINVAL"; if(err== 22) return (char*)"PICO_ERR_EINVAL (invalid argument)";
// ... // ...
if(err== 64) return (char*)"PICO_ERR_ENONET"; if(err== 64) return (char*)"PICO_ERR_ENONET";
// ... // ...

16
src/picoTCP.hpp
View File

@@ -71,6 +71,7 @@
#define PICO_IPV4_ROUTE_DEL_SIG struct pico_ip4 address, struct pico_ip4 netmask, int metric #define PICO_IPV4_ROUTE_DEL_SIG struct pico_ip4 address, struct pico_ip4 netmask, int metric
#define PICO_IPV6_ROUTE_ADD_SIG struct pico_ip6 address, struct pico_ip6 netmask, struct pico_ip6 gateway, int metric, struct pico_ipv6_link *link #define PICO_IPV6_ROUTE_ADD_SIG struct pico_ip6 address, struct pico_ip6 netmask, struct pico_ip6 gateway, int metric, struct pico_ipv6_link *link
#define PICO_IPV6_ROUTE_DEL_SIG struct pico_ip6 address, struct pico_ip6 netmask, struct pico_ip6 gateway, int metric, struct pico_ipv6_link *link #define PICO_IPV6_ROUTE_DEL_SIG struct pico_ip6 address, struct pico_ip6 netmask, struct pico_ip6 gateway, int metric, struct pico_ipv6_link *link
#define PICO_DNS_CLIENT_NAMESERVER_SIG pico_ip4*, unsigned char
namespace ZeroTier namespace ZeroTier
{ {
@@ -111,6 +112,16 @@ namespace ZeroTier
*/ */
bool pico_route_del(VirtualTap *tap, const InetAddress &addr, const InetAddress &nm, int metric); bool pico_route_del(VirtualTap *tap, const InetAddress &addr, const InetAddress &nm, int metric);
/*
* Registers a DNS nameserver with the network stack
*/
int pico_add_dns_nameserver(struct sockaddr *addr);
/*
* Un-registers a DNS nameserver from the network stack
*/
int pico_del_dns_nameserver(struct sockaddr *addr);
/* /*
* Main stack loop * Main stack loop
*/ */
@@ -181,6 +192,11 @@ namespace ZeroTier
*/ */
int pico_Close(VirtualSocket *vs); int pico_Close(VirtualSocket *vs);
/*
* Converts a pico_err to its most closely-related errno, and sets errno
*/
static int map_pico_err_to_errno(int err);
/* /*
* Converts picoTCP error codes to pretty string * Converts picoTCP error codes to pretty string
*/ */

229
test/selftest.cpp
View File

@@ -240,8 +240,9 @@ void RECORD_RESULTS(int *test_number, bool passed, char *details, std::vector<st
// //
void tcp_client_4(TCP_UNIT_TEST_SIG_4) void tcp_client_4(TCP_UNIT_TEST_SIG_4)
{ {
std::string msg = "tcp_client_4"; std::string testname = "tcp_client_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "tcp_cs_4";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str()); int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -249,7 +250,6 @@ void tcp_client_4(TCP_UNIT_TEST_SIG_4)
DEBUG_ERROR("error creating ZeroTier socket"); DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0)
DEBUG_ERROR("error connecting to remote host (%d)", err); DEBUG_ERROR("error connecting to remote host (%d)", err);
// TODO: Put this test in the general API section // TODO: Put this test in the general API section
struct sockaddr_storage peer_addr; struct sockaddr_storage peer_addr;
struct sockaddr_in *in4 = (struct sockaddr_in*)&peer_addr; struct sockaddr_in *in4 = (struct sockaddr_in*)&peer_addr;
@@ -263,15 +263,16 @@ void tcp_client_4(TCP_UNIT_TEST_SIG_4)
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
// //
void tcp_server_4(TCP_UNIT_TEST_SIG_4) void tcp_server_4(TCP_UNIT_TEST_SIG_4)
{ {
std::string msg = "tcp_server_4"; std::string testname = "tcp_server_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "tcp_cs_4";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int w=0, r=0, sockfd, accfd, err, len = strlen(msg.c_str()); int w=0, r=0, sockfd, accfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -283,7 +284,6 @@ void tcp_server_4(TCP_UNIT_TEST_SIG_4)
printf("error placing socket in LISTENING state (%d)", err); printf("error placing socket in LISTENING state (%d)", err);
if((accfd = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0) if((accfd = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0)
DEBUG_ERROR("error accepting connection (%d)", err); DEBUG_ERROR("error accepting connection (%d)", err);
// TODO: Put this test in the general API section // TODO: Put this test in the general API section
struct sockaddr_storage peer_addr; struct sockaddr_storage peer_addr;
struct sockaddr_in *in4 = (struct sockaddr_in*)&peer_addr; struct sockaddr_in *in4 = (struct sockaddr_in*)&peer_addr;
@@ -297,15 +297,16 @@ void tcp_server_4(TCP_UNIT_TEST_SIG_4)
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
err = zts_close(accfd); err = zts_close(accfd);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
// //
void tcp_client_6(TCP_UNIT_TEST_SIG_6) void tcp_client_6(TCP_UNIT_TEST_SIG_6)
{ {
std::string msg = "tcp_client_6"; std::string testname = "tcp_client_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "tcp_cs_6";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str()); int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -313,7 +314,6 @@ void tcp_client_6(TCP_UNIT_TEST_SIG_6)
DEBUG_ERROR("error creating ZeroTier socket"); DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0) if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0)
DEBUG_ERROR("error connecting to remote host (%d)", err); DEBUG_ERROR("error connecting to remote host (%d)", err);
// TODO: Put this test in the general API section // TODO: Put this test in the general API section
struct sockaddr_storage peer_addr; struct sockaddr_storage peer_addr;
struct sockaddr_in6 *p6 = (struct sockaddr_in6*)&peer_addr; struct sockaddr_in6 *p6 = (struct sockaddr_in6*)&peer_addr;
@@ -327,7 +327,7 @@ void tcp_client_6(TCP_UNIT_TEST_SIG_6)
r = zts_read(sockfd, rbuf, len); r = zts_read(sockfd, rbuf, len);
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str()); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -336,8 +336,9 @@ void tcp_client_6(TCP_UNIT_TEST_SIG_6)
// //
void tcp_server_6(TCP_UNIT_TEST_SIG_6) void tcp_server_6(TCP_UNIT_TEST_SIG_6)
{ {
std::string msg = "tcp_sever_6"; std::string testname = "tcp_sever_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "tcp_cs_6";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int w=0, r=0, sockfd, accfd, err, len = strlen(msg.c_str()); int w=0, r=0, sockfd, accfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -349,7 +350,6 @@ void tcp_server_6(TCP_UNIT_TEST_SIG_6)
DEBUG_ERROR("error placing socket in LISTENING state (%d)", err); DEBUG_ERROR("error placing socket in LISTENING state (%d)", err);
if((accfd = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0) if((accfd = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0)
DEBUG_ERROR("error accepting connection (%d)", err); DEBUG_ERROR("error accepting connection (%d)", err);
// TODO: Put this test in the general API section // TODO: Put this test in the general API section
struct sockaddr_storage peer_addr; struct sockaddr_storage peer_addr;
struct sockaddr_in6 *p6 = (struct sockaddr_in6*)&peer_addr; struct sockaddr_in6 *p6 = (struct sockaddr_in6*)&peer_addr;
@@ -365,7 +365,7 @@ void tcp_server_6(TCP_UNIT_TEST_SIG_6)
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
err = zts_close(accfd); err = zts_close(accfd);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
@@ -374,8 +374,9 @@ void tcp_server_6(TCP_UNIT_TEST_SIG_6)
// //
void udp_client_4(UDP_UNIT_TEST_SIG_4) void udp_client_4(UDP_UNIT_TEST_SIG_4)
{ {
std::string msg = "udp_client_4"; std::string testname = "udp_client_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "udp_cs_4";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str()); int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -384,11 +385,11 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
DEBUG_ERROR("error creating ZeroTier socket"); DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0)) if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0))
std::cout << "error setting O_NONBLOCK (errno=" << strerror(errno) << ")" << std::endl; std::cout << "error setting O_NONBLOCK (errno=" << strerror(errno) << ")" << std::endl;
fprintf(stderr, "sending UDP packets until I get a single response...\n"); DEBUG_INFO("sending UDP packets until I get a single response...\n");
if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in)) < 0)) if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in)) < 0))
DEBUG_ERROR("error binding to interface (%d)", err); DEBUG_ERROR("error binding to interface (%d)", err);
struct sockaddr_in saddr; struct sockaddr_storage saddr;
while(1) { while(1) {
// tx // tx
if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) { if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
@@ -402,8 +403,8 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
if(r == strlen(msg.c_str())) { if(r == strlen(msg.c_str())) {
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w); DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", testname.c_str(), count, err, r, w);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str()); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -414,8 +415,9 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
void udp_server_4(UDP_UNIT_TEST_SIG_4) void udp_server_4(UDP_UNIT_TEST_SIG_4)
{ {
std::string msg = "udp_server_4"; std::string testname = "udp_server_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "udp_cs_4";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str()); int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -426,32 +428,33 @@ void udp_server_4(UDP_UNIT_TEST_SIG_4)
DEBUG_ERROR("error binding to interface (%d)", err); DEBUG_ERROR("error binding to interface (%d)", err);
// rx // rx
DEBUG_INFO("waiting for UDP packet..."); DEBUG_INFO("waiting for UDP packet...");
struct sockaddr_in saddr; struct sockaddr_storage saddr;
struct sockaddr_in *in4 = (struct sockaddr_in*)&saddr;
int serverlen = sizeof(saddr); int serverlen = sizeof(saddr);
memset(&saddr, 0, sizeof(saddr)); memset(&saddr, 0, sizeof(saddr));
r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen); r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)in4, (socklen_t *)&serverlen);
char addrstr[INET_ADDRSTRLEN]; char addrstr[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(saddr.sin_addr), addrstr, INET_ADDRSTRLEN); inet_ntop(AF_INET, &(in4->sin_addr), addrstr, INET_ADDRSTRLEN);
// once we receive a UDP packet, spend 10 seconds sending responses in the hopes that the client will see // once we receive a UDP packet, spend 10 seconds sending responses in the hopes that the client will see
DEBUG_INFO("received DGRAM from %s : %d", inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port)); DEBUG_INFO("received DGRAM from %s : %d", inet_ntoa(in4->sin_addr), ntohs(in4->sin_port));
DEBUG_INFO("sending DGRAM(s) to %s : %d", inet_ntoa(remote_addr->sin_addr), ntohs(remote_addr->sin_port)); DEBUG_INFO("sending DGRAM(s) to %s : %d", inet_ntoa(remote_addr->sin_addr), ntohs(remote_addr->sin_port));
// tx // tx
long int tx_ti = get_now_ts(); long int tx_ti = get_now_ts();
while(1) { while(1) {
sleep(1); sleep(1);
//DEBUG_INFO("sending UDP packet"); //DEBUG_INFO("sending UDP packet");
if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) { if((w = zts_sendto(sockfd, msg.c_str(), len, 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
DEBUG_ERROR("error sending packet, err=%d", errno); DEBUG_ERROR("error sending packet, err=%d", errno);
} }
if(get_now_ts() >= tx_ti + 20000) { if(get_now_ts() >= tx_ti + 20000) {
DEBUG_INFO("get_now_ts()-tx_ti=%d\n", get_now_ts()-tx_ti); DEBUG_INFO("get_now_ts()-tx_ti=%d", get_now_ts()-tx_ti);
break; break;
} }
} }
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
//err = zts_close(sockfd); //err = zts_close(sockfd);
DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w); DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", testname.c_str(), count, err, r, w);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str()); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -460,8 +463,9 @@ void udp_server_4(UDP_UNIT_TEST_SIG_4)
// //
void udp_client_6(UDP_UNIT_TEST_SIG_6) void udp_client_6(UDP_UNIT_TEST_SIG_6)
{ {
std::string msg = "udp_client_6"; std::string testname = "udp_client_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "udp_cs_6";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str()); int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -470,28 +474,29 @@ void udp_client_6(UDP_UNIT_TEST_SIG_6)
DEBUG_ERROR("error creating ZeroTier socket"); DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0)) if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0))
std::cout << "error setting O_NONBLOCK (errno=" << strerror(errno) << ")" << std::endl; std::cout << "error setting O_NONBLOCK (errno=" << strerror(errno) << ")" << std::endl;
DEBUG_INFO("[1] sending UDP packets until I get a single response...\n");
DEBUG_INFO("[1] binding and sending UDP packets until I get a single response...");
if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0)) if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0))
DEBUG_ERROR("error binding to interface (%d)", err); DEBUG_ERROR("error binding to interface (%d)", err);
// start sending UDP packets in the hopes that at least one will be picked up by the server // start sending UDP packets in the hopes that at least one will be picked up by the server
struct sockaddr_in saddr; struct sockaddr_storage saddr;
while(1) { while(1) {
// tx // tx
if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) { if((w = zts_sendto(sockfd, msg.c_str(), len, 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
DEBUG_ERROR("error sending packet, err=%d", errno); DEBUG_ERROR("error sending packet, err=%d", errno);
} }
usleep(100000); usleep(100000);
memset(rbuf, 0, sizeof(rbuf)); memset(rbuf, 0, sizeof(rbuf));
int serverlen = sizeof(remote_addr); int serverlen = sizeof(remote_addr);
// rx // rx
r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen); r = zts_recvfrom(sockfd, rbuf, len, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
if(r == strlen(msg.c_str())) { if(r == len) {
DEBUG_INFO("[2] complete"); DEBUG_INFO("[2] complete");
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w); DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str()); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -502,8 +507,9 @@ void udp_client_6(UDP_UNIT_TEST_SIG_6)
void udp_server_6(UDP_UNIT_TEST_SIG_6) void udp_server_6(UDP_UNIT_TEST_SIG_6)
{ {
std::string msg = "udp_server_6"; std::string testname = "udp_server_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "udp_cs_6";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str()); int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -513,16 +519,17 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0)) if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0))
DEBUG_ERROR("error binding to interface (%d)", err); DEBUG_ERROR("error binding to interface (%d)", err);
// rx // rx
DEBUG_INFO("[1/4] waiting for UDP packet...\n"); DEBUG_INFO("[1/4] waiting for UDP packet to start test...");
struct sockaddr_in6 saddr; struct sockaddr_storage saddr;
struct sockaddr_in6 *in6 = (struct sockaddr_in6*)&saddr;
int serverlen = sizeof(saddr); int serverlen = sizeof(saddr);
memset(&saddr, 0, sizeof(saddr)); memset(&saddr, 0, sizeof(saddr));
r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen); r = zts_recvfrom(sockfd, rbuf, len, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
char addrstr[INET6_ADDRSTRLEN], remote_addrstr[INET6_ADDRSTRLEN]; char addrstr[INET6_ADDRSTRLEN], remote_addrstr[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, &(saddr.sin6_addr), addrstr, INET6_ADDRSTRLEN); inet_ntop(AF_INET6, &(in6->sin6_addr), addrstr, INET6_ADDRSTRLEN);
inet_ntop(AF_INET6, &(remote_addr->sin6_addr), remote_addrstr, INET6_ADDRSTRLEN); inet_ntop(AF_INET6, &(remote_addr->sin6_addr), remote_addrstr, INET6_ADDRSTRLEN);
DEBUG_INFO("[2/4] received DGRAM from %s : %d", addrstr, ntohs(saddr.sin6_port)); DEBUG_INFO("[2/4] received DGRAM from %s : %d", addrstr, ntohs(in6->sin6_port));
DEBUG_INFO("[2/4] sending DGRAM(s) to %s : %d", remote_addrstr, ntohs(remote_addr->sin6_port)); DEBUG_INFO("[2/4] sending DGRAM(s) to %s : %d", remote_addrstr, ntohs(remote_addr->sin6_port));
// once we receive a UDP packet, spend 10 seconds sending responses in the hopes that the client will see // once we receive a UDP packet, spend 10 seconds sending responses in the hopes that the client will see
// tx // tx
@@ -530,19 +537,18 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
while(1) { while(1) {
usleep(100000); usleep(100000);
//DEBUG_INFO("sending UDP packet"); //DEBUG_INFO("sending UDP packet");
if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) { if((w = zts_sendto(sockfd, msg.c_str(), len, 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
DEBUG_ERROR("error sending packet, err=%d", errno); DEBUG_ERROR("error sending packet, err=%d", errno);
} }
if(get_now_ts() >= tx_ti + 20000) { if(get_now_ts() >= tx_ti + 20000) {
DEBUG_INFO("[3/4] get_now_ts()-tx_ti=%d\n", get_now_ts()-tx_ti); DEBUG_INFO("[3/4] get_now_ts()-tx_ti=%d", get_now_ts()-tx_ti);
break; break;
} }
} }
DEBUG_INFO("[4/4] complete");
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
//err = zts_close(sockfd); //err = zts_close(sockfd);
DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w); DEBUG_INFO("[4/4] complete, %s, n=%d, err=%d, r=%d, w=%d\n", testname.c_str(), count, err, r, w);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str()); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -557,8 +563,9 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
// Maintain transfer for count OR count // Maintain transfer for count OR count
void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4) void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
{ {
std::string msg = "tcp_client_sustained_4"; std::string testname = "tcp_client_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "tcp_sustained_4";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int n=0, w=0, r=0, sockfd, err; int n=0, w=0, r=0, sockfd, err;
char *rxbuf = (char*)malloc(count*sizeof(char)); char *rxbuf = (char*)malloc(count*sizeof(char));
char *txbuf = (char*)malloc(count*sizeof(char)); char *txbuf = (char*)malloc(count*sizeof(char));
@@ -621,7 +628,7 @@ void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
float rx_rate = (float)count / (float)rx_dt; float rx_rate = (float)count / (float)rx_dt;
sprintf(details, "%s, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", sprintf(details, "%s, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s",
msg.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) )); testname.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
*passed = (r == count && w == count && match && err>=0); *passed = (r == count && w == count && match && err>=0);
} }
@@ -634,11 +641,13 @@ void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
// Maintain transfer for count OR count // Maintain transfer for count OR count
void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6) void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
{ {
std::string msg = "tcp_server_sustained_6"; std::string testname = "tcp_client_sustained_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "tcp_sustained_6";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int n=0, w=0, r=0, sockfd, err; int n=0, w=0, r=0, sockfd, err;
char *rxbuf = (char*)malloc(count*sizeof(char)); char *rxbuf = (char*)malloc(count*sizeof(char));
char *txbuf = (char*)malloc(count*sizeof(char)); char *txbuf = (char*)malloc(count*sizeof(char));
generate_random_data(txbuf, count); generate_random_data(txbuf, count);
if((sockfd = zts_socket(AF_INET6, SOCK_STREAM, 0)) < 0) if((sockfd = zts_socket(AF_INET6, SOCK_STREAM, 0)) < 0)
@@ -699,7 +708,7 @@ void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
float rx_rate = (float)count / (float)rx_dt; float rx_rate = (float)count / (float)rx_dt;
sprintf(details, "%s, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", sprintf(details, "%s, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s",
msg.c_str(), msg.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) )); testname.c_str(), msg.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
*passed = (r == count && w == count && match && err>=0); *passed = (r == count && w == count && match && err>=0);
} }
@@ -711,15 +720,16 @@ void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
// Maintain transfer for count OR count // Maintain transfer for count OR count
void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4) void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
{ {
std::string msg = "tcp_server_sustained_4"; std::string testname = "tcp_server_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "tcp_sustained_4";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int n=0, w=0, r=0, sockfd, accfd, err; int n=0, w=0, r=0, sockfd, accfd, err;
char *rxbuf = (char*)malloc(count*sizeof(char)); char *rxbuf = (char*)malloc(count*sizeof(char));
memset(rxbuf, 0, count); memset(rxbuf, 0, count);
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0)
DEBUG_ERROR("error creating ZeroTier socket"); DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_bind(sockfd, (struct sockaddr *)addr, (socklen_t)sizeof(struct sockaddr_in)) < 0)) if((err = zts_bind(sockfd, (struct sockaddr *)addr, (socklen_t)sizeof(addr)) < 0))
DEBUG_ERROR("error binding to interface (%d)", err); DEBUG_ERROR("error binding to interface (%d)", err);
if((err = zts_listen(sockfd, 1)) < 0) if((err = zts_listen(sockfd, 1)) < 0)
DEBUG_ERROR("error placing socket in LISTENING state (%d)", err); DEBUG_ERROR("error placing socket in LISTENING state (%d)", err);
@@ -767,7 +777,7 @@ void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
float rx_rate = (float)count / (float)rx_dt; float rx_rate = (float)count / (float)rx_dt;
sprintf(details, "%s, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", sprintf(details, "%s, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s",
msg.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) )); testname.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
*passed = (r == count && w == count && err>=0); *passed = (r == count && w == count && err>=0);
} }
@@ -778,8 +788,9 @@ void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
// Maintain transfer for count OR count // Maintain transfer for count OR count
void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6) void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
{ {
std::string msg = "tcp_server_sustained_6"; std::string testname = "tcp_server_sustained_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "tcp_sustained_6";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int n=0, w=0, r=0, sockfd, accfd, err; int n=0, w=0, r=0, sockfd, accfd, err;
char *rxbuf = (char*)malloc(count*sizeof(char)); char *rxbuf = (char*)malloc(count*sizeof(char));
memset(rxbuf, 0, count); memset(rxbuf, 0, count);
@@ -832,7 +843,7 @@ void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
float rx_rate = (float)count / (float)rx_dt; float rx_rate = (float)count / (float)rx_dt;
sprintf(details, "%s, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", sprintf(details, "%s, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s",
msg.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) )); testname.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
*passed = (r == count && w == count && err>=0); *passed = (r == count && w == count && err>=0);
} }
@@ -841,8 +852,9 @@ void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4) void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
{ {
std::string msg = "udp_client_sustained_4"; std::string testname = "udp_client_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "udp_sustained_4";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str()); int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -858,7 +870,7 @@ void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str()); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -866,8 +878,9 @@ void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
void udp_server_sustained_4(TCP_UNIT_TEST_SIG_4) void udp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
{ {
std::string msg = "udp_server_sustained_4"; std::string testname = "udp_server_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str()); std::string msg = "udp_sustained_4";
fprintf(stderr, "\n\n%s\n\n", testname.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str()); int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -888,7 +901,7 @@ void udp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
w = r; w = r;
//sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); //sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
//err = zts_close(sockfd); //err = zts_close(sockfd);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str()); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str()); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -1524,11 +1537,19 @@ void test_bad_args()
DEBUG_TEST("SOCK_DGRAM = %d", SOCK_DGRAM); DEBUG_TEST("SOCK_DGRAM = %d", SOCK_DGRAM);
} }
void close_while_writing_test() void dns_test(struct sockaddr *addr)
{ {
// TODO: Close a socket while another thread is writing to it or reading from it fprintf(stderr, "\n\ndns_test\n\n");
zts_add_dns_nameserver(addr);
// resolve
zts_del_dns_nameserver(addr);
} }
void close_while_writing_test()
{
fprintf(stderr, "\n\nclose_while_writing_test\n\n");
// TODO: Close a socket while another thread is writing to it or reading from it
}
void* create_socket(void *arg) void* create_socket(void *arg)
{ {
@@ -1553,6 +1574,7 @@ void* create_socket(void *arg)
void multithread_socket_creation() void multithread_socket_creation()
{ {
fprintf(stderr, "\n\nmultithread_socket_creation\n\n");
/* /*
pthread_t tid[2]; pthread_t tid[2];
@@ -1567,12 +1589,14 @@ void multithread_socket_creation()
void multithread_rw() void multithread_rw()
{ {
fprintf(stderr, "\n\nmultithread_rw\n\n");
// TODO: Test read/writes from multiple threads // TODO: Test read/writes from multiple threads
} }
// Tests rapid opening and closure of sockets // Tests rapid opening and closure of sockets
void close_test(struct sockaddr *bind_addr) void close_test(struct sockaddr *bind_addr)
{ {
fprintf(stderr, "\n\nclose_test\n\n");
// BUG: While running an extended test of unassigned closures, the // BUG: While running an extended test of unassigned closures, the
// stack may crash at: `pico_check_timers at pico_stack.c:608, this appears // stack may crash at: `pico_check_timers at pico_stack.c:608, this appears
// to be a bad pointer to a timer within the stack. // to be a bad pointer to a timer within the stack.
@@ -1583,7 +1607,7 @@ void close_test(struct sockaddr *bind_addr)
{ {
int fd; int fd;
if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) { if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
DEBUG_INFO("error creating socket. sleeping until timers are released"); DEBUG_ERROR("error creating socket. sleeping until timers are released");
sleep(30); sleep(30);
} }
if((err = zts_bind(fd, (struct sockaddr *)bind_addr, sizeof(struct sockaddr_in)) < 0)) { if((err = zts_bind(fd, (struct sockaddr *)bind_addr, sizeof(struct sockaddr_in)) < 0)) {
@@ -1600,10 +1624,10 @@ void close_test(struct sockaddr *bind_addr)
void bind_to_localhost_test(int port) void bind_to_localhost_test(int port)
{ {
fprintf(stderr, "\n\nbind_to_localhost_test\n\n");
int fd, err = 0; int fd, err = 0;
// ipv4, 0.0.0.0 // ipv4, 0.0.0.0
struct sockaddr bind_addr; struct sockaddr_storage bind_addr;
DEBUG_INFO("binding to 0.0.0.0"); DEBUG_INFO("binding to 0.0.0.0");
create_addr("0.0.0.0", port, 4, (struct sockaddr *)&bind_addr); create_addr("0.0.0.0", port, 4, (struct sockaddr *)&bind_addr);
if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) > 0) { if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) > 0) {
@@ -1623,6 +1647,7 @@ void bind_to_localhost_test(int port)
port++; port++;
/*
// ipv4, 127.0.0.1 // ipv4, 127.0.0.1
DEBUG_INFO("binding to 127.0.0.1"); DEBUG_INFO("binding to 127.0.0.1");
create_addr("127.0.0.1", port, 4, (struct sockaddr *)&bind_addr); create_addr("127.0.0.1", port, 4, (struct sockaddr *)&bind_addr);
@@ -1642,6 +1667,7 @@ void bind_to_localhost_test(int port)
} }
port++; port++;
*/
// ipv6, [::] // ipv6, [::]
DEBUG_INFO("binding to [::]"); DEBUG_INFO("binding to [::]");
@@ -1670,7 +1696,7 @@ int main(int argc , char *argv[])
{ {
if(argc < 5) { if(argc < 5) {
fprintf(stderr, "usage: selftest <selftest.conf> <alice|bob|ted|carol> to <bob|alice|ted|carol>\n"); fprintf(stderr, "usage: selftest <selftest.conf> <alice|bob|ted|carol> to <bob|alice|ted|carol>\n");
fprintf(stderr, "e.g. : selftest test/selftest.conf alice to bob\n"); fprintf(stderr, "e.g. : selftest test/test.conf alice to bob\n");
return 1; return 1;
} }
@@ -1693,7 +1719,7 @@ int main(int argc , char *argv[])
std::string nwid, stype, path = argv[1]; std::string nwid, stype, path = argv[1];
std::string ipstr, ipstr6, local_ipstr, local_ipstr6, remote_ipstr, remote_ipstr6; std::string ipstr, ipstr6, local_ipstr, local_ipstr6, remote_ipstr, remote_ipstr6;
// loaf config file // load config file
if(path.find(".conf") == std::string::npos) { if(path.find(".conf") == std::string::npos) {
fprintf(stderr, "Possibly invalid conf file. Exiting...\n"); fprintf(stderr, "Possibly invalid conf file. Exiting...\n");
exit(0); exit(0);
@@ -1734,7 +1760,7 @@ int main(int argc , char *argv[])
DEBUG_TEST("Waiting for libzt to come online...\n"); DEBUG_TEST("Waiting for libzt to come online...\n");
zts_simple_start(path.c_str(), nwid.c_str()); zts_simple_start(path.c_str(), nwid.c_str());
char device_id[11]; char device_id[ZT_ID_LEN];
zts_get_device_id(device_id); zts_get_device_id(device_id);
DEBUG_TEST("I am %s, %s", device_id, me.c_str()); DEBUG_TEST("I am %s, %s", device_id, me.c_str());
if(mode == TEST_MODE_SERVER) if(mode == TEST_MODE_SERVER)
@@ -1767,6 +1793,7 @@ int main(int argc , char *argv[])
struct sockaddr_storage local_addr; struct sockaddr_storage local_addr;
struct sockaddr_storage remote_addr; struct sockaddr_storage remote_addr;
// closure test // closure test
/* /*
@@ -1775,17 +1802,35 @@ int main(int argc , char *argv[])
DEBUG_INFO("testing closures by binding to: %s", local_ipstr.c_str()); DEBUG_INFO("testing closures by binding to: %s", local_ipstr.c_str());
create_addr(local_ipstr, port, 4, (struct sockaddr *)&in4); create_addr(local_ipstr, port, 4, (struct sockaddr *)&in4);
close_test((struct sockaddr*)&in4); close_test((struct sockaddr*)&in4);
port++;
*/ */
close_while_writing_test(); // Test adding, resolving, and removing a DNS server
ipv = 4;
create_addr(remote_ipstr, port, ipv, (struct sockaddr *)&remote_addr);
dns_test((struct sockaddr *)&remote_addr);
// close_while_writing_test();
// localhost bind test // localhost bind test
//bind_to_localhost_test(1000); // bind_to_localhost_test(port);
// Transmission Tests // Transmission Tests
// RANDOM API TEST
//random_api_test();
// SLAM API TEST
//slam_api_test();
// BAD ARGS API TEST
//test_bad_args();
// OBSCURE API TEST
//obscure_api_test();
port = start_port; port = start_port;
delay = 0; delay = 0;
count = 1024*128; count = 1024*128;
@@ -1793,7 +1838,6 @@ int main(int argc , char *argv[])
// ipv4 client/server (UDP) // ipv4 client/server (UDP)
/*
ipv = 4; ipv = 4;
if(mode == TEST_MODE_SERVER) { if(mode == TEST_MODE_SERVER) {
create_addr(local_ipstr, port, ipv, (struct sockaddr *)&local_addr); create_addr(local_ipstr, port, ipv, (struct sockaddr *)&local_addr);
@@ -1822,8 +1866,6 @@ int main(int argc , char *argv[])
} }
RECORD_RESULTS(&test_number, passed, details, &results); RECORD_RESULTS(&test_number, passed, details, &results);
port++; port++;
*/
// ipv6 client/server (UDP) // ipv6 client/server (UDP)
ipv = 6; ipv = 6;
@@ -1855,7 +1897,6 @@ int main(int argc , char *argv[])
RECORD_RESULTS(&test_number, passed, details, &results); RECORD_RESULTS(&test_number, passed, details, &results);
port++; port++;
exit(0);
// ipv4 sustained transfer (UDP) // ipv4 sustained transfer (UDP)
ipv = 4; ipv = 4;
@@ -1910,6 +1951,7 @@ exit(0);
port++; port++;
// ipv4 sustained transfer (TCP) // ipv4 sustained transfer (TCP)
ipv = 4; ipv = 4;
if(mode == TEST_MODE_SERVER) { if(mode == TEST_MODE_SERVER) {
create_addr(local_ipstr, port, ipv, (struct sockaddr *)&local_addr); create_addr(local_ipstr, port, ipv, (struct sockaddr *)&local_addr);
@@ -2016,19 +2058,6 @@ exit(0);
} }
*/ */
// RANDOM API TEST
//random_api_test();
// SLAM API TEST
//slam_api_test();
// BAD ARGS API TEST
//test_bad_args();
// OBSCURE API TEST
//obscure_api_test();
// Print results of all tests // Print results of all tests
printf("--------------------------------------------------------------------------------\n"); printf("--------------------------------------------------------------------------------\n");
for(int i=0;i<results.size(); i++) { for(int i=0;i<results.size(); i++) {