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) {
char* addr_str = new char [ZT_MAX_IPADDR_LEN];
zts_get_ipv4_address(nwid, addr_str, ZT_MAX_IPADDR_LEN);
char* addr_str = new char [INET_ADDRSTRLEN];
zts_get_ipv4_address(nwid, addr_str, INET_ADDRSTRLEN);
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_AAAA_RDLENGTH 16
#ifdef __cplusplus
extern "C" {
#endif
int pico_dns_client_init(void);
/* flag is PICO_DNS_NS_DEL or PICO_DNS_NS_ADD */
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_getname6(const char *url, void (*callback)(char *, void *), void *arg);
#endif
#ifdef __cplusplus
}
#endif
#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_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_ACCEPT_RECHECK_DELAY 100 // ms (for blocking zts_accept() 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_REVISION 4
#define ZT_MAX_IPADDR_LEN 64
#define ZT_ID_LEN 10
#define ZT_ID_LEN 16
#define ZT_VER_STR_LEN 6
#define ZT_HOME_PATH_MAX_LEN 128
#define ZT_MAC_ADDRSTRLEN 18
#define ZT_SOCK_STATE_NONE 100
#define ZT_SOCK_STATE_UNHANDLED_CONNECTED 101
@@ -503,7 +508,7 @@ int zts_add_dns_nameserver(struct sockaddr *addr);
/*
* 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 */
@@ -558,6 +563,7 @@ ZeroTier::VirtualTap *getTapByNWID(uint64_t nwid);
ZeroTier::VirtualTap *getTapByAddr(ZeroTier::InetAddress *addr);
ZeroTier::VirtualTap *getTapByName(char *ifname);
ZeroTier::VirtualTap *getTapByIndex(int index);
ZeroTier::VirtualTap *getAnyTap();
/*
* 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
CFLAGS?=-Ofast -g -fstack-protector
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
endif
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 \
-I$(ZTO)/osdep \
-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\""
# 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 \
-I$(ZTO)/osdep \
-I$(ZTO)/node \
@@ -209,7 +214,7 @@ static_lib: picotcp $(ZTO_OBJS)
$(CXX) $(CXXFLAGS) $(LIBZT_FILES) $(STACK_DRIVER_FILES) -c
mv *.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)
endif
ifeq ($(STACK_LWIP),1)

64
src/VirtualTap.cpp
View File

@@ -62,7 +62,7 @@ class VirtualTap;
extern std::vector<void*> vtaps;
static bool picodev_initialized;
// static bool picodev_initialized;
namespace ZeroTier {
@@ -96,12 +96,19 @@ namespace ZeroTier {
_phy(this,false,true)
{
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;
snprintf(tmp3, 64, "libzt%d-%lx", devno++, _nwid);
_dev = tmp3;
snprintf(vtap_full_name, sizeof(vtap_full_name), "libzt%d-%lx", devno++, _nwid);
_dev = vtap_full_name;
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);
}
@@ -143,14 +150,14 @@ namespace ZeroTier {
bool VirtualTap::addIp(const InetAddress &ip)
{
#if defined(NO_STACK)
char ipbuf[64];
char ipbuf[INET6_ADDRSTRLEN];
DEBUG_INFO("addIp (%s)", ip.toString(ipbuf));
_ips.push_back(ip);
std::sort(_ips.begin(),_ips.end());
return true;
#endif
#if defined(STACK_PICO) || defined(STACK_LWIP)
char ipbuf[64];
char ipbuf[INET6_ADDRSTRLEN];
DEBUG_INFO("addIp (%s)", ip.toString(ipbuf));
if(registerIpWithStack(ip)) {
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
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());
return std::string(id);
}
@@ -260,6 +268,10 @@ namespace ZeroTier {
if(picostack){
picostack->pico_init_interface(this);
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);
}
}
@@ -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 */
/****************************************************************************/
@@ -532,20 +569,21 @@ namespace ZeroTier {
}
void VirtualTap::Housekeeping()
{
{/*
Mutex::Lock _l(_tcpconns_m);
std::time_t current_ts = std::time(nullptr);
if(current_ts > last_housekeeping_ts + ZT_HOUSEKEEPING_INTERVAL) {
// update managed routes (add/del from network stacks)
if(zt1ServiceRef) {
std::vector<ZT_VirtualNetworkRoute> *managed_routes = ((ZeroTier::OneService *)zt1ServiceRef)->getRoutes(this->_nwid);
ZeroTier::OneService *service = ((ZeroTier::OneService *)zt1ServiceRef);
if(service) {
std::vector<ZT_VirtualNetworkRoute> *managed_routes = service->getRoutes(this->_nwid);
ZeroTier::InetAddress target_addr;
ZeroTier::InetAddress via_addr;
ZeroTier::InetAddress null_addr;
ZeroTier::InetAddress nm;
null_addr.fromString("");
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
// check if pushed route exists in tap (add)
for(int i=0; i<ZT_MAX_NETWORK_ROUTES; i++) {
@@ -592,7 +630,9 @@ namespace ZeroTier {
// TODO: Clean up VirtualSocket objects
last_housekeeping_ts = std::time(nullptr);
}
*/
}
/****************************************************************************/

18
src/VirtualTap.hpp
View File

@@ -180,12 +180,25 @@ namespace ZeroTier {
*/
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 */
/****************************************************************************/
#if defined(STACK_PICO)
bool should_start_stack = false;
struct pico_device *picodev = NULL;
@@ -206,6 +219,9 @@ namespace ZeroTier {
std::vector<std::pair<ZeroTier::InetAddress, ZeroTier::InetAddress>> routes;
void *zt1ServiceRef = NULL;
char vtap_full_name[64];
char vtap_abbr_name[16];
static int devno;
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 <errno.h>
#include <time.h>
#include <stdint.h>
#if defined(__APPLE__)
#include <net/ethernet.h>
@@ -130,7 +131,7 @@ void zts_start(const char *path)
if(path)
ZeroTier::homeDir = path;
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)
@@ -138,11 +139,9 @@ void zts_simple_start(const char *path, const char *nwid)
zts_start(path);
while(!zts_running()) {
nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL);
//usleep(ZT_API_CHECK_INTERVAL * 1000);
}
zts_join(nwid);
while(!zts_has_address(nwid)) {
//usleep(ZT_API_CHECK_INTERVAL * 1000);
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) {
if(ZeroTier::zt1Service) {
char id[ZT_ID_LEN+1];
char id[ZT_ID_LEN];
sprintf(id, "%lx",ZeroTier::zt1Service->getNode()->address());
memcpy(devID, id, ZT_ID_LEN+1);
memcpy(devID, id, ZT_ID_LEN);
return 0;
}
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)
{
char ipv4_addr[ZT_MAX_IPADDR_LEN];
memset(ipv4_addr, 0, ZT_MAX_IPADDR_LEN);
zts_get_ipv4_address(nwid, ipv4_addr, ZT_MAX_IPADDR_LEN);
char ipv4_addr[INET_ADDRSTRLEN];
memset(ipv4_addr, 0, INET_ADDRSTRLEN);
zts_get_ipv4_address(nwid, ipv4_addr, INET_ADDRSTRLEN);
return strcmp(ipv4_addr, "\0");
}
int zts_has_ipv6_address(const char *nwid)
{
char ipv6_addr[ZT_MAX_IPADDR_LEN];
memset(ipv6_addr, 0, ZT_MAX_IPADDR_LEN);
zts_get_ipv6_address(nwid, ipv6_addr, ZT_MAX_IPADDR_LEN);
char ipv6_addr[INET6_ADDRSTRLEN];
memset(ipv6_addr, 0, INET6_ADDRSTRLEN);
zts_get_ipv6_address(nwid, ipv6_addr, INET6_ADDRSTRLEN);
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()){
for(int i=0; i<tap->_ips.size(); i++) {
if(tap->_ips[i].isV4()) {
char ipbuf[64];
char ipbuf[INET_ADDRSTRLEN];
std::string addr = tap->_ips[i].toString(ipbuf);
int len = addrlen < addr.length() ? addrlen : addr.length();
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()){
for(int i=0; i<tap->_ips.size(); i++) {
if(tap->_ips[i].isV6()) {
char ipbuf[64];
char ipbuf[INET6_ADDRSTRLEN];
std::string addr = tap->_ips[i].toString(ipbuf);
int len = addrlen < addr.length() ? addrlen : addr.length();
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::Utils::hexStrToU64(nwid),ZeroTier::Utils::hexStrToU64(devID));
char ipbuf[64];
char ipbuf[INET6_ADDRSTRLEN];
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::Utils::hexStrToU64(nwid),ZeroTier::Utils::hexStrToU64(devID));
char ipbuf[64];
char ipbuf[INET6_ADDRSTRLEN];
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
// are being established (also applies to accept())
//usleep(ZT_CONNECT_RECHECK_DELAY * 1000);
nanosleep((const struct timespec[]){{0, (ZT_CONNECT_RECHECK_DELAY * 1000000)}}, NULL);
tap->_tcpconns_m.lock();
for(int i=0; i<tap->_VirtualSockets.size(); i++)
@@ -619,7 +617,6 @@ Darwin:
address space.
*/
int zts_bind(ZT_BIND_SIG) {
DEBUG_INFO();
int err = errno = 0;
if(fd < 0) {
errno = EBADF;
@@ -643,26 +640,31 @@ int zts_bind(ZT_BIND_SIG) {
if(vs->socket_family == AF_INET) {
struct sockaddr_in *in4 = (struct sockaddr_in *)addr;
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
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) {
struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr;
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()) {
tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]);
tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]); // pick any vtap
}
}
}
ZeroTier::InetAddress inet;
sockaddr2inet(vs->socket_family, addr, &inet);
char buf3[64];
if(!tap)
tap = getTapByAddr(&inet);
@@ -793,7 +795,6 @@ int zts_accept(ZT_ACCEPT_SIG) {
}
else { // blocking
while(true) {
//usleep(ZT_ACCEPT_RECHECK_DELAY * 1000);
nanosleep((const struct timespec[]){{0, (ZT_ACCEPT_RECHECK_DELAY * 1000000)}}, NULL);
accepted_vs = tap->Accept(vs);
if(accepted_vs)
@@ -1036,7 +1037,7 @@ Linux / Darwin:
int zts_close(ZT_CLOSE_SIG)
{
int err = errno = 0;
DEBUG_EXTRA("fd=%d", fd);
//DEBUG_EXTRA("fd=%d", fd);
if(fd < 0) {
errno = EBADF;
return -1;
@@ -1192,7 +1193,7 @@ Linux:
*/
ssize_t zts_sendto(ZT_SENDTO_SIG)
{
//DEBUG_INFO();
DEBUG_TRANS("fd=%d", fd);
int err = errno = 0;
if(fd < 0) {
errno = EBADF;
@@ -1208,26 +1209,27 @@ ssize_t zts_sendto(ZT_SENDTO_SIG)
ZeroTier::InetAddress iaddr;
ZeroTier::VirtualTap *tap;
char ipstr[INET6_ADDRSTRLEN];
// int port;
memset(ipstr, 0, INET6_ADDRSTRLEN);
if(vs->socket_type == SOCK_DGRAM) {
// form addresses
if(vs->socket_family == AF_INET) {
if(vs->socket_type == SOCK_DGRAM)
{
if(vs->socket_family == AF_INET)
{
char ipstr[INET_ADDRSTRLEN];
memset(ipstr, 0, INET_ADDRSTRLEN);
inet_ntop(AF_INET,
(const void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, ipstr, INET_ADDRSTRLEN);
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,
(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
char addrstr[64];
char addrstr[INET6_ADDRSTRLEN];
sprintf(addrstr, "%s%s", ipstr, std::string("/40").c_str());
iaddr.fromString(addrstr);
// port = ((struct sockaddr_in6*)addr)->sin6_port;
}
// get tap
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?
}
}
if(vs->socket_type == SOCK_RAW) {
if(vs->socket_type == SOCK_RAW)
{
struct sockaddr_ll *socket_address = (struct sockaddr_ll *)addr;
ZeroTier::VirtualTap *tap = getTapByIndex(socket_address->sll_ifindex);
if(tap) {
@@ -1308,6 +1311,7 @@ ssize_t zts_sendto(ZT_SENDTO_SIG)
*/
ssize_t zts_send(ZT_SEND_SIG)
{
DEBUG_TRANS("fd=%d", fd);
int err = errno = 0;
ZeroTier::VirtualSocket *vs = get_virtual_socket(fd);
if(!vs) {
@@ -1375,7 +1379,7 @@ ssize_t zts_send(ZT_SEND_SIG)
// TODO
ssize_t zts_sendmsg(ZT_SENDMSG_SIG)
{
DEBUG_INFO("fd = %d", fd);
DEBUG_TRANS("fd=%d", fd);
int err = errno = 0;
if(fd < 0) {
errno = EBADF;
@@ -1413,6 +1417,7 @@ ssize_t zts_sendmsg(ZT_SENDMSG_SIG)
*/
ssize_t zts_recv(ZT_RECV_SIG)
{
DEBUG_TRANS("fd=%d", fd);
int err = errno = 0;
ZeroTier::VirtualSocket *vs = get_virtual_socket(fd);
if(!vs) {
@@ -1500,21 +1505,31 @@ ssize_t zts_recv(ZT_RECV_SIG)
*/
ssize_t zts_recvfrom(ZT_RECVFROM_SIG)
{
//DEBUG_INFO();
int r = 0, err = errno = 0;
DEBUG_TRANS("fd=%d", fd);
int32_t r = 0;
errno = 0;
if(fd < 0) {
errno = EBADF;
return -1;
}
char udp_msg_buf[ZT_MAX_MTU];
r = read(fd, udp_msg_buf, sizeof(udp_msg_buf));
char udp_msg_buf[ZT_SOCKET_MSG_BUF_SZ];
char *msg_ptr = udp_msg_buf;
r = read(fd, msg_ptr, sizeof(udp_msg_buf));
if(r > 0) {
int udp_msg_len = 0;
memcpy(&udp_msg_len, udp_msg_buf, sizeof(udp_msg_len));
memcpy(addr, udp_msg_buf + sizeof(int), sizeof(struct sockaddr_in));
*addrlen = sizeof(struct sockaddr_in);
int payload_sz = udp_msg_len - sizeof(struct sockaddr_in);
memcpy(buf, udp_msg_buf + sizeof(int) + sizeof(struct sockaddr_in), payload_sz);
*addrlen = sizeof(struct sockaddr_storage);
// get message length
int32_t udp_msg_len = 0;
memcpy(&udp_msg_len, msg_ptr, sizeof(udp_msg_len));
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;
}
return r;
@@ -1523,7 +1538,7 @@ ssize_t zts_recvfrom(ZT_RECVFROM_SIG)
// TODO
ssize_t zts_recvmsg(ZT_RECVMSG_SIG)
{
DEBUG_INFO("fd=%d", fd);
DEBUG_TRANS("fd=%d", fd);
int err = errno = 0;
if(fd < 0) {
errno = EBADF;
@@ -1536,12 +1551,12 @@ ssize_t zts_recvmsg(ZT_RECVMSG_SIG)
}
int zts_read(ZT_READ_SIG) {
//DEBUG_INFO("fd = %d", fd);
DEBUG_TRANS("fd=%d", fd);
return read(fd, buf, len);
}
int zts_write(ZT_WRITE_SIG) {
// DEBUG_INFO("fd = %d", fd);
DEBUG_TRANS("fd=%d", fd);
return write(fd, buf, len);
}
@@ -1616,7 +1631,6 @@ int zts_shutdown(ZT_SHUTDOWN_SIG)
for(int i=0; i<ZT_SDK_CLTIME; i++) {
if(vs->TXbuf->count() == 0)
break;
//usleep(ZT_API_CHECK_INTERVAL * 1000);
nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL);
}
@@ -1635,21 +1649,29 @@ int zts_shutdown(ZT_SHUTDOWN_SIG)
return 0;
}
int zts_add_dns_nameserver(struct sockaddr *addr)
{
errno = 0;
return 0;
ZeroTier::VirtualTap *vtap = getAnyTap();
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;
return 0;
ZeroTier::VirtualTap *vtap = getAnyTap();
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>
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) {
homeDir = env->GetStringUTFChars(path, NULL);
zts_start(homeDir.c_str());
@@ -1711,9 +1733,9 @@ namespace ZeroTier {
JNIEnv *env, jobject thisObj, jstring nwid)
{
const char *nwid_str = env->GetStringUTFChars(nwid, NULL);
char address_string[32];
memset(address_string, 0, 32);
zts_get_ipv4_address(nwid_str, address_string, ZT_MAX_IPADDR_LEN);
char address_string[INET_ADDRSTRLEN];
memset(address_string, 0, INET_ADDRSTRLEN);
zts_get_ipv4_address(nwid_str, address_string, INET_ADDRSTRLEN);
jclass clazz = (*env).FindClass("java/util/ArrayList");
jobject addresses = (*env).NewObject(clazz, (*env).GetMethodID(clazz, "<init>", "()V"));
jstring _str = (*env).NewStringUTF(address_string);
@@ -1725,9 +1747,9 @@ namespace ZeroTier {
JNIEnv *env, jobject thisObj, jstring nwid)
{
const char *nwid_str = env->GetStringUTFChars(nwid, NULL);
char address_string[32];
memset(address_string, 0, 32);
zts_get_ipv6_address(nwid_str, address_string, ZT_MAX_IPADDR_LEN);
char address_string[INET6_ADDRSTRLEN];
memset(address_string, 0, INET6_ADDRSTRLEN);
zts_get_ipv6_address(nwid_str, address_string, INET6_ADDRSTRLEN);
jclass clazz = (*env).FindClass("java/util/ArrayList");
jobject addresses = (*env).NewObject(clazz, (*env).GetMethodID(clazz, "<init>", "()V"));
jstring _str = (*env).NewStringUTF(address_string);
@@ -1778,7 +1800,7 @@ namespace ZeroTier {
struct sockaddr_in addr;
jbyte *body = (*env).GetByteArrayElements( buf, 0);
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));
if(rxbytes > 0)
memcpy(body, (jbyte*)buffer + payload_offset, rxbytes);
@@ -1909,18 +1931,6 @@ namespace ZeroTier {
/* 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)
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::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++) {
s = (ZeroTier::VirtualTap*)ZeroTier::vtaps[i];
// check address schemes
@@ -2092,6 +2102,17 @@ ZeroTier::VirtualTap *getTapByIndex(int index)
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 */
/****************************************************************************/

366
src/picoTCP.cpp
View File

@@ -25,6 +25,7 @@
*/
#include <ctime>
#include <stdint.h>
#include "pico_eth.h"
#include "pico_stack.h"
@@ -36,6 +37,7 @@
#include "pico_device.h"
#include "pico_ipv6.h"
#include "pico_tcp.h"
#include "pico_dns_client.h"
#include "libzt.h"
#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_close(PICO_SOCKET_CLOSE_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);
@@ -106,7 +109,7 @@ namespace ZeroTier {
picodev.tap = tap;
uint8_t 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");
handle_general_failure();
err = false;
@@ -122,7 +125,7 @@ namespace ZeroTier {
{
_picostack_driver_lock.lock();
bool err = false;
char ipbuf[64];
char ipbuf[INET6_ADDRSTRLEN];
uint8_t hwaddr[6];
// register addresses
if(ip.isV4()) {
@@ -132,8 +135,8 @@ namespace ZeroTier {
pico_ipv4_link_add(&picodev, ipaddr, netmask);
DEBUG_INFO("addr=%s", ip.toString(ipbuf));
tap->_mac.copyTo(hwaddr, 6);
char macbuf[18];
mac2str(macbuf, sizeof(macbuf), hwaddr);
char macbuf[ZT_MAC_ADDRSTRLEN];
mac2str(macbuf, ZT_MAC_ADDRSTRLEN, hwaddr);
DEBUG_INFO("mac=%s", macbuf);
err = true;
}
@@ -147,8 +150,8 @@ namespace ZeroTier {
pico_ipv6_link_add(&picodev, ipaddr, netmask);
DEBUG_INFO("addr=%s", ipv6_str);
tap->_mac.copyTo(hwaddr, 6);
char macbuf[18];
mac2str(macbuf, sizeof(macbuf), hwaddr);
char macbuf[ZT_MAC_ADDRSTRLEN];
mac2str(macbuf, ZT_MAC_ADDRSTRLEN, hwaddr);
DEBUG_INFO("mac=%s", macbuf);
err = true;
}
@@ -189,6 +192,45 @@ namespace ZeroTier {
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)
{
while(tap->_run)
@@ -232,28 +274,17 @@ namespace ZeroTier {
do {
n = 0;
//DEBUG_INFO("RXbuf->count() = %d", vs->RXbuf->count());
int avail = ZT_TCP_RX_BUF_SZ - vs->RXbuf->count();
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,
(void *)&peer.ip4.addr, &port);
if (r > 0)
{
vs->RXbuf->produce(r);
//DEBUG_INFO("RXbuf->count() = %d", vs->RXbuf->count());
n = tap->_phy.streamSend(vs->sock, vs->RXbuf->get_buf(), r);
if(n>0)
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) {
tap->_phy.setNotifyWritable(vs->sock, false);
@@ -311,12 +342,12 @@ namespace ZeroTier {
in4.sin_port = port;
// 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
char udp_msg_buf[ZT_MAX_MTU]; // [sz : addr : payload]
int len = sizeof(struct sockaddr_in) + r;
int tot_len = sizeof(len) + len;
memcpy(udp_msg_buf, &len, sizeof(len)); // len: sockaddr+payload
memcpy(udp_msg_buf + sizeof(len), &in4, sizeof(in4)); // sockaddr
memcpy(udp_msg_buf + sizeof(len) + sizeof(in4), &udp_payload_buf, r); // payload
char udp_msg_buf[ZT_SOCKET_MSG_BUF_SZ]; // [sz : addr : payload]
int32_t len = sizeof(struct sockaddr_storage) + r;
int32_t tot_len = sizeof(int32_t) + len;
memcpy(udp_msg_buf, &len, sizeof(int32_t)); // len: sockaddr+payload
memcpy(udp_msg_buf + sizeof(int32_t), &in4, sizeof(struct sockaddr_storage)); // sockaddr
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) {
DEBUG_ERROR("write()=%d, errno=%d", w, errno);
}
@@ -331,12 +362,12 @@ namespace ZeroTier {
in6.sin6_port = port;
// 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
char udp_msg_buf[ZT_MAX_MTU]; // [sz : addr : payload]
int len = sizeof(struct sockaddr_in6) + r;
int tot_len = sizeof(len) + len;
memcpy(udp_msg_buf, &len, sizeof(len)); // len: sockaddr+payload
memcpy(udp_msg_buf + sizeof(len), &in6, sizeof(in6)); // sockaddr
memcpy(udp_msg_buf + sizeof(len) + sizeof(in6), &udp_payload_buf, r); // payload
char udp_msg_buf[ZT_SOCKET_MSG_BUF_SZ]; // [sz : addr : payload]
int32_t len = sizeof(struct sockaddr_storage) + r;
int32_t tot_len = sizeof(int32_t) + len;
memcpy(udp_msg_buf, &len, sizeof(int32_t)); // len: sockaddr+payload
memcpy(udp_msg_buf + sizeof(int32_t), &in6, sizeof(struct sockaddr_storage)); // sockaddr
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) {
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);
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();
return;
}
if(vs->socket_type == SOCK_STREAM) {
//DEBUG_TRANS("[ TCP TX -> STACK] :: vs = %p, len = %d", vs, r);
}
if(vs->socket_type == SOCK_DGRAM) {
//DEBUG_TRANS("[ UDP 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(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
// 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)");
@@ -386,7 +416,44 @@ namespace ZeroTier {
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));
// --- 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);
if(!vbp) {
DEBUG_ERROR("s->priv yielded no valid VirtualBindingPair");
@@ -395,7 +462,6 @@ namespace ZeroTier {
}
VirtualTap *tap = static_cast<VirtualTap*>(vbp->tap);
VirtualSocket *vs = static_cast<VirtualSocket*>(vbp->vs);
int err = 0;
if(!vs) {
DEBUG_ERROR("invalid VirtualSocket");
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
// may now be issued in order to accept the incoming VirtualSocket from a remote host.
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)
{
uint16_t port;
@@ -420,9 +486,8 @@ namespace ZeroTier {
if(vs->socket_family == AF_INET6) { // NOTE: p->net->proto_number == PICO_PROTO_IPV4
client_psock = pico_socket_accept(s, &orig6, &port);
}
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;
}
@@ -435,19 +500,21 @@ namespace ZeroTier {
new_vs->picosock = client_psock;
// TODO: Condense this
char addrstr[INET6_ADDRSTRLEN];
if(vs->socket_family == AF_INET) {
struct sockaddr_in in4;
in4.sin_addr.s_addr = orig4.addr;
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, INET6_ADDRSTRLEN);
char addrstr[INET_ADDRSTRLEN];
struct sockaddr_storage ss4;
struct sockaddr_in *in4 = (struct sockaddr_in *)&ss4;
in4->sin_addr.s_addr = orig4.addr;
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);
ZeroTier::InetAddress inet;
inet.fromString(addrstr);
new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
}
if(vs->socket_family == AF_INET6) {
char addrstr[INET6_ADDRSTRLEN];
struct sockaddr_in6 in6;
memcpy(&(in6.sin6_addr.s6_addr), &orig6, sizeof(in6.sin6_addr.s6_addr));
in6.sin6_port = Utils::hton(port);
@@ -459,7 +526,7 @@ namespace ZeroTier {
new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
}
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();
return;
}
@@ -474,36 +541,6 @@ namespace ZeroTier {
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
// can be taken by the socket owner because this event indicates there is new data to receive.
if (ev & PICO_SOCK_EV_RD) {
@@ -522,7 +559,6 @@ namespace ZeroTier {
int pico_eth_tx(struct pico_device *dev, void *buf, int len)
{
//_picostack_driver_lock.lock();
//DEBUG_INFO("len = %d", len);
VirtualTap *tap = static_cast<VirtualTap*>(dev->tap);
if(!tap) {
DEBUG_ERROR("invalid dev->tap");
@@ -536,8 +572,8 @@ namespace ZeroTier {
src_mac.setTo(ethhdr->saddr, 6);
dest_mac.setTo(ethhdr->daddr, 6);
if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
char macBuf[18], nodeBuf[11];
mac2str(macBuf, sizeof(macBuf), ethhdr->daddr);
char macBuf[ZT_MAC_ADDRSTRLEN], nodeBuf[ZT_ID_LEN];
mac2str(macBuf, ZT_MAC_ADDRSTRLEN, ethhdr->daddr);
ZeroTier::MAC mac;
mac.setTo(ethhdr->daddr, 6);
mac.toAddress(tap->_nwid).toString(nodeBuf);
@@ -564,6 +600,7 @@ namespace ZeroTier {
ext/picotcp/build/include/pico_tcp.h:#define PICO_TCP_RSTACK (PICO_TCP_RST | PICO_TCP_ACK)
*/
if(hdr) {
char *flag_ptr = flagbuf;
if (hdr->flags & PICO_TCP_PSH) {
@@ -587,8 +624,10 @@ namespace ZeroTier {
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,
Utils::ntoh((uint16_t)ethhdr->proto),0, ((char*)buf)
@@ -615,10 +654,10 @@ namespace ZeroTier {
from.copyTo(ethhdr.saddr, 6);
to.copyTo(ethhdr.daddr, 6);
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) {
char macBuf[18], nodeBuf[11];
char macBuf[ZT_MAC_ADDRSTRLEN], nodeBuf[ZT_ID_LEN];
mac2str(macBuf, sizeof(macBuf), ethhdr.saddr);
ZeroTier::MAC mac;
mac.setTo(ethhdr.saddr, 6);
@@ -637,7 +676,7 @@ namespace ZeroTier {
{
tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
hdr = (struct pico_tcp_hdr *)tcp_hdr_ptr;
if(hdr) {
char *flag_ptr = flagbuf;
if (hdr->flags & PICO_TCP_PSH) {
@@ -661,13 +700,15 @@ namespace ZeroTier {
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())
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 + sizeof(newlen), &ethhdr, sizeof(ethhdr)); // new eth header
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen) + sizeof(ethhdr), data, len); // frame data
tap->pico_frame_rxbuf_tot += newlen;
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(int32_t), &ethhdr, sizeof(ethhdr)); // new eth header
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(int32_t) + sizeof(ethhdr), data, len); // frame data
tap->pico_frame_rxbuf_tot += msg_len;
//_picostack_driver_lock.unlock();
}
@@ -680,22 +721,21 @@ namespace ZeroTier {
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
// TODO: Optimize
// TODO: Optimize (use Ringbuffer)
Mutex::Lock _l(tap->_pico_frame_rxbuf_m);
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) {
//DEBUG_FLOW(" [ FBUF -> STACK] Frame buffer SZ=%d", tap->pico_frame_rxbuf_tot);
memset(frame, 0, sizeof(frame));
len = 0;
memcpy(&len, tap->pico_frame_rxbuf, sizeof(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
//DEBUG_FLOW(" [ FBUF -> STACK] Moving FRAME of size (%d) from FBUF(sz=%d) into stack",len, tap->pico_frame_rxbuf_tot-len);
memcpy(frame, tap->pico_frame_rxbuf + sizeof(len), len-(sizeof(len)) ); // get frame data
// get frame len
memcpy(&len, tap->pico_frame_rxbuf, sizeof(int32_t));
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(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
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) {
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;
@@ -727,33 +767,37 @@ namespace ZeroTier {
protocol_version = PICO_PROTO_IPV6;
if(socket_type == SOCK_DGRAM) {
DEBUG_INFO("SOCK_DGRAM");
psock = pico_socket_open(
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
}
}
if(socket_type == SOCK_STREAM) {
psock = pico_socket_open(
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 rx_buf_sz = ZT_STACK_TCP_SOCKET_RX_SZ;
int t_err = 0;
//int value = 1;
// int value = 1;
// pico_socket_setoption(psock, PICO_TCP_NODELAY, &value);
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)
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) {
int linger_time_ms = ZT_SOCK_BEHAVIOR_LINGER_TIME;
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;
pico_string_to_ipv4(ipv4_str, &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);
}
if(vs->socket_family == AF_INET6) {
@@ -788,26 +834,22 @@ namespace ZeroTier {
char ipv6_str[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN);
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);
}
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));
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;
}
int picoTCP::pico_Bind(VirtualSocket *vs, const struct sockaddr *addr, socklen_t addrlen)
{
//DEBUG_INFO();
if(!vs || !vs->picosock) {
DEBUG_ERROR("invalid vs or vs->picosock");
handle_general_failure();
@@ -837,49 +879,25 @@ namespace ZeroTier {
err = pico_socket_bind(vs->picosock, &pip6, (uint16_t *)&(in6->sin6_port));
}
if(err < 0) {
if(pico_err < 0)
DEBUG_ERROR("pico_err = %d", pico_err);
DEBUG_ERROR("unable to bind pico_socket(%p), err=%d", (vs->picosock), 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;
}
DEBUG_ERROR("unable to bind 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);
}
return err;
}
int picoTCP::pico_Listen(VirtualSocket *vs, int backlog)
{
//DEBUG_INFO();
if(!vs || !vs->picosock) {
DEBUG_ERROR("invalid vs or vs->picosock");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
int err = 0;
if((err = pico_socket_listen(vs->picosock, backlog)) < 0)
{
if(err == PICO_ERR_EINVAL) {
DEBUG_ERROR("PICO_ERR_EINVAL");
errno = EINVAL;
return -1;
}
if(err == PICO_ERR_EISCONN) {
DEBUG_ERROR("PICO_ERR_EISCONN");
errno = EISCONN;
return -1;
}
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",
vs->picosock, err, pico_err, beautify_pico_error(pico_err));
return map_pico_err_to_errno(pico_err);
}
vs->state = ZT_SOCK_STATE_LISTENING;
return ZT_ERR_OK;
@@ -936,7 +954,7 @@ namespace ZeroTier {
if(vs->socket_type == SOCK_DGRAM) {
int r;
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));
err = -1;
}
@@ -962,7 +980,8 @@ namespace ZeroTier {
int txsz = vs->TXbuf->count();
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) {
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;
}
else {
@@ -971,7 +990,12 @@ namespace ZeroTier {
if(r>0){
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;
}
@@ -983,7 +1007,7 @@ namespace ZeroTier {
handle_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)
return ZT_ERR_GENERAL_FAILURE;
int err = 0;
@@ -992,11 +1016,47 @@ namespace ZeroTier {
return ZT_ERR_OK;
if((err = pico_socket_close(vs->picosock)) < 0) {
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;
}
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)
{
if(err== 0) return (char*)"PICO_ERR_NOERR";
@@ -1005,17 +1065,17 @@ namespace ZeroTier {
// ...
if(err== 4) return (char*)"PICO_ERR_EINTR";
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== 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== 14) return (char*)"PICO_ERR_EFAULT";
// ...
if(err== 16) return (char*)"PICO_ERR_EBUSY";
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";
// ...

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_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_DNS_CLIENT_NAMESERVER_SIG pico_ip4*, unsigned char
namespace ZeroTier
{
@@ -111,6 +112,16 @@ namespace ZeroTier
*/
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
*/
@@ -181,6 +192,11 @@ namespace ZeroTier
*/
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
*/

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)
{
std::string msg = "tcp_client_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "tcp_client_4";
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());
char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf);
@@ -249,7 +250,6 @@ void tcp_client_4(TCP_UNIT_TEST_SIG_4)
DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0)
DEBUG_ERROR("error connecting to remote host (%d)", err);
// TODO: Put this test in the general API section
struct sockaddr_storage 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);
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
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());
}
//
void tcp_server_4(TCP_UNIT_TEST_SIG_4)
{
std::string msg = "tcp_server_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "tcp_server_4";
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());
char rbuf[STR_SIZE];
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);
if((accfd = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0)
DEBUG_ERROR("error accepting connection (%d)", err);
// TODO: Put this test in the general API section
struct sockaddr_storage 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);
err = zts_close(sockfd);
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());
}
//
void tcp_client_6(TCP_UNIT_TEST_SIG_6)
{
std::string msg = "tcp_client_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "tcp_client_6";
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());
char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf);
@@ -313,7 +314,6 @@ void tcp_client_6(TCP_UNIT_TEST_SIG_6)
DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0)
DEBUG_ERROR("error connecting to remote host (%d)", err);
// TODO: Put this test in the general API section
struct sockaddr_storage 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);
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
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("Received : %s", rbuf);
*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)
{
std::string msg = "tcp_sever_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "tcp_sever_6";
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());
char rbuf[STR_SIZE];
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);
if((accfd = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0)
DEBUG_ERROR("error accepting connection (%d)", err);
// TODO: Put this test in the general API section
struct sockaddr_storage 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);
err = zts_close(sockfd);
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());
}
@@ -374,8 +374,9 @@ void tcp_server_6(TCP_UNIT_TEST_SIG_6)
//
void udp_client_4(UDP_UNIT_TEST_SIG_4)
{
std::string msg = "udp_client_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "udp_client_4";
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());
char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf);
@@ -384,11 +385,11 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0))
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))
DEBUG_ERROR("error binding to interface (%d)", err);
struct sockaddr_in saddr;
struct sockaddr_storage saddr;
while(1) {
// tx
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())) {
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd);
DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", 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", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf);
*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)
{
std::string msg = "udp_server_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "udp_server_4";
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());
char rbuf[STR_SIZE];
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);
// rx
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);
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];
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
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));
// tx
long int tx_ti = get_now_ts();
while(1) {
sleep(1);
//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);
}
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;
}
}
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
//err = zts_close(sockfd);
DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", 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", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf);
*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)
{
std::string msg = "udp_client_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "udp_client_6";
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());
char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf);
@@ -470,28 +474,29 @@ void udp_client_6(UDP_UNIT_TEST_SIG_6)
DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0))
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))
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
struct sockaddr_in saddr;
struct sockaddr_storage saddr;
while(1) {
// 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);
}
usleep(100000);
memset(rbuf, 0, sizeof(rbuf));
int serverlen = sizeof(remote_addr);
// rx
r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
if(r == strlen(msg.c_str())) {
r = zts_recvfrom(sockfd, rbuf, len, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
if(r == len) {
DEBUG_INFO("[2] complete");
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd);
DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", 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", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf);
*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)
{
std::string msg = "udp_server_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "udp_server_6";
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());
char rbuf[STR_SIZE];
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))
DEBUG_ERROR("error binding to interface (%d)", err);
// rx
DEBUG_INFO("[1/4] waiting for UDP packet...\n");
struct sockaddr_in6 saddr;
DEBUG_INFO("[1/4] waiting for UDP packet to start test...");
struct sockaddr_storage saddr;
struct sockaddr_in6 *in6 = (struct sockaddr_in6*)&saddr;
int serverlen = 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];
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);
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));
// once we receive a UDP packet, spend 10 seconds sending responses in the hopes that the client will see
// tx
@@ -530,19 +537,18 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
while(1) {
usleep(100000);
//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);
}
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;
}
}
DEBUG_INFO("[4/4] complete");
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
//err = zts_close(sockfd);
DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", 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", testname.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf);
*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
void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
{
std::string msg = "tcp_client_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "tcp_client_sustained_4";
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;
char *rxbuf = (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;
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);
}
@@ -634,11 +641,13 @@ void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
// Maintain transfer for count OR count
void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
{
std::string msg = "tcp_server_sustained_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "tcp_client_sustained_6";
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;
char *rxbuf = (char*)malloc(count*sizeof(char));
char *txbuf = (char*)malloc(count*sizeof(char));
generate_random_data(txbuf, count);
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;
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);
}
@@ -711,15 +720,16 @@ void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
// Maintain transfer for count OR count
void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
{
std::string msg = "tcp_server_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "tcp_server_sustained_4";
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;
char *rxbuf = (char*)malloc(count*sizeof(char));
memset(rxbuf, 0, count);
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0)
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);
if((err = zts_listen(sockfd, 1)) < 0)
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;
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);
}
@@ -778,8 +788,9 @@ void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
// Maintain transfer for count OR count
void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
{
std::string msg = "tcp_server_sustained_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "tcp_server_sustained_6";
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;
char *rxbuf = (char*)malloc(count*sizeof(char));
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;
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);
}
@@ -841,8 +852,9 @@ void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
{
std::string msg = "udp_client_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "udp_client_sustained_4";
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());
char rbuf[STR_SIZE];
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);
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("Received : %s", rbuf);
*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)
{
std::string msg = "udp_server_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
std::string testname = "udp_server_sustained_4";
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());
char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf);
@@ -888,7 +901,7 @@ void udp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
w = r;
//sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
//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("Received : %s", rbuf);
*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);
}
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)
{
@@ -1553,6 +1574,7 @@ void* create_socket(void *arg)
void multithread_socket_creation()
{
fprintf(stderr, "\n\nmultithread_socket_creation\n\n");
/*
pthread_t tid[2];
@@ -1567,12 +1589,14 @@ void multithread_socket_creation()
void multithread_rw()
{
fprintf(stderr, "\n\nmultithread_rw\n\n");
// TODO: Test read/writes from multiple threads
}
// Tests rapid opening and closure of sockets
void close_test(struct sockaddr *bind_addr)
{
fprintf(stderr, "\n\nclose_test\n\n");
// BUG: While running an extended test of unassigned closures, the
// 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.
@@ -1583,7 +1607,7 @@ void close_test(struct sockaddr *bind_addr)
{
int fd;
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);
}
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)
{
fprintf(stderr, "\n\nbind_to_localhost_test\n\n");
int fd, err = 0;
// ipv4, 0.0.0.0
struct sockaddr bind_addr;
struct sockaddr_storage bind_addr;
DEBUG_INFO("binding to 0.0.0.0");
create_addr("0.0.0.0", port, 4, (struct sockaddr *)&bind_addr);
if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) > 0) {
@@ -1623,6 +1647,7 @@ void bind_to_localhost_test(int port)
port++;
/*
// ipv4, 127.0.0.1
DEBUG_INFO("binding to 127.0.0.1");
create_addr("127.0.0.1", port, 4, (struct sockaddr *)&bind_addr);
@@ -1642,6 +1667,7 @@ void bind_to_localhost_test(int port)
}
port++;
*/
// ipv6, [::]
DEBUG_INFO("binding to [::]");
@@ -1670,7 +1696,7 @@ int main(int argc , char *argv[])
{
if(argc < 5) {
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;
}
@@ -1693,7 +1719,7 @@ int main(int argc , char *argv[])
std::string nwid, stype, path = argv[1];
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) {
fprintf(stderr, "Possibly invalid conf file. Exiting...\n");
exit(0);
@@ -1734,7 +1760,7 @@ int main(int argc , char *argv[])
DEBUG_TEST("Waiting for libzt to come online...\n");
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);
DEBUG_TEST("I am %s, %s", device_id, me.c_str());
if(mode == TEST_MODE_SERVER)
@@ -1767,6 +1793,7 @@ int main(int argc , char *argv[])
struct sockaddr_storage local_addr;
struct sockaddr_storage remote_addr;
// closure test
/*
@@ -1775,17 +1802,35 @@ int main(int argc , char *argv[])
DEBUG_INFO("testing closures by binding to: %s", local_ipstr.c_str());
create_addr(local_ipstr, port, 4, (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
//bind_to_localhost_test(1000);
// bind_to_localhost_test(port);
// 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;
delay = 0;
count = 1024*128;
@@ -1793,7 +1838,6 @@ int main(int argc , char *argv[])
// ipv4 client/server (UDP)
/*
ipv = 4;
if(mode == TEST_MODE_SERVER) {
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);
port++;
*/
// ipv6 client/server (UDP)
ipv = 6;
@@ -1855,7 +1897,6 @@ int main(int argc , char *argv[])
RECORD_RESULTS(&test_number, passed, details, &results);
port++;
exit(0);
// ipv4 sustained transfer (UDP)
ipv = 4;
@@ -1910,6 +1951,7 @@ exit(0);
port++;
// ipv4 sustained transfer (TCP)
ipv = 4;
if(mode == TEST_MODE_SERVER) {
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
printf("--------------------------------------------------------------------------------\n");
for(int i=0;i<results.size(); i++) {