mirror
/
devilutionX-libzt
mirror of https://github.com/diasurgical/libzt.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

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

pull/1/head
Joseph Henry 9 years ago
parent
be1d7082e9
commit
ec323c9842
11 changed files with 598 additions and 395 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      examples/node/binding.cc
  2. 6
      ext/picotcp/modules/pico_dns_client.h
  3. 12
      include/libzt.h
  4. 6
      make-linux.mk
  5. 7
      make-mac.mk
  6. 66
      src/VirtualTap.cpp
  7. 18
      src/VirtualTap.hpp
  8. 179
      src/libzt.cpp
  9. 452
      src/picoTCP.cpp
  10. 16
      src/picoTCP.hpp
  11. 227
      test/selftest.cpp

4
examples/node/binding.cc
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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)

66
src/VirtualTap.cpp
Unescape 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);
// update managed routes (add/del from network stacks)
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
Unescape 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
Unescape 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 */
/****************************************************************************/

452
src/picoTCP.cpp
Unescape 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;
}
@ -188,7 +191,46 @@ 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,31 +600,34 @@ namespace ZeroTier {
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) {
sprintf(flag_ptr, "PSH ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_SYN) {
sprintf(flag_ptr, "SYN ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_ACK) {
sprintf(flag_ptr, "ACK ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_FIN) {
sprintf(flag_ptr, "FIN ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_RST) {
sprintf(flag_ptr, "RST ");
flag_ptr+=4;
if (hdr->flags & PICO_TCP_PSH) {
sprintf(flag_ptr, "PSH ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_SYN) {
sprintf(flag_ptr, "SYN ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_ACK) {
sprintf(flag_ptr, "ACK ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_FIN) {
sprintf(flag_ptr, "FIN ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_RST) {
sprintf(flag_ptr, "RST ");
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,37 +676,39 @@ namespace ZeroTier {
{
tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
hdr = (struct pico_tcp_hdr *)tcp_hdr_ptr;
char *flag_ptr = flagbuf;
if (hdr->flags & PICO_TCP_PSH) {
sprintf(flag_ptr, "PSH ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_SYN) {
sprintf(flag_ptr, "SYN ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_ACK) {
sprintf(flag_ptr, "ACK ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_FIN) {
sprintf(flag_ptr, "FIN ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_RST) {
sprintf(flag_ptr, "RST ");
flag_ptr+=4;
if(hdr) {
char *flag_ptr = flagbuf;
if (hdr->flags & PICO_TCP_PSH) {
sprintf(flag_ptr, "PSH ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_SYN) {
sprintf(flag_ptr, "SYN ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_ACK) {
sprintf(flag_ptr, "ACK ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_FIN) {
sprintf(flag_ptr, "FIN ");
flag_ptr+=4;
}
if (hdr->flags & PICO_TCP_RST) {
sprintf(flag_ptr, "RST ");
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) {
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
Unescape 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
*/

227
test/selftest.cpp
Unescape 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,12 +1537,20 @@ void test_bad_args()
DEBUG_TEST("SOCK_DGRAM = %d", SOCK_DGRAM);
}
void dns_test(struct sockaddr *addr)
{
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
// localhost bind test
ipv = 4;
create_addr(remote_ipstr, port, ipv, (struct sockaddr *)&remote_addr);
dns_test((struct sockaddr *)&remote_addr);
//bind_to_localhost_test(1000);
// close_while_writing_test();
// localhost bind test
// 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++) {

Write Preview
Loading…
Cancel
Save