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

picotcp stack driver edge case bug fixes

Browse Source
This commit is contained in:
Joseph Henry
2017-08-24 11:45:39 -07:00
parent bceadfbe46
commit eff90c7d13
12 changed files with 1385 additions and 931 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
examples/cpp/simple.cpp
View File

@@ -1,141 +0,0 @@
// Comprehensive stress test for socket-like API
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <arpa/inet.h>
#include <string.h>
#include <netinet/in.h>
#include <netdb.h>
#include "libzt.h"
int main()
{
char *nwid = (char *)"e5cd7a9e1c0fd272";
// Get ZeroTier core version
char ver[ZT_VER_STR_LEN];
zts_core_version(ver);
printf("zts_core_version = %s\n", ver);
// Get SDK version
zts_sdk_version(ver);
printf("zts_sdk_version = %s\n", ver);
// Spawns a couple threads to support ZeroTier core, userspace network stack, and generates ID in ./zt
zts_start("./zt");
// Print the device/app ID (this is also the ID you'd see in ZeroTier Central)
char id[ZT_ID_LEN + 1];
zts_get_device_id(id);
printf("id = %s\n", id);
// Get the home path of this ZeroTier instance, where we store identity keys, conf files, etc
char homePath[ZT_HOME_PATH_MAX_LEN+1];
zts_get_homepath(homePath, ZT_HOME_PATH_MAX_LEN);
printf("homePath = %s\n", homePath);
// Wait for ZeroTier service to start
while(!zts_running()) {
printf("wating for service to start\n");
sleep(1);
}
// Join a network
zts_join(nwid);
// Wait for ZeroTier service to issue an address to the device on the given network
while(!zts_has_address("e5cd7a9e1c0fd272")) {
printf("waiting for service to issue an address\n");
sleep(1);
}
// Begin Socket API calls
int err;
int sockfd;
int port = 7878;
struct sockaddr_in addr;
// socket()
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0)
printf("error creating ZeroTier socket");
else
printf("sockfd = %d\n", sockfd);
// connect() IPv6
if(false)
{
struct hostent *server = gethostbyname2("fde5:cd7a:9e1c:0fd2:7299:9367:5993:3b86",AF_INET6);
struct sockaddr_in6 serv_addr;
memset((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin6_flowinfo = 0;
serv_addr.sin6_family = AF_INET6;
memmove((char *) &serv_addr.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
serv_addr.sin6_port = htons( port );
if((err = zts_connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
return -1;
}
}
// connect() IPv4
if(true)
{
addr.sin_addr.s_addr = inet_addr("10.9.9.20");
addr.sin_family = AF_INET;
addr.sin_port = htons( port );
if((err = zts_connect(sockfd, (const struct sockaddr *)&addr, sizeof(addr))) < 0) {
printf("error connecting to remote host (%d)\n", err);
return -1;
}
zts_write(sockfd, "hello", 5);
sleep(3);
zts_close(sockfd);
}
// bind() ipv4
if(false)
{
//addr.sin_addr.s_addr = INADDR_ANY; // TODO: Requires significant socket multiplexer work
addr.sin_addr.s_addr = inet_addr("10.9.9.40");
addr.sin_family = AF_INET;
addr.sin_port = htons( port );
if((err = zts_bind(sockfd, (const struct sockaddr *)&addr, sizeof(addr))) < 0) {
printf("error binding to interface (%d)\n", err);
return -1;
}
zts_listen(sockfd, 1);
struct sockaddr_in client;
int c = sizeof(struct sockaddr_in);
int accept_fd = zts_accept(sockfd, (struct sockaddr *)&client, (socklen_t*)&c);
printf("reading from buffer\n");
char newbuf[32];
memset(newbuf, 0, 32);
read(accept_fd, newbuf, 20);
printf("newbuf = %s\n", newbuf);
}
// End Socket API calls
// Get the ipv4 address assigned for this network
char addr_str[ZT_MAX_IPADDR_LEN];
zts_get_ipv4_address(nwid, addr_str, ZT_MAX_IPADDR_LEN);
printf("ipv4 = %s\n", addr_str);
zts_get_ipv6_address(nwid, addr_str, ZT_MAX_IPADDR_LEN);
printf("ipv6 = %s\n", addr_str);
printf("peer_count = %lu\n", zts_get_peer_count());
while(1) {
sleep(1);
}
// Stop service, delete tap interfaces, and network stack
zts_stop();
return 0;
}

40
include/Debug.hpp
View File

@@ -75,7 +75,7 @@
#endif #endif
*/ */
#define ZT_THREAD_ID 0 // #define ZT_THREAD_ID 0
#if defined(__JNI_LIB__) #if defined(__JNI_LIB__)
#include <jni.h> #include <jni.h>
@@ -86,15 +86,15 @@
#endif #endif
#if ZT_DEBUG_LEVEL >= ZT_MSG_TEST #if ZT_DEBUG_LEVEL >= ZT_MSG_TEST
#define DEBUG_TEST(fmt, args...) fprintf(stderr, ZT_CYN "TEST [%d] : %17s:%5d:%25s: " fmt \ #define DEBUG_TEST(fmt, args...) fprintf(stderr, ZT_CYN "TEST : %17s:%5d:%25s: " fmt \
"\n" ZT_RESET, ZT_THREAD_ID, ZT_FILENAME, __LINE__, __FUNCTION__, ##args) "\n" ZT_RESET, ZT_FILENAME, __LINE__, __FUNCTION__, ##args)
#else #else
#define DEBUG_ERROR(fmt, args...) #define DEBUG_ERROR(fmt, args...)
#endif #endif
#if ZT_DEBUG_LEVEL >= ZT_MSG_ERROR #if ZT_DEBUG_LEVEL >= ZT_MSG_ERROR
#define DEBUG_ERROR(fmt, args...) fprintf(stderr, ZT_RED "ERROR[%d] : %17s:%5d:%25s: " fmt \ #define DEBUG_ERROR(fmt, args...) fprintf(stderr, ZT_RED "ERROR: %17s:%5d:%25s: " fmt \
"\n" ZT_RESET, ZT_THREAD_ID, ZT_FILENAME, __LINE__, __FUNCTION__, ##args) "\n" ZT_RESET, ZT_FILENAME, __LINE__, __FUNCTION__, ##args)
#else #else
#define DEBUG_ERROR(fmt, args...) #define DEBUG_ERROR(fmt, args...)
#endif #endif
@@ -110,14 +110,14 @@
#define DEBUG_STACK(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, ZT_LOG_TAG, \ #define DEBUG_STACK(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, ZT_LOG_TAG, \
"STACK: %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args)) "STACK: %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args))
#else #else
#define DEBUG_INFO(fmt, args...) fprintf(stderr, \ #define DEBUG_INFO(fmt, args...) fprintf(stderr, \
"INFO [%d] : %17s:%5d:%25s: " fmt "\n", ZT_THREAD_ID, ZT_FILENAME, __LINE__, __FUNCTION__, ##args) "INFO : %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args)
#define DEBUG_ATTN(fmt, args...) fprintf(stderr, ZT_CYN \ #define DEBUG_ATTN(fmt, args...) fprintf(stderr, ZT_CYN \
"ATTN [%d] : %17s:%5d:%25s: " fmt "\n" ZT_RESET, ZT_THREAD_ID, ZT_FILENAME, __LINE__, __FUNCTION__, ##args) "ATTN : %17s:%5d:%25s: " fmt "\n" ZT_RESET, ZT_FILENAME, __LINE__, __FUNCTION__, ##args)
#define DEBUG_STACK(fmt, args...) fprintf(stderr, ZT_YEL \ #define DEBUG_STACK(fmt, args...) fprintf(stderr, ZT_YEL \
"STACK[%d] : %17s:%5d:%25s: " fmt "\n" ZT_RESET, ZT_THREAD_ID, ZT_FILENAME, __LINE__, __FUNCTION__, ##args) "STACK: %17s:%5d:%25s: " fmt "\n" ZT_RESET, ZT_FILENAME, __LINE__, __FUNCTION__, ##args)
#define DEBUG_BLANK(fmt, args...) fprintf(stderr, \ #define DEBUG_BLANK(fmt, args...) fprintf(stderr, \
"INFO [%d] : %17s:%5d:" fmt "\n", ZT_THREAD_ID, ZT_FILENAME, __LINE__, ##args) "INFO : %17s:%5d:" fmt "\n", ZT_FILENAME, __LINE__, ##args)
#endif #endif
#else #else
#define DEBUG_INFO(fmt, args...) #define DEBUG_INFO(fmt, args...)
@@ -129,10 +129,10 @@
#if ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER #if ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER
#if defined(__ANDROID__) #if defined(__ANDROID__)
#define DEBUG_TRANS(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, ZT_LOG_TAG, \ #define DEBUG_TRANS(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, ZT_LOG_TAG, \
"TRANS : %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args)) "TRANS: %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args))
#else #else
#define DEBUG_TRANS(fmt, args...) fprintf(stderr, ZT_GRN "TRANS[%ld] : %17s:%5d:%25s: " fmt \ #define DEBUG_TRANS(fmt, args...) fprintf(stderr, ZT_GRN "TRANS: %17s:%5d:%25s: " fmt \
"\n" ZT_RESET, ZT_THREAD_ID, ZT_FILENAME, __LINE__, __FUNCTION__, ##args) "\n" ZT_RESET, ZT_FILENAME, __LINE__, __FUNCTION__, ##args)
#endif #endif
#else #else
#define DEBUG_TRANS(fmt, args...) #define DEBUG_TRANS(fmt, args...)
@@ -141,10 +141,10 @@
#if ZT_DEBUG_LEVEL >= ZT_MSG_EXTRA #if ZT_DEBUG_LEVEL >= ZT_MSG_EXTRA
#if defined(__ANDROID__) #if defined(__ANDROID__)
#define DEBUG_EXTRA(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, ZT_LOG_TAG, \ #define DEBUG_EXTRA(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, ZT_LOG_TAG, \
"EXTRA : %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args)) "EXTRA: %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args))
#else #else
#define DEBUG_EXTRA(fmt, args...) fprintf(stderr, \ #define DEBUG_EXTRA(fmt, args...) fprintf(stderr, \
"EXTRA[%d] : %17s:%5d:%25s: " fmt "\n", ZT_THREAD_ID, ZT_FILENAME, __LINE__, __FUNCTION__, ##args) "EXTRA: %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args)
#endif #endif
#else #else
#define DEBUG_EXTRA(fmt, args...) #define DEBUG_EXTRA(fmt, args...)
@@ -155,8 +155,8 @@
#define DEBUG_FLOW(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, ZT_LOG_TAG, \ #define DEBUG_FLOW(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, ZT_LOG_TAG, \
"FLOW : %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args)) "FLOW : %17s:%5d:%25s: " fmt "\n", ZT_FILENAME, __LINE__, __FUNCTION__, ##args))
#else #else
#define DEBUG_FLOW(fmt, args...) fprintf(stderr, "FLOW [%ld] : %17s:%5d:%25s: " fmt "\n", \ #define DEBUG_FLOW(fmt, args...) fprintf(stderr, "FLOW : %17s:%5d:%25s: " fmt "\n", \
ZT_THREAD_ID, ZT_FILENAME, __LINE__, __FUNCTION__, ##args) ZT_FILENAME, __LINE__, __FUNCTION__, ##args)
#endif #endif
#else #else
#define DEBUG_FLOW(fmt, args...) #define DEBUG_FLOW(fmt, args...)

36
include/libzt.h
View File

@@ -495,6 +495,16 @@ int zts_shutdown(ZT_SHUTDOWN_SIG);
*/ */
std::vector<ZT_VirtualNetworkRoute> *zts_get_network_routes(char *nwid); std::vector<ZT_VirtualNetworkRoute> *zts_get_network_routes(char *nwid);
/*
* Adds a DNS nameserver for the network stack to use
*/
int zts_add_dns_nameserver(struct sockaddr *addr);
/*
* Removes a DNS nameserver
*/
int zts_remove_dns_nameserver(struct sockaddr *addr);
/****************************************************************************/ /****************************************************************************/
/* SDK Socket API Helper functions/objects --- DONT CALL THESE DIRECTLY */ /* SDK Socket API Helper functions/objects --- DONT CALL THESE DIRECTLY */
/****************************************************************************/ /****************************************************************************/
@@ -545,7 +555,7 @@ int pico_ntimers();
/****************************************************************************/ /****************************************************************************/
ZeroTier::VirtualTap *getTapByNWID(uint64_t nwid); ZeroTier::VirtualTap *getTapByNWID(uint64_t nwid);
ZeroTier::VirtualTap *getTapByAddr(ZeroTier::InetAddress &addr); ZeroTier::VirtualTap *getTapByAddr(ZeroTier::InetAddress *addr);
ZeroTier::VirtualTap *getTapByName(char *ifname); ZeroTier::VirtualTap *getTapByName(char *ifname);
ZeroTier::VirtualTap *getTapByIndex(int index); ZeroTier::VirtualTap *getTapByIndex(int index);
@@ -554,6 +564,30 @@ ZeroTier::VirtualTap *getTapByIndex(int index);
*/ */
ZeroTier::VirtualSocket *get_virtual_socket(int fd); ZeroTier::VirtualSocket *get_virtual_socket(int fd);
/*
* Removes a VirtualSocket
*/
void del_virtual_socket(int fd);
/*
* Adds a virtualSocket
*/
void add_unassigned_virtual_socket(int fd, ZeroTier::VirtualSocket *vs);
/*
* Removes unassigned VirtualSocket
*/
void del_unassigned_virtual_socket(int fd);
/*
* Adds an assigned VirtualSocket
*/
void add_assigned_virtual_socket(ZeroTier::VirtualTap *tap, ZeroTier::VirtualSocket *vs, int fd);
/*
* Removes an assigned VirtualSocket
*/
void del_assigned_virtual_socket(ZeroTier::VirtualTap *tap, ZeroTier::VirtualSocket *vs, int fd);
/* /*
* Destroys all virtual tap devices * Destroys all virtual tap devices
*/ */

135
src/Utilities.cpp
View File

@@ -24,4 +24,137 @@
* of your own application. * of your own application.
*/ */
// Intentionally left blank #include "InetAddress.hpp"
#include "Debug.hpp"
char *beautify_eth_proto_nums(int proto)
{
if(proto == 0x0800) return (char*)"IPv4";
if(proto == 0x0806) return (char*)"ARP";
if(proto == 0x0842) return (char*)"Wake-on-LAN";
if(proto == 0x22F3) return (char*)"IETF TRILL Protocol";
if(proto == 0x22EA) return (char*)"Stream Reservation Protocol";
if(proto == 0x6003) return (char*)"DECnet Phase IV";
if(proto == 0x8035) return (char*)"Reverse Address Resolution Protocol";
if(proto == 0x809B) return (char*)"AppleTalk (Ethertalk)";
if(proto == 0x80F3) return (char*)"AppleTalk Address Resolution Protocol (AARP)";
if(proto == 0x8100) return (char*)"VLAN-tagged frame (IEEE 802.1Q) and Shortest Path Bridging IEEE 802.1aq with NNI compatibility";
if(proto == 0x8137) return (char*)"IPX";
if(proto == 0x8204) return (char*)"QNX Qnet";
if(proto == 0x86DD) return (char*)"IPv6";
if(proto == 0x8808) return (char*)"Ethernet flow control";
if(proto == 0x8809) return (char*)"Ethernet Slow Protocols";
if(proto == 0x8819) return (char*)"CobraNet";
if(proto == 0x8847) return (char*)"MPLS unicast";
if(proto == 0x8848) return (char*)"MPLS multicast";
if(proto == 0x8863) return (char*)"PPPoE Discovery Stage";
if(proto == 0x8864) return (char*)"PPPoE Session Stage";
if(proto == 0x886D) return (char*)"Intel Advanced Networking Services";
if(proto == 0x8870) return (char*)"Jumbo Frames (Obsoleted draft-ietf-isis-ext-eth-01)";
if(proto == 0x887B) return (char*)"HomePlug 1.0 MME";
if(proto == 0x888E) return (char*)"EAP over LAN (IEEE 802.1X)";
if(proto == 0x8892) return (char*)"PROFINET Protocol";
if(proto == 0x889A) return (char*)"HyperSCSI (SCSI over Ethernet)";
if(proto == 0x88A2) return (char*)"ATA over Ethernet";
if(proto == 0x88A4) return (char*)"EtherCAT Protocol";
if(proto == 0x88A8) return (char*)"Provider Bridging (IEEE 802.1ad) & Shortest Path Bridging IEEE 802.1aq";
if(proto == 0x88AB) return (char*)"Ethernet Powerlink[citation needed]";
if(proto == 0x88B8) return (char*)"GOOSE (Generic Object Oriented Substation event)";
if(proto == 0x88B9) return (char*)"GSE (Generic Substation Events) Management Services";
if(proto == 0x88BA) return (char*)"SV (Sampled Value Transmission)";
if(proto == 0x88CC) return (char*)"Link Layer Discovery Protocol (LLDP)";
if(proto == 0x88CD) return (char*)"SERCOS III";
if(proto == 0x88DC) return (char*)"WSMP, WAVE Short Message Protocol";
if(proto == 0x88E1) return (char*)"HomePlug AV MME[citation needed]";
if(proto == 0x88E3) return (char*)"Media Redundancy Protocol (IEC62439-2)";
if(proto == 0x88E5) return (char*)"MAC security (IEEE 802.1AE)";
if(proto == 0x88E7) return (char*)"Provider Backbone Bridges (PBB) (IEEE 802.1ah)";
if(proto == 0x88F7) return (char*)"Precision Time Protocol (PTP) over Ethernet (IEEE 1588)";
if(proto == 0x88FB) return (char*)"Parallel Redundancy Protocol (PRP)";
if(proto == 0x8902) return (char*)"IEEE 802.1ag Connectivity Fault Management (CFM) Protocol / ITU-T Recommendation Y.1731 (OAM)";
if(proto == 0x8906) return (char*)"Fibre Channel over Ethernet (FCoE)";
if(proto == 0x8914) return (char*)"FCoE Initialization Protocol";
if(proto == 0x8915) return (char*)"RDMA over Converged Ethernet (RoCE)";
if(proto == 0x891D) return (char*)"TTEthernet Protocol Control Frame (TTE)";
if(proto == 0x892F) return (char*)"High-availability Seamless Redundancy (HSR)";
if(proto == 0x9000) return (char*)"Ethernet Configuration Testing Protocol";
if(proto == 0x9100) return (char*)"VLAN-tagged (IEEE 802.1Q) frame with double tagging";
return (char*)"UNKNOWN";
}
/*
ZeroTier::InetAddress *ztipv6_mask(ZeroTier::InetAddress *addr, unsigned int bits)
{
ZeroTier::InetAddress r(addr);
switch(r.ss_family) {
case AF_INET:
reinterpret_cast<struct sockaddr_in *>(&r)->sin_addr.s_addr &= ZeroTier::Utils::hton((uint32_t)(0xffffffff << (32 - bits)));
break;
case AF_INET6: {
uint64_t nm[2];
memcpy(nm,reinterpret_cast<struct sockaddr_in6 *>(&r)->sin6_addr.s6_addr,16);
nm[0] &= ZeroTier::Utils::hton((uint64_t)((bits >= 64) ? 0xffffffffffffffffULL : (0xffffffffffffffffULL << (64 - bits))));
nm[1] &= ZeroTier::Utils::hton((uint64_t)((bits <= 64) ? 0ULL : (0xffffffffffffffffULL << (128 - bits))));
memcpy(reinterpret_cast<struct sockaddr_in6 *>(&r)->sin6_addr.s6_addr,nm,16);
} break;
}
return &r;
}
*/
bool ipv6_in_subnet(ZeroTier::InetAddress *subnet, ZeroTier::InetAddress *addr)
{
ZeroTier::InetAddress r(addr);
ZeroTier::InetAddress b(subnet);
const unsigned int bits = subnet->netmaskBits();
switch(r.ss_family) {
case AF_INET:
reinterpret_cast<struct sockaddr_in *>(&r)->sin_addr.s_addr &= ZeroTier::Utils::hton((uint32_t)(0xffffffff << (32 - bits)));
break;
case AF_INET6: {
uint64_t nm[2];
uint64_t nm2[2];
memcpy(nm,reinterpret_cast<struct sockaddr_in6 *>(&r)->sin6_addr.s6_addr,16);
memcpy(nm2,reinterpret_cast<struct sockaddr_in6 *>(&b)->sin6_addr.s6_addr,16);
nm[0] &= ZeroTier::Utils::hton((uint64_t)((bits >= 64) ? 0xffffffffffffffffULL : (0xffffffffffffffffULL << (64 - bits))));
nm[1] &= ZeroTier::Utils::hton((uint64_t)((bits <= 64) ? 0ULL : (0xffffffffffffffffULL << (128 - bits))));
nm2[0] &= ZeroTier::Utils::hton((uint64_t)((bits >= 64) ? 0xffffffffffffffffULL : (0xffffffffffffffffULL << (64 - bits))));
nm2[1] &= ZeroTier::Utils::hton((uint64_t)((bits <= 64) ? 0ULL : (0xffffffffffffffffULL << (128 - bits))));
memcpy(reinterpret_cast<struct sockaddr_in6 *>(&r)->sin6_addr.s6_addr,nm,16);
memcpy(reinterpret_cast<struct sockaddr_in6 *>(&b)->sin6_addr.s6_addr,nm2,16);
}
break;
}
char b0[64], b1[64];
memset(b0, 0, 64);
memset(b1, 0, 64);
return !strcmp(r.toIpString(b0), b.toIpString(b1));
}
void sockaddr2inet(int socket_family, const struct sockaddr *addr, ZeroTier::InetAddress *inet)
{
char ipstr[INET6_ADDRSTRLEN];
memset(ipstr, 0, INET6_ADDRSTRLEN);
if(socket_family == AF_INET) {
inet_ntop(AF_INET,
(const void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, ipstr, INET_ADDRSTRLEN);
inet->fromString(ipstr);
}
if(socket_family == AF_INET6) {
inet_ntop(AF_INET6,
(const void *)&((struct sockaddr_in6 *)addr)->sin6_addr.s6_addr, ipstr, INET6_ADDRSTRLEN);
char addrstr[64];
sprintf(addrstr, "%s", ipstr);
inet->fromString(addrstr);
}
}
void mac2str(char *macbuf, int len, unsigned char* addr)
{
snprintf(macbuf, len, "%02x:%02x:%02x:%02x:%02x:%02x",
addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
}

82
src/Utilities.hpp
View File

@@ -27,66 +27,26 @@
#ifndef UTILITIES_HPP #ifndef UTILITIES_HPP
#define UTILITIES_HPP #define UTILITIES_HPP
char *beautify_eth_proto_nums(int proto) /*
{ * Returns masked address for subnet comparisons
if(proto == 0x0800) return (char*)"IPv4"; */
if(proto == 0x0806) return (char*)"ARP"; //ZeroTier::InetAddress *ztipv6_mask(ZeroTier::InetAddress *addr, unsigned int bits);
if(proto == 0x0842) return (char*)"Wake-on-LAN"; bool ipv6_in_subnet(ZeroTier::InetAddress *subnet, ZeroTier::InetAddress *addr);
if(proto == 0x22F3) return (char*)"IETF TRILL Protocol";
if(proto == 0x22EA) return (char*)"Stream Reservation Protocol";
if(proto == 0x6003) return (char*)"DECnet Phase IV";
if(proto == 0x8035) return (char*)"Reverse Address Resolution Protocol";
if(proto == 0x809B) return (char*)"AppleTalk (Ethertalk)";
if(proto == 0x80F3) return (char*)"AppleTalk Address Resolution Protocol (AARP)";
if(proto == 0x8100) return (char*)"VLAN-tagged frame (IEEE 802.1Q) and Shortest Path Bridging IEEE 802.1aq with NNI compatibility";
if(proto == 0x8137) return (char*)"IPX";
if(proto == 0x8204) return (char*)"QNX Qnet";
if(proto == 0x86DD) return (char*)"IPv6";
if(proto == 0x8808) return (char*)"Ethernet flow control";
if(proto == 0x8809) return (char*)"Ethernet Slow Protocols";
if(proto == 0x8819) return (char*)"CobraNet";
if(proto == 0x8847) return (char*)"MPLS unicast";
if(proto == 0x8848) return (char*)"MPLS multicast";
if(proto == 0x8863) return (char*)"PPPoE Discovery Stage";
if(proto == 0x8864) return (char*)"PPPoE Session Stage";
if(proto == 0x886D) return (char*)"Intel Advanced Networking Services";
if(proto == 0x8870) return (char*)"Jumbo Frames (Obsoleted draft-ietf-isis-ext-eth-01)";
if(proto == 0x887B) return (char*)"HomePlug 1.0 MME";
if(proto == 0x888E) return (char*)"EAP over LAN (IEEE 802.1X)";
if(proto == 0x8892) return (char*)"PROFINET Protocol";
if(proto == 0x889A) return (char*)"HyperSCSI (SCSI over Ethernet)";
if(proto == 0x88A2) return (char*)"ATA over Ethernet";
if(proto == 0x88A4) return (char*)"EtherCAT Protocol";
if(proto == 0x88A8) return (char*)"Provider Bridging (IEEE 802.1ad) & Shortest Path Bridging IEEE 802.1aq";
if(proto == 0x88AB) return (char*)"Ethernet Powerlink[citation needed]";
if(proto == 0x88B8) return (char*)"GOOSE (Generic Object Oriented Substation event)";
if(proto == 0x88B9) return (char*)"GSE (Generic Substation Events) Management Services";
if(proto == 0x88BA) return (char*)"SV (Sampled Value Transmission)";
if(proto == 0x88CC) return (char*)"Link Layer Discovery Protocol (LLDP)";
if(proto == 0x88CD) return (char*)"SERCOS III";
if(proto == 0x88DC) return (char*)"WSMP, WAVE Short Message Protocol";
if(proto == 0x88E1) return (char*)"HomePlug AV MME[citation needed]";
if(proto == 0x88E3) return (char*)"Media Redundancy Protocol (IEC62439-2)";
if(proto == 0x88E5) return (char*)"MAC security (IEEE 802.1AE)";
if(proto == 0x88E7) return (char*)"Provider Backbone Bridges (PBB) (IEEE 802.1ah)";
if(proto == 0x88F7) return (char*)"Precision Time Protocol (PTP) over Ethernet (IEEE 1588)";
if(proto == 0x88FB) return (char*)"Parallel Redundancy Protocol (PRP)";
if(proto == 0x8902) return (char*)"IEEE 802.1ag Connectivity Fault Management (CFM) Protocol / ITU-T Recommendation Y.1731 (OAM)";
if(proto == 0x8906) return (char*)"Fibre Channel over Ethernet (FCoE)";
if(proto == 0x8914) return (char*)"FCoE Initialization Protocol";
if(proto == 0x8915) return (char*)"RDMA over Converged Ethernet (RoCE)";
if(proto == 0x891D) return (char*)"TTEthernet Protocol Control Frame (TTE)";
if(proto == 0x892F) return (char*)"High-availability Seamless Redundancy (HSR)";
if(proto == 0x9000) return (char*)"Ethernet Configuration Testing Protocol";
if(proto == 0x9100) return (char*)"VLAN-tagged (IEEE 802.1Q) frame with double tagging";
return (char*)"UNKNOWN";
}
void mac2str(char *macbuf, int len, unsigned char* addr) /*
{ * Convert protocol numbers to human-readable strings
snprintf(macbuf, len, "%02x:%02x:%02x:%02x:%02x:%02x", */
addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]); char *beautify_eth_proto_nums(int proto);
}
/*
* Convert a struct sockaddr to a ZeroTier::InetAddress
*/
void sockaddr2inet(int socket_family, const struct sockaddr *addr, ZeroTier::InetAddress *inet);
/*
* Convert a raw MAC address byte array into a human-readable string
*/
void mac2str(char *macbuf, int len, unsigned char* addr);
#if defined(STACK_LWIP) && defined(LIBZT_IPV6) #if defined(STACK_LWIP) && defined(LIBZT_IPV6)
#define IP6_ADDR2(ipaddr, a,b,c,d,e,f,g,h) do { (ipaddr)->addr[0] = ZeroTier::Utils::hton((u32_t)((a & 0xffff) << 16) | (b & 0xffff)); \ #define IP6_ADDR2(ipaddr, a,b,c,d,e,f,g,h) do { (ipaddr)->addr[0] = ZeroTier::Utils::hton((u32_t)((a & 0xffff) << 16) | (b & 0xffff)); \
@@ -94,7 +54,9 @@ void mac2str(char *macbuf, int len, unsigned char* addr)
(ipaddr)->addr[2] = ZeroTier::Utils::hton(((e & 0xffff) << 16) | (f & 0xffff)); \ (ipaddr)->addr[2] = ZeroTier::Utils::hton(((e & 0xffff) << 16) | (f & 0xffff)); \
(ipaddr)->addr[3] = ZeroTier::Utils::hton(((g & 0xffff) << 16) | (h & 0xffff)); } while(0) (ipaddr)->addr[3] = ZeroTier::Utils::hton(((g & 0xffff) << 16) | (h & 0xffff)); } while(0)
// Convert from standard IPV6 address structure to an lwIP native structure /*
* Convert from standard IPV6 address structure to an lwIP native structure
*/
inline void in6_to_ip6(ip6_addr_t *ba, struct sockaddr_in6 *in6) inline void in6_to_ip6(ip6_addr_t *ba, struct sockaddr_in6 *in6)
{ {
uint8_t *ip = &(in6->sin6_addr).s6_addr[0]; uint8_t *ip = &(in6->sin6_addr).s6_addr[0];

7
src/VirtualSocket.hpp
View File

@@ -82,7 +82,6 @@ namespace ZeroTier {
std::time_t closure_ts = 0; std::time_t closure_ts = 0;
VirtualSocket() { VirtualSocket() {
DEBUG_EXTRA("this=0x%x, socket_family=%d, socket_type=%d", this, socket_family, socket_type);
TXbuf = new RingBuffer<unsigned char>(ZT_TCP_TX_BUF_SZ); TXbuf = new RingBuffer<unsigned char>(ZT_TCP_TX_BUF_SZ);
RXbuf = new RingBuffer<unsigned char>(ZT_TCP_RX_BUF_SZ); RXbuf = new RingBuffer<unsigned char>(ZT_TCP_RX_BUF_SZ);
@@ -98,7 +97,11 @@ namespace ZeroTier {
app_fd = fdpair[1]; app_fd = fdpair[1];
} }
~VirtualSocket() { ~VirtualSocket() {
DEBUG_EXTRA("this=0x%x", this); close(app_fd);
close(sdk_fd);
delete TXbuf;
delete RXbuf;
TXbuf = RXbuf = NULL;
} }
}; };

196
src/VirtualTap.cpp
View File

@@ -62,6 +62,8 @@ class VirtualTap;
extern std::vector<void*> vtaps; extern std::vector<void*> vtaps;
static bool picodev_initialized;
namespace ZeroTier { namespace ZeroTier {
int VirtualTap::devno = 0; int VirtualTap::devno = 0;
@@ -94,14 +96,12 @@ namespace ZeroTier {
_phy(this,false,true) _phy(this,false,true)
{ {
vtaps.push_back((void*)this); vtaps.push_back((void*)this);
// set interface name // set interface name
char tmp3[17]; char tmp3[17];
ifindex = devno; ifindex = devno;
sprintf(tmp3, "libzt%d", devno++); sprintf(tmp3, "libzt%d-%lx", devno++, _nwid);
_dev = tmp3; _dev = tmp3;
DEBUG_INFO("set device name to: %s", _dev.c_str()); DEBUG_INFO("set VirtualTap interface name to: %s", _dev.c_str());
_thread = Thread::start(this); _thread = Thread::start(this);
} }
@@ -111,10 +111,6 @@ namespace ZeroTier {
_phy.whack(); _phy.whack();
Thread::join(_thread); Thread::join(_thread);
_phy.close(_unixListenSocket,false); _phy.close(_unixListenSocket,false);
for(int i=0; i<_VirtualSockets.size(); i++) {
delete _VirtualSockets[i];
_VirtualSockets[i] = NULL;
}
} }
void VirtualTap::setEnabled(bool en) void VirtualTap::setEnabled(bool en)
@@ -131,7 +127,7 @@ namespace ZeroTier {
{ {
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack){ if(picostack){
picostack->pico_init_interface(this, ip); picostack->pico_register_address(this, ip);
return true; return true;
} }
#endif #endif
@@ -153,15 +149,18 @@ namespace ZeroTier {
std::sort(_ips.begin(),_ips.end()); std::sort(_ips.begin(),_ips.end());
return true; return true;
#endif #endif
if(registerIpWithStack(ip)) #if defined(STACK_PICO) || defined(STACK_LWIP)
{ char ipbuf[64];
// only start the stack if we successfully registered and initialized a device to DEBUG_INFO("addIp (%s)", ip.toString(ipbuf));
// the given address if(registerIpWithStack(ip)) {
_ips.push_back(ip); if (std::find(_ips.begin(),_ips.end(),ip) == _ips.end()) {
std::sort(_ips.begin(),_ips.end()); _ips.push_back(ip);
std::sort(_ips.begin(),_ips.end());
}
return true; return true;
} }
return false; return false;
#endif
} }
bool VirtualTap::removeIp(const InetAddress &ip) bool VirtualTap::removeIp(const InetAddress &ip)
@@ -204,6 +203,19 @@ namespace ZeroTier {
return _dev; return _dev;
} }
std::string VirtualTap::nodeId() const
{
// TODO: This is inefficient and awkward, should be replaced with something more elegant
if(zt1ServiceRef) {
char id[ZT_ID_LEN+1];
sprintf(id, "%lx",((ZeroTier::OneService *)zt1ServiceRef)->getNode()->address());
return std::string(id);
}
else {
return std::string("----------");
}
}
void VirtualTap::setFriendlyName(const char *friendlyName) void VirtualTap::setFriendlyName(const char *friendlyName)
{ {
DEBUG_INFO("%s", friendlyName); DEBUG_INFO("%s", friendlyName);
@@ -215,14 +227,14 @@ namespace ZeroTier {
{ {
std::vector<MulticastGroup> newGroups; std::vector<MulticastGroup> newGroups;
Mutex::Lock _l(_multicastGroups_m); Mutex::Lock _l(_multicastGroups_m);
// TODO: get multicast subscriptions from network stack // TODO: get multicast subscriptions
std::vector<InetAddress> allIps(ips()); std::vector<InetAddress> allIps(ips());
for(std::vector<InetAddress>::iterator ip(allIps.begin());ip!=allIps.end();++ip) for(std::vector<InetAddress>::iterator ip(allIps.begin());ip!=allIps.end();++ip)
newGroups.push_back(MulticastGroup::deriveMulticastGroupForAddressResolution(*ip)); newGroups.push_back(MulticastGroup::deriveMulticastGroupForAddressResolution(*ip));
std::sort(newGroups.begin(),newGroups.end()); std::sort(newGroups.begin(),newGroups.end());
std::unique(newGroups.begin(),newGroups.end()); std::unique(newGroups.begin(),newGroups.end());
for(std::vector<MulticastGroup>::iterator m(newGroups.begin());m!=newGroups.end();++m) { for(std::vector<MulticastGroup>::iterator m(newGroups.begin());m!=newGroups.end();++m) {
if (!std::binary_search(_multicastGroups.begin(),_multicastGroups.end(),*m)) if (!std::binary_search(_multicastGroups.begin(),_multicastGroups.end(),*m))
added.push_back(*m); added.push_back(*m);
@@ -245,8 +257,12 @@ namespace ZeroTier {
throw() throw()
{ {
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) if(picostack){
picostack->pico_loop(this); picostack->pico_init_interface(this);
if(should_start_stack) {
picostack->pico_loop(this);
}
}
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
if(lwipstack) if(lwipstack)
@@ -284,12 +300,18 @@ namespace ZeroTier {
// Adds a route to the virtual tap // Adds a route to the virtual tap
bool VirtualTap::routeAdd(const InetAddress &addr, const InetAddress &nm, const InetAddress &gw) bool VirtualTap::routeAdd(const InetAddress &addr, const InetAddress &nm, const InetAddress &gw)
{ {
#if defined(NO_STACK)
return false;
#endif
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) if(picostack) {
return picostack->pico_route_add(this, addr, nm, gw, 0); return picostack->pico_route_add(this, addr, nm, gw, 0);
}
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
return true; if(lwipstack) {
return true;
}
#endif #endif
return false; return false;
} }
@@ -297,16 +319,40 @@ namespace ZeroTier {
// Deletes a route from the virtual tap // Deletes a route from the virtual tap
bool VirtualTap::routeDelete(const InetAddress &addr, const InetAddress &nm) bool VirtualTap::routeDelete(const InetAddress &addr, const InetAddress &nm)
{ {
#if defined(NO_STACK)
return false;
#endif
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) if(picostack) {
return picostack->pico_route_del(this, addr, nm, 0); return picostack->pico_route_del(this, addr, nm, 0);
}
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
return true; if(lwipstack) {
return true;
}
#endif #endif
return false; return false;
} }
void VirtualTap::addVirtualSocket(VirtualSocket *vs)
{
Mutex::Lock _l(_tcpconns_m);
_VirtualSockets.push_back(vs);
}
void VirtualTap::removeVirtualSocket(VirtualSocket *vs)
{
Mutex::Lock _l(_tcpconns_m);
for(int i=0; i<_VirtualSockets.size(); i++) {
if(vs == _VirtualSockets[i]) {
_VirtualSockets.erase(_VirtualSockets.begin() + i);
DEBUG_INFO("Removed vs=%p from vt=%p", vs, this);
break;
}
}
}
/****************************************************************************/ /****************************************************************************/
/* SDK Socket API */ /* SDK Socket API */
/****************************************************************************/ /****************************************************************************/
@@ -317,15 +363,17 @@ namespace ZeroTier {
return -1; return -1;
#endif #endif
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) if(picostack) {
Mutex::Lock _l(_tcpconns_m); Mutex::Lock _l(_tcpconns_m);
return picostack->pico_Connect(vs, addr, addrlen); return picostack->pico_Connect(vs, addr, addrlen);
}
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
if(lwipstack) if(lwipstack) {
return lwipstack->lwip_Connect(vs, addr, addrlen); return lwipstack->lwip_Connect(vs, addr, addrlen);
}
#endif #endif
return ZT_ERR_GENERAL_FAILURE; return -1;
} }
// Bind VirtualSocket to a network stack's interface // Bind VirtualSocket to a network stack's interface
@@ -333,16 +381,19 @@ namespace ZeroTier {
#if defined(NO_STACK) #if defined(NO_STACK)
return -1; return -1;
#endif #endif
Mutex::Lock _l(_tcpconns_m);
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) if(picostack) {
Mutex::Lock _l(_tcpconns_m);
return picostack->pico_Bind(vs, addr, addrlen); return picostack->pico_Bind(vs, addr, addrlen);
}
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
if(lwipstack) if(lwipstack) {
Mutex::Lock _l(_tcpconns_m);
return lwipstack->lwip_Bind(this, vs, addr, addrlen); return lwipstack->lwip_Bind(this, vs, addr, addrlen);
}
#endif #endif
return ZT_ERR_GENERAL_FAILURE; return -1;
} }
// Listen for an incoming VirtualSocket // Listen for an incoming VirtualSocket
@@ -350,18 +401,24 @@ namespace ZeroTier {
#if defined(NO_STACK) #if defined(NO_STACK)
return -1; return -1;
#endif #endif
Mutex::Lock _l(_tcpconns_m);
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) if(picostack) {
Mutex::Lock _l(_tcpconns_m);
return picostack->pico_Listen(vs, backlog); return picostack->pico_Listen(vs, backlog);
return ZT_ERR_GENERAL_FAILURE; }
else {
return ZT_ERR_GENERAL_FAILURE;
}
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
if(lwipstack) if(lwipstack) {
Mutex::Lock _l(_tcpconns_m);
return lwipstack->lwip_Listen(vs, backlog); return lwipstack->lwip_Listen(vs, backlog);
return ZT_ERR_GENERAL_FAILURE; }
else {
return ZT_ERR_GENERAL_FAILURE;
}
#endif #endif
return ZT_ERR_GENERAL_FAILURE;
} }
// Accept a VirtualSocket // Accept a VirtualSocket
@@ -370,28 +427,37 @@ namespace ZeroTier {
return NULL; return NULL;
#endif #endif
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) // TODO: separation of church and state
if(picostack) {
Mutex::Lock _l(_tcpconns_m); Mutex::Lock _l(_tcpconns_m);
return picostack->pico_Accept(vs); return picostack->pico_Accept(vs);
return NULL; }
else {
return NULL;
}
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
if(lwipstack) if(lwipstack) {
Mutex::Lock _l(_tcpconns_m);
return lwipstack->lwip_Accept(vs); return lwipstack->lwip_Accept(vs);
return NULL; }
else {
return NULL;
}
#endif #endif
return NULL;
} }
// Read from stack/buffers into the app's socket // Read from stack/buffers into the app's socket
int VirtualTap::Read(PhySocket *sock,void **uptr,bool stack_invoked) { int VirtualTap::Read(PhySocket *sock,void **uptr,bool stack_invoked) {
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) if(picostack) {
return picostack->pico_Read(this, sock, (VirtualSocket*)uptr, stack_invoked); return picostack->pico_Read(this, sock, (VirtualSocket*)uptr, stack_invoked);
}
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
if(lwipstack) if(lwipstack) {
return lwipstack->lwip_Read((VirtualSocket*)*(_phy.getuptr(sock)), stack_invoked); return lwipstack->lwip_Read((VirtualSocket*)*(_phy.getuptr(sock)), stack_invoked);
}
#endif #endif
return -1; return -1;
} }
@@ -409,12 +475,14 @@ namespace ZeroTier {
return len; return len;
} }
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) if(picostack) {
return picostack->pico_Write(vs, data, len); return picostack->pico_Write(vs, data, len);
}
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
if(lwipstack) if(lwipstack) {
return lwipstack->lwip_Write(vs, data, len); return lwipstack->lwip_Write(vs, data, len);
}
#endif #endif
return -1; return -1;
} }
@@ -426,8 +494,14 @@ namespace ZeroTier {
int err = 0; int err = 0;
#if defined(STACK_PICO) #if defined(STACK_PICO)
if(picostack) { if(picostack) {
err = picostack->pico_Connect(vs, addr, addrlen); // implicit if((err = picostack->pico_Connect(vs, addr, addrlen)) < 0) { // implicit
err = picostack->pico_Write(vs, (void*)buf, len); errno = ENOTCONN;
return err;
}
if((err = picostack->pico_Write(vs, (void*)buf, len)) < 0) {
errno = ENOBUFS; // TODO: translate pico err to something more useful
return err;
}
} }
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
@@ -439,36 +513,22 @@ namespace ZeroTier {
} }
int VirtualTap::Close(VirtualSocket *vs) { int VirtualTap::Close(VirtualSocket *vs) {
#if defined(STACK_PICO) int err = 0;
if(!vs) { if(!vs) {
DEBUG_ERROR("invalid VirtualSocket"); DEBUG_ERROR("invalid VirtualSocket");
return -1; return -1;
} }
picostack->pico_Close(vs); #if defined(STACK_PICO)
if(!vs->sock) { err = picostack->pico_Close(vs);
// DEBUG_EXTRA("invalid PhySocket");
return -1;
}
// Here we assume _tcpconns_m is already locked by caller
// FIXME: is this assumption still valid
if(vs->state==ZT_SOCK_STATE_LISTENING)
{
// since we never wrapped this socket
DEBUG_INFO("in LISTENING state, no need to close in PhyIO");
return -1;
}
else
{
if(vs->sock)
_phy.close(vs->sock, false);
}
//close(_phy.getDescriptor(vs->sock));
#endif #endif
#if defined(STACK_LWIP) #if defined(STACK_LWIP)
if(lwipstack) if(lwipstack)
lwipstack->lwip_Close(vs); lwipstack->lwip_Close(vs);
#endif #endif
return 0; // TODO if(vs->sock) {
_phy.close(vs->sock, false);
}
return err;
} }
void VirtualTap::Housekeeping() void VirtualTap::Housekeeping()

26
src/VirtualTap.hpp
View File

@@ -109,10 +109,15 @@ namespace ZeroTier {
unsigned int len); unsigned int len);
/* /*
* Get device name * Get VirtualTap device name (e.g. 'libzt4-17d72843bc2c5760')
*/ */
std::string deviceName() const; std::string deviceName() const;
/*
* Get Node ID (ZT address)
*/
std::string nodeId() const;
/* /*
* Set friendly name * Set friendly name
*/ */
@@ -153,7 +158,7 @@ namespace ZeroTier {
/* /*
* Notifies us that we can write to an application's socket * Notifies us that we can write to an application's socket
*/ */
void phyOnUnixWritable(PhySocket *sock, void **uptr, bool lwip_invoked); void phyOnUnixWritable(PhySocket *sock, void **uptr, bool stack_invoked);
/* /*
* Adds a route to the virtual tap * Adds a route to the virtual tap
@@ -165,19 +170,24 @@ namespace ZeroTier {
*/ */
bool routeDelete(const InetAddress &addr, const InetAddress &nm); bool routeDelete(const InetAddress &addr, const InetAddress &nm);
/*
* Assign a VirtualSocket to the VirtualTap
*/
void addVirtualSocket(VirtualSocket *vs);
/*
* Remove a VirtualSocket from the VirtualTap
*/
void removeVirtualSocket(VirtualSocket *vs);
/****************************************************************************/ /****************************************************************************/
/* Vars */ /* Vars */
/****************************************************************************/ /****************************************************************************/
#if defined(STACK_PICO) #if defined(STACK_PICO)
/* bool should_start_stack = false;
* Whether our picoTCP device has been initialized
*/
bool picodev_initialized = false;
struct pico_device *picodev = NULL; struct pico_device *picodev = NULL;
struct pico_device *picodev6 = NULL;
/****************************************************************************/ /****************************************************************************/
/* Guarded RX Frame Buffer for picoTCP */ /* Guarded RX Frame Buffer for picoTCP */

884
src/libzt.cpp
View File

File diff suppressed because it is too large Load Diff

391
src/picoTCP.cpp
View File

@@ -35,6 +35,7 @@
#include "pico_socket.h" #include "pico_socket.h"
#include "pico_device.h" #include "pico_device.h"
#include "pico_ipv6.h" #include "pico_ipv6.h"
#include "pico_tcp.h"
#include "libzt.h" #include "libzt.h"
#include "Utilities.hpp" #include "Utilities.hpp"
@@ -79,64 +80,80 @@ int pico_socket_shutdown(PICO_SOCKET_SHUTDOWN_SIG);
struct pico_socket * pico_socket_accept(PICO_SOCKET_ACCEPT_SIG); struct pico_socket * pico_socket_accept(PICO_SOCKET_ACCEPT_SIG);
*/ */
extern std::vector<void*> vtaps;
/*
* Whether our picoTCP device has been initialized
*/
static bool picodev_initialized;
namespace ZeroTier { namespace ZeroTier {
struct pico_device picodev; struct pico_device picodev;
ZeroTier::Mutex _picostack_driver_lock;
bool picoTCP::pico_init_interface(VirtualTap *tap, const InetAddress &ip) bool picoTCP::pico_init_interface(VirtualTap *tap)
{ {
char ipbuf[64]; bool err = false;
uint8_t hwaddr[6]; _picostack_driver_lock.lock();
if (std::find(tap->_ips.begin(),tap->_ips.end(),ip) == tap->_ips.end()) { // give right to vtap to start the stack
tap->_ips.push_back(ip); // only one stack loop is permitted
std::sort(tap->_ips.begin(),tap->_ips.end()); if(!picodev_initialized) {
tap->should_start_stack = true;
if(!tap->picodev_initialized) picodev.send = pico_eth_tx; // tx
{ picodev.poll = pico_eth_poll; // calls pico_eth_rx
picodev.send = pico_eth_tx; // tx picodev.mtu = tap->_mtu;
picodev.poll = pico_eth_poll; // calls pico_eth_rx picodev.tap = tap;
picodev.mtu = tap->_mtu; uint8_t mac[PICO_SIZE_ETH];
picodev.tap = tap; tap->_mac.copyTo(mac, PICO_SIZE_ETH);
uint8_t mac[PICO_SIZE_ETH]; if(pico_device_init(&picodev, tap->_dev.c_str(), mac) != 0) {
tap->_mac.copyTo(mac, PICO_SIZE_ETH); DEBUG_ERROR("dev init failed");
if(pico_device_init(&picodev, tap->_dev.c_str(), mac) != 0) { handle_general_failure();
DEBUG_ERROR("dev init failed"); err = false;
handle_general_failure();
return false;
}
tap->picodev_initialized = true;
}
if(ip.isV4())
{
struct pico_ip4 ipaddr, netmask;
ipaddr.addr = *((uint32_t *)ip.rawIpData());
netmask.addr = *((uint32_t *)ip.netmask().rawIpData());
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);
DEBUG_INFO("mac=%s", macbuf);
return true;
}
if(ip.isV6())
{
char ipv6_str[INET6_ADDRSTRLEN], nm_str[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, ip.rawIpData(), ipv6_str, INET6_ADDRSTRLEN);
inet_ntop(AF_INET6, ip.netmask().rawIpData(), nm_str, INET6_ADDRSTRLEN);
struct pico_ip6 ipaddr, netmask;
pico_string_to_ipv6(ipv6_str, ipaddr.addr);
pico_string_to_ipv6(nm_str, netmask.addr);
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);
DEBUG_INFO("mac=%s", macbuf);
return true;
} }
picodev_initialized = true;
err = true;
} }
return false; _picostack_driver_lock.unlock();
return err;
}
bool picoTCP::pico_register_address(VirtualTap *tap, const InetAddress &ip)
{
_picostack_driver_lock.lock();
bool err = false;
char ipbuf[64];
uint8_t hwaddr[6];
// register addresses
if(ip.isV4()) {
struct pico_ip4 ipaddr, netmask;
ipaddr.addr = *((uint32_t *)ip.rawIpData());
netmask.addr = *((uint32_t *)ip.netmask().rawIpData());
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);
DEBUG_INFO("mac=%s", macbuf);
err = true;
}
if(ip.isV6()) {
char ipv6_str[INET6_ADDRSTRLEN], nm_str[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, ip.rawIpData(), ipv6_str, INET6_ADDRSTRLEN);
inet_ntop(AF_INET6, ip.netmask().rawIpData(), nm_str, INET6_ADDRSTRLEN);
struct pico_ip6 ipaddr, netmask;
pico_string_to_ipv6(ipv6_str, ipaddr.addr);
pico_string_to_ipv6(nm_str, netmask.addr);
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);
DEBUG_INFO("mac=%s", macbuf);
err = true;
}
_picostack_driver_lock.unlock();
return err;
} }
// TODO: // TODO:
@@ -177,7 +194,9 @@ namespace ZeroTier {
while(tap->_run) while(tap->_run)
{ {
tap->_phy.poll(ZT_PHY_POLL_INTERVAL); tap->_phy.poll(ZT_PHY_POLL_INTERVAL);
//_picostack_driver_lock.lock();
pico_stack_tick(); pico_stack_tick();
//_picostack_driver_lock.unlock();
tap->Housekeeping(); tap->Housekeeping();
} }
} }
@@ -185,7 +204,12 @@ namespace ZeroTier {
// from stack socket to app socket // from stack socket to app socket
void picoTCP::pico_cb_tcp_read(ZeroTier::VirtualTap *tap, struct pico_socket *s) void picoTCP::pico_cb_tcp_read(ZeroTier::VirtualTap *tap, struct pico_socket *s)
{ {
VirtualSocket *vs = (VirtualSocket*)((VirtualBindingPair*)(s->priv))->vs; VirtualSocket *vs = (VirtualSocket*)(((VirtualBindingPair*)s->priv)->vs);
if(!vs) {
DEBUG_ERROR("s->priv yielded no valid vs");
handle_general_failure();
return;
}
Mutex::Lock _l(vs->_rx_m); Mutex::Lock _l(vs->_rx_m);
if(!tap) { if(!tap) {
@@ -211,6 +235,12 @@ namespace ZeroTier {
//DEBUG_INFO("RXbuf->count() = %d", vs->RXbuf->count()); //DEBUG_INFO("RXbuf->count() = %d", vs->RXbuf->count());
int avail = ZT_TCP_RX_BUF_SZ - vs->RXbuf->count(); int avail = ZT_TCP_RX_BUF_SZ - vs->RXbuf->count();
if(avail) { if(avail) {
DEBUG_INFO("vs->RXbuf->get_buf()= %p", vs->RXbuf->get_buf());
DEBUG_INFO("vs->RXbuf->count() = %d", vs->RXbuf->count());
DEBUG_INFO("s = %p", s);
DEBUG_INFO("avail = %d", avail);
DEBUG_INFO("tap = %p", tap);
DEBUG_INFO("peer.ip4.addr = %p", peer.ip4.addr);
r = pico_socket_recvfrom(s, vs->RXbuf->get_buf(), ZT_STACK_SOCKET_RD_MAX, r = pico_socket_recvfrom(s, vs->RXbuf->get_buf(), ZT_STACK_SOCKET_RD_MAX,
(void *)&peer.ip4.addr, &port); (void *)&peer.ip4.addr, &port);
if (r > 0) if (r > 0)
@@ -245,7 +275,12 @@ namespace ZeroTier {
void picoTCP::pico_cb_udp_read(VirtualTap *tap, struct pico_socket *s) void picoTCP::pico_cb_udp_read(VirtualTap *tap, struct pico_socket *s)
{ {
// DEBUG_INFO(); // DEBUG_INFO();
VirtualSocket *vs = (VirtualSocket*)((VirtualBindingPair*)(s->priv))->vs; VirtualSocket *vs = (VirtualSocket*)(((VirtualBindingPair*)s->priv)->vs);
if(!vs) {
DEBUG_ERROR("s->priv yielded no valid vs");
handle_general_failure();
return;
}
Mutex::Lock _l(vs->_rx_m); Mutex::Lock _l(vs->_rx_m);
if(!tap) { if(!tap) {
@@ -264,8 +299,8 @@ namespace ZeroTier {
struct pico_ip4 ip4; struct pico_ip4 ip4;
struct pico_ip6 ip6; struct pico_ip6 ip6;
} peer; } peer;
int r = 0; int r = 0, w = 0;
// TODO: Consolidate this
if(vs->socket_family == AF_INET) { if(vs->socket_family == AF_INET) {
struct sockaddr_in in4; struct sockaddr_in in4;
char udp_payload_buf[ZT_MAX_MTU]; char udp_payload_buf[ZT_MAX_MTU];
@@ -282,7 +317,9 @@ namespace ZeroTier {
memcpy(udp_msg_buf, &len, sizeof(len)); // len: sockaddr+payload 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), &in4, sizeof(in4)); // sockaddr
memcpy(udp_msg_buf + sizeof(len) + sizeof(in4), &udp_payload_buf, r); // payload memcpy(udp_msg_buf + sizeof(len) + sizeof(in4), &udp_payload_buf, r); // payload
int w = write(vs->sdk_fd, udp_msg_buf, tot_len); if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
DEBUG_ERROR("write()=%d, errno=%d", w, errno);
}
} }
if(vs->socket_family == AF_INET6) { if(vs->socket_family == AF_INET6) {
struct sockaddr_in6 in6; struct sockaddr_in6 in6;
@@ -300,13 +337,20 @@ namespace ZeroTier {
memcpy(udp_msg_buf, &len, sizeof(len)); // len: sockaddr+payload 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), &in6, sizeof(in6)); // sockaddr
memcpy(udp_msg_buf + sizeof(len) + sizeof(in6), &udp_payload_buf, r); // payload memcpy(udp_msg_buf + sizeof(len) + sizeof(in6), &udp_payload_buf, r); // payload
int w = write(vs->sdk_fd, udp_msg_buf, tot_len); if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
DEBUG_ERROR("write()=%d, errno=%d", w, errno);
}
} }
} }
void picoTCP::pico_cb_tcp_write(VirtualTap *tap, struct pico_socket *s) void picoTCP::pico_cb_tcp_write(VirtualTap *tap, struct pico_socket *s)
{ {
VirtualSocket *vs = (VirtualSocket*)((VirtualBindingPair*)(s->priv))->vs; VirtualSocket *vs = (VirtualSocket*)(((VirtualBindingPair*)s->priv)->vs);
if(!vs) {
DEBUG_ERROR("s->priv yielded no valid vs");
handle_general_failure();
return;
}
Mutex::Lock _l(vs->_tx_m); Mutex::Lock _l(vs->_tx_m);
if(!vs) { if(!vs) {
DEBUG_ERROR("invalid VirtualSocket"); DEBUG_ERROR("invalid VirtualSocket");
@@ -340,32 +384,31 @@ namespace ZeroTier {
vs->TXbuf->consume(r); vs->TXbuf->consume(r);
} }
void picoTCP::pico_cb_socket_activity(uint16_t ev, struct pico_socket *s) void picoTCP::pico_cb_socket_ev(uint16_t ev, struct pico_socket *s)
{ {
if(!(VirtualTap*)((VirtualBindingPair*)(s->priv))) //DEBUG_EXTRA("s=%p, s->state=%d %s", s, s->state, beautify_pico_state(s->state));
return; VirtualBindingPair *vbp = (VirtualBindingPair*)(s->priv);
VirtualTap *tap = (VirtualTap*)((VirtualBindingPair*)(s->priv))->tap; if(!vbp) {
VirtualSocket *vs = (VirtualSocket*)((VirtualBindingPair*)(s->priv))->vs; DEBUG_ERROR("s->priv yielded no valid VirtualBindingPair");
if(!tap || !vs) {
DEBUG_ERROR("invalid tap or vs");
handle_general_failure(); handle_general_failure();
return; return;
} }
VirtualTap *tap = static_cast<VirtualTap*>(vbp->tap);
VirtualSocket *vs = static_cast<VirtualSocket*>(vbp->vs);
int err = 0; int err = 0;
if(!vs) { if(!vs) {
DEBUG_ERROR("invalid VirtualSocket"); DEBUG_ERROR("invalid VirtualSocket");
handle_general_failure(); handle_general_failure();
return; return;
} }
// PICO_SOCK_EV_vs - triggered when VirtualSocket is established (TCP only). This event is // PICO_SOCK_EV - triggered when VirtualSocket is established (TCP only). This event is
// received either after a successful call to pico socket vsect to indicate that the VirtualSocket // received either after a successful call to pico socket vsect to indicate that the VirtualSocket
// has been established, or on a listening socket, indicating that a call to pico socket accept // has been established, or on a listening socket, indicating that a call to pico socket accept
// may now be issued in order to accept the incoming VirtualSocket from a remote host. // may now be issued in order to accept the incoming VirtualSocket from a remote host.
if (ev & PICO_SOCK_EV_CONN) { if (ev & PICO_SOCK_EV_CONN) {
//DEBUG_EXTRA("PICO_SOCK_EV_CONN");
if(vs->state == ZT_SOCK_STATE_LISTENING) if(vs->state == ZT_SOCK_STATE_LISTENING)
{ {
Mutex::Lock _l(tap->_tcpconns_m);
uint16_t port; uint16_t port;
struct pico_socket *client_psock = nullptr; struct pico_socket *client_psock = nullptr;
struct pico_ip4 orig4; struct pico_ip4 orig4;
@@ -381,7 +424,8 @@ namespace ZeroTier {
if(!client_psock) { if(!client_psock) {
DEBUG_ERROR("pico_err=%s, picosock=%p", beautify_pico_error(pico_err), s); DEBUG_ERROR("pico_err=%s, picosock=%p", beautify_pico_error(pico_err), s);
return; return;
} }
// Create a new VirtualSocket and add it to the queue, // Create a new VirtualSocket and add it to the queue,
// some time in the future a call to zts_multiplex_accept() will pick up // some time in the future a call to zts_multiplex_accept() will pick up
// this new VirtualSocket, add it to the VirtualSocket list and return its // this new VirtualSocket, add it to the VirtualSocket list and return its
@@ -389,42 +433,41 @@ namespace ZeroTier {
VirtualSocket *new_vs = new VirtualSocket(); VirtualSocket *new_vs = new VirtualSocket();
new_vs->socket_type = SOCK_STREAM; new_vs->socket_type = SOCK_STREAM;
new_vs->picosock = client_psock; new_vs->picosock = client_psock;
new_vs->tap = tap;
new_vs->picosock->priv = new VirtualBindingPair(tap,new_vs);
tap->_VirtualSockets.push_back(new_vs);
vs->_AcceptedConnections.push(new_vs);
// TODO: Condense this // TODO: Condense this
if(vs->socket_family == AF_INET) char addrstr[INET6_ADDRSTRLEN];
{ if(vs->socket_family == AF_INET) {
struct sockaddr_in in4; struct sockaddr_in in4;
in4.sin_addr.s_addr = orig4.addr; in4.sin_addr.s_addr = orig4.addr;
in4.sin_port = Utils::hton(port); in4.sin_port = Utils::hton(port);
memcpy(&(new_vs->peer_addr), &in4, sizeof(new_vs->peer_addr)); memcpy(&(new_vs->peer_addr), &in4, sizeof(new_vs->peer_addr));
char addrstr[INET_ADDRSTRLEN]; inet_ntop(AF_INET, &(in4.sin_addr), addrstr, INET6_ADDRSTRLEN);
inet_ntop(AF_INET, &(in4.sin_addr), addrstr, INET_ADDRSTRLEN);
DEBUG_EXTRA("accepted connection from: %s : %d", addrstr, port); DEBUG_EXTRA("accepted connection from: %s : %d", addrstr, port);
ZeroTier::InetAddress inet;
inet.fromString(addrstr);
new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
} }
if(vs->socket_family == AF_INET6) if(vs->socket_family == AF_INET6) {
{
struct sockaddr_in6 in6; struct sockaddr_in6 in6;
memcpy(&(in6.sin6_addr.s6_addr), &orig6, sizeof(in6.sin6_addr.s6_addr)); memcpy(&(in6.sin6_addr.s6_addr), &orig6, sizeof(in6.sin6_addr.s6_addr));
in6.sin6_port = Utils::hton(port); in6.sin6_port = Utils::hton(port);
memcpy(&(new_vs->peer_addr), &in6, sizeof(new_vs->peer_addr)); memcpy(&(new_vs->peer_addr), &in6, sizeof(new_vs->peer_addr));
char addrstr[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, &(in6.sin6_addr), addrstr, INET6_ADDRSTRLEN); inet_ntop(AF_INET6, &(in6.sin6_addr), addrstr, INET6_ADDRSTRLEN);
DEBUG_EXTRA("accepted connection from: %s : %d", addrstr, port); 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(!new_vs->tap) {
// int value = 1; DEBUG_ERROR("no valid VirtualTap could be found for this incoming connect address <%s>", addrstr);
// pico_socket_setoption(new_vs->picosock, PICO_TCP_NODELAY, &value); handle_general_failure();
return;
if(ZT_SOCK_BEHAVIOR_LINGER) {
int linger_time_ms = ZT_SOCK_BEHAVIOR_LINGER_TIME;
int t_err = 0;
if((t_err = pico_socket_setoption(new_vs->picosock, PICO_SOCKET_OPT_LINGER, &linger_time_ms)) < 0)
DEBUG_ERROR("unable to set LINGER size, err=%d, pico_err=%d, app_fd=%d, sdk_fd=%d", t_err, pico_err, vs->app_fd, vs->sdk_fd);
} }
new_vs->sock = tap->_phy.wrapSocket(new_vs->sdk_fd, new_vs); // Assign this VirtualSocket to the appropriate VirtualTap
new_vs->picosock->priv = new VirtualBindingPair(new_vs->tap,new_vs);
new_vs->tap->addVirtualSocket(new_vs);
vs->_AcceptedConnections.push(new_vs);
new_vs->sock = new_vs->tap->_phy.wrapSocket(new_vs->sdk_fd, new_vs);
} }
if(vs->state != ZT_SOCK_STATE_LISTENING) { if(vs->state != ZT_SOCK_STATE_LISTENING) {
// set state so socket multiplexer logic will pick this up // set state so socket multiplexer logic will pick this up
@@ -454,7 +497,9 @@ namespace ZeroTier {
// keep the VirtualSocket half-open (only for sending) after the FIN packet has been received, // 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. // allowing new data to be sent in the TCP CLOSE WAIT state.
if (ev & PICO_SOCK_EV_CLOSE) { if (ev & PICO_SOCK_EV_CLOSE) {
err = pico_socket_close(s); 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); //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); vs->closure_ts = std::time(nullptr);
return; return;
@@ -476,8 +521,9 @@ namespace ZeroTier {
int pico_eth_tx(struct pico_device *dev, void *buf, int len) int pico_eth_tx(struct pico_device *dev, void *buf, int len)
{ {
//_picostack_driver_lock.lock();
//DEBUG_INFO("len = %d", len); //DEBUG_INFO("len = %d", len);
VirtualTap *tap = (VirtualTap*)(dev->tap); VirtualTap *tap = static_cast<VirtualTap*>(dev->tap);
if(!tap) { if(!tap) {
DEBUG_ERROR("invalid dev->tap"); DEBUG_ERROR("invalid dev->tap");
handle_general_failure(); handle_general_failure();
@@ -489,19 +535,65 @@ namespace ZeroTier {
MAC dest_mac; MAC dest_mac;
src_mac.setTo(ethhdr->saddr, 6); src_mac.setTo(ethhdr->saddr, 6);
dest_mac.setTo(ethhdr->daddr, 6); dest_mac.setTo(ethhdr->daddr, 6);
if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) { if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
char macBuf[18], nodeBuf[11]; char macBuf[18], nodeBuf[11];
mac2str(macBuf, sizeof(macBuf), ethhdr->daddr); mac2str(macBuf, sizeof(macBuf), ethhdr->daddr);
ZeroTier::MAC mac; ZeroTier::MAC mac;
mac.setTo(ethhdr->daddr, 6); mac.setTo(ethhdr->daddr, 6);
mac.toAddress(tap->_nwid).toString(nodeBuf); mac.toAddress(tap->_nwid).toString(nodeBuf);
DEBUG_TRANS("len=%5d, dest=%s, node=%s, proto=0x%04x (%s)", len, macBuf, nodeBuf, Utils::ntoh(ethhdr->proto), beautify_eth_proto_nums(Utils::ntoh(ethhdr->proto)));
}
char flagbuf[32];
memset(&flagbuf, 0, 32);
struct pico_tcp_hdr *hdr;
void * tcp_hdr_ptr;
if(Utils::ntoh(ethhdr->proto) == 0x86dd) { // tcp, ipv6
tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
}
if(Utils::ntoh(ethhdr->proto) == 0x0800) // tcp
{
tcp_hdr_ptr = &buf + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
hdr = (struct pico_tcp_hdr *)tcp_hdr_ptr;
/*
ext/picotcp/build/include/pico_tcp.h:#define PICO_TCP_SYNACK (PICO_TCP_SYN | PICO_TCP_ACK)
ext/picotcp/build/include/pico_tcp.h:#define PICO_TCP_PSHACK (PICO_TCP_PSH | PICO_TCP_ACK)
ext/picotcp/build/include/pico_tcp.h:#define PICO_TCP_FINACK (PICO_TCP_FIN | PICO_TCP_ACK)
ext/picotcp/build/include/pico_tcp.h:#define PICO_TCP_FINPSHACK (PICO_TCP_FIN | PICO_TCP_PSH | PICO_TCP_ACK)
ext/picotcp/build/include/pico_tcp.h:#define PICO_TCP_RSTACK (PICO_TCP_RST | PICO_TCP_ACK)
*/
char *flag_ptr = flagbuf;
if (hdr->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);
}
tap->_handler(tap->_arg,NULL,tap->_nwid,src_mac,dest_mac, tap->_handler(tap->_arg,NULL,tap->_nwid,src_mac,dest_mac,
Utils::ntoh((uint16_t)ethhdr->proto),0, ((char*)buf) Utils::ntoh((uint16_t)ethhdr->proto),0, ((char*)buf)
+ sizeof(struct pico_eth_hdr),len - sizeof(struct pico_eth_hdr)); + sizeof(struct pico_eth_hdr),len - sizeof(struct pico_eth_hdr));
//_picostack_driver_lock.unlock();
return len; return len;
} }
@@ -509,6 +601,7 @@ namespace ZeroTier {
void picoTCP::pico_eth_rx(VirtualTap *tap, const MAC &from,const MAC &to,unsigned int etherType, void picoTCP::pico_eth_rx(VirtualTap *tap, const MAC &from,const MAC &to,unsigned int etherType,
const void *data,unsigned int len) const void *data,unsigned int len)
{ {
//_picostack_driver_lock.lock();
if(!tap) { if(!tap) {
DEBUG_ERROR("invalid tap"); DEBUG_ERROR("invalid tap");
handle_general_failure(); handle_general_failure();
@@ -530,45 +623,85 @@ namespace ZeroTier {
ZeroTier::MAC mac; ZeroTier::MAC mac;
mac.setTo(ethhdr.saddr, 6); mac.setTo(ethhdr.saddr, 6);
mac.toAddress(tap->_nwid).toString(nodeBuf); mac.toAddress(tap->_nwid).toString(nodeBuf);
DEBUG_TRANS("len=%5d, src=%s, node=%s, proto=0x%04x (%s)", len, macBuf, nodeBuf, etherType, beautify_eth_proto_nums(etherType));
char flagbuf[32];
memset(&flagbuf, 0, 32);
struct pico_tcp_hdr *hdr;
void * tcp_hdr_ptr;
if(etherType == 0x86dd) { // tcp, ipv6
tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
}
if(etherType == 0x0800) // tcp, ipv4
{
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;
}
}
//DEBUG_TRANS("len=%5d src=%s [%s RX --> %s] proto=0x%04x %s %s", len, macBuf, nodeBuf, tap->nodeId().c_str(), etherType, beautify_eth_proto_nums(etherType), flagbuf);
} }
// write virtual ethernet frame to guarded buffer (emptied by pico_eth_poll()) // write virtual ethernet frame to guarded buffer (emptied by pico_eth_poll())
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot, &newlen, sizeof(newlen)); // size of frame + meta memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot, &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), &ethhdr, sizeof(ethhdr)); // new eth header
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen) + sizeof(ethhdr), data, len); // frame data memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen) + sizeof(ethhdr), data, len); // frame data
tap->pico_frame_rxbuf_tot += newlen; tap->pico_frame_rxbuf_tot += newlen;
//_picostack_driver_lock.unlock();
} }
// feed frames on the guarded RX buffer (from zerotier virtual wire) into the network stack // feed frames on the guarded RX buffer (from zerotier virtual wire) into the network stack
int pico_eth_poll(struct pico_device *dev, int loop_score) int pico_eth_poll(struct pico_device *dev, int loop_score)
{ {
VirtualTap *tap = (VirtualTap*)(dev->tap); VirtualTap *tap = static_cast<VirtualTap*>(dev->tap);
if(!tap) { if(!tap) {
DEBUG_ERROR("invalid dev->tap"); DEBUG_ERROR("invalid dev->tap");
handle_general_failure(); handle_general_failure();
return ZT_ERR_GENERAL_FAILURE; return ZT_ERR_GENERAL_FAILURE;
} }
// FIXME: The copy logic and/or buffer structure should be reworked for better performance after the BETA // TODO: Optimize
// VirtualTap *tap = (VirtualTap*)netif->state;
Mutex::Lock _l(tap->_pico_frame_rxbuf_m); Mutex::Lock _l(tap->_pico_frame_rxbuf_m);
unsigned char frame[ZT_SDK_MTU]; unsigned char frame[ZT_SDK_MTU];
int len; int len, err = 0;
int err = 0;
while (tap->pico_frame_rxbuf_tot > 0 && loop_score > 0) { while (tap->pico_frame_rxbuf_tot > 0 && loop_score > 0) {
//DEBUG_FLOW(" [ FBUF -> STACK] Frame buffer SZ=%d", tap->pico_frame_rxbuf_tot); //DEBUG_FLOW(" [ FBUF -> STACK] Frame buffer SZ=%d", tap->pico_frame_rxbuf_tot);
memset(frame, 0, sizeof(frame)); memset(frame, 0, sizeof(frame));
len = 0; len = 0;
memcpy(&len, tap->pico_frame_rxbuf, sizeof(len)); // get frame len memcpy(&len, tap->pico_frame_rxbuf, sizeof(len)); // get frame len
if(len >= 0) { 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); //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 memcpy(frame, tap->pico_frame_rxbuf + sizeof(len), len-(sizeof(len)) ); // get frame data
memmove(tap->pico_frame_rxbuf, tap->pico_frame_rxbuf + len, MAX_PICO_FRAME_RX_BUF_SZ-len); // shift buffer memmove(tap->pico_frame_rxbuf, tap->pico_frame_rxbuf + len, MAX_PICO_FRAME_RX_BUF_SZ-len); // shift buffer
err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(len))); if((err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(len)))) < 0) {
// DEBUG_INFO("pico_stack_recv() = %d", err); if(picostack) {
DEBUG_ERROR("pico_stack_recv()=%d, %s", err, picostack->beautify_pico_error(pico_err));
}
}
tap->pico_frame_rxbuf_tot-=len; tap->pico_frame_rxbuf_tot-=len;
} }
else { else {
DEBUG_ERROR("Invalid frame size (%d). Exiting.",len); DEBUG_ERROR("invalid frame size (%d)",len);
handle_general_failure(); handle_general_failure();
} }
loop_score--; loop_score--;
@@ -580,7 +713,7 @@ namespace ZeroTier {
{ {
int err = 0; int err = 0;
if(!can_provision_new_socket()) { if(!can_provision_new_socket()) {
DEBUG_ERROR("cannot create additional socket, see PICO_MAX_TIMERS. current = %d", pico_ntimers()); DEBUG_ERROR("cannot create additional socket, see PICO_MAX_TIMERS. current=%d", pico_ntimers());
errno = EMFILE; errno = EMFILE;
err = -1; err = -1;
} }
@@ -596,14 +729,14 @@ namespace ZeroTier {
if(socket_type == SOCK_DGRAM) { if(socket_type == SOCK_DGRAM) {
DEBUG_INFO("SOCK_DGRAM"); DEBUG_INFO("SOCK_DGRAM");
psock = pico_socket_open( psock = pico_socket_open(
protocol_version, PICO_PROTO_UDP, &ZeroTier::picoTCP::pico_cb_socket_activity); protocol_version, PICO_PROTO_UDP, &ZeroTier::picoTCP::pico_cb_socket_ev);
if(psock) { // configure size of UDP SND/RCV buffers if(psock) { // configure size of UDP SND/RCV buffers
// TODO // TODO
} }
} }
if(socket_type == SOCK_STREAM) { if(socket_type == SOCK_STREAM) {
psock = pico_socket_open( psock = pico_socket_open(
protocol_version, PICO_PROTO_TCP, &ZeroTier::picoTCP::pico_cb_socket_activity); protocol_version, PICO_PROTO_TCP, &ZeroTier::picoTCP::pico_cb_socket_ev);
if(psock) { // configure size of TCP SND/RCV buffers if(psock) { // configure size of TCP SND/RCV buffers
int tx_buf_sz = ZT_STACK_TCP_SOCKET_TX_SZ; int tx_buf_sz = ZT_STACK_TCP_SOCKET_TX_SZ;
int rx_buf_sz = ZT_STACK_TCP_SOCKET_RX_SZ; int rx_buf_sz = ZT_STACK_TCP_SOCKET_RX_SZ;
@@ -613,14 +746,14 @@ namespace ZeroTier {
// pico_socket_setoption(psock, PICO_TCP_NODELAY, &value); // pico_socket_setoption(psock, PICO_TCP_NODELAY, &value);
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_SNDBUF, &tx_buf_sz)) < 0) if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_SNDBUF, &tx_buf_sz)) < 0)
DEBUG_ERROR("unable to set SNDBUF size, err = %d, pico_err = %d", t_err, pico_err); DEBUG_ERROR("unable to set SNDBUF size, err=%d, pico_err=%d", t_err, pico_err);
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_RCVBUF, &rx_buf_sz)) < 0) if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_RCVBUF, &rx_buf_sz)) < 0)
DEBUG_ERROR("unable to set RCVBUF size, err = %d, pico_err = %d", t_err, pico_err); DEBUG_ERROR("unable to set RCVBUF size, err=%d, pico_err=%d", t_err, pico_err);
if(ZT_SOCK_BEHAVIOR_LINGER) { if(ZT_SOCK_BEHAVIOR_LINGER) {
int linger_time_ms = ZT_SOCK_BEHAVIOR_LINGER_TIME; int linger_time_ms = ZT_SOCK_BEHAVIOR_LINGER_TIME;
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_LINGER, &linger_time_ms)) < 0) if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_LINGER, &linger_time_ms)) < 0)
DEBUG_ERROR("unable to set LINGER, err = %d, pico_err = %d", t_err, pico_err); DEBUG_ERROR("unable to set LINGER, err=%d, pico_err=%d", t_err, pico_err);
} }
} }
} }
@@ -646,6 +779,7 @@ namespace ZeroTier {
uint32_t ipval = 0; uint32_t ipval = 0;
pico_string_to_ipv4(ipv4_str, &ipval); pico_string_to_ipv4(ipv4_str, &ipval);
zaddr.addr = ipval; zaddr.addr = ipval;
//DEBUG_EXTRA("connecting to addr=%s port=%d", ipv4_str, Utils::ntoh(in4->sin_port));
err = pico_socket_connect(vs->picosock, &zaddr, in4->sin_port); err = pico_socket_connect(vs->picosock, &zaddr, in4->sin_port);
} }
if(vs->socket_family == AF_INET6) { if(vs->socket_family == AF_INET6) {
@@ -654,6 +788,7 @@ namespace ZeroTier {
char ipv6_str[INET6_ADDRSTRLEN]; char ipv6_str[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN); inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN);
pico_string_to_ipv6(ipv6_str, zaddr.addr); pico_string_to_ipv6(ipv6_str, zaddr.addr);
//DEBUG_EXTRA("connecting to addr=%s port=%d", ipv6_str, Utils::ntoh(in6->sin6_port));
err = pico_socket_connect(vs->picosock, &zaddr, in6->sin6_port); err = pico_socket_connect(vs->picosock, &zaddr, in6->sin6_port);
} }
if(err) { if(err) {
@@ -688,7 +823,7 @@ namespace ZeroTier {
inet_ntop(AF_INET, (const void *)&in4->sin_addr.s_addr, ipv4_str, INET_ADDRSTRLEN); inet_ntop(AF_INET, (const void *)&in4->sin_addr.s_addr, ipv4_str, INET_ADDRSTRLEN);
pico_string_to_ipv4(ipv4_str, &tempaddr); pico_string_to_ipv4(ipv4_str, &tempaddr);
zaddr.addr = tempaddr; zaddr.addr = tempaddr;
//DEBUG_EXTRA("addr=%s:%d", ipv4_str, Utils::ntoh(in4->sin_port)); DEBUG_EXTRA("binding to addr=%s port=%d", ipv4_str, Utils::ntoh(in4->sin_port));
err = pico_socket_bind(vs->picosock, &zaddr, (uint16_t *)&(in4->sin_port)); err = pico_socket_bind(vs->picosock, &zaddr, (uint16_t *)&(in4->sin_port));
} }
if(vs->socket_family == AF_INET6) { if(vs->socket_family == AF_INET6) {
@@ -698,7 +833,7 @@ namespace ZeroTier {
inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN); inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN);
// TODO: This isn't proper // TODO: This isn't proper
pico_string_to_ipv6("::", pip6.addr); pico_string_to_ipv6("::", pip6.addr);
//DEBUG_EXTRA("addr=%s:%d", ipv6_str, Utils::ntoh(in6->sin6_port)); DEBUG_EXTRA("binding to addr=%s port=%d", ipv6_str, Utils::ntoh(in6->sin6_port));
err = pico_socket_bind(vs->picosock, &pip6, (uint16_t *)&(in6->sin6_port)); err = pico_socket_bind(vs->picosock, &pip6, (uint16_t *)&(in6->sin6_port));
} }
if(err < 0) { if(err < 0) {
@@ -778,6 +913,11 @@ namespace ZeroTier {
int err = 0; int err = 0;
// TODO: Add RingBuffer overflow checks // TODO: Add RingBuffer overflow checks
// DEBUG_INFO("vs=%p, len=%d", vs, len); // DEBUG_INFO("vs=%p, len=%d", vs, len);
if(!vs) {
DEBUG_ERROR("invalid vs");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
Mutex::Lock _l(vs->_tx_m); Mutex::Lock _l(vs->_tx_m);
if(len <= 0) { if(len <= 0) {
DEBUG_ERROR("invalid write length (len=%d)", len); DEBUG_ERROR("invalid write length (len=%d)", len);
@@ -793,9 +933,7 @@ namespace ZeroTier {
handle_general_failure(); handle_general_failure();
return -1; return -1;
} }
if(vs->socket_type == SOCK_DGRAM) {
if(vs->socket_type == SOCK_DGRAM)
{
int r; int r;
if((r = pico_socket_write(vs->picosock, data, len)) < 0) { if((r = pico_socket_write(vs->picosock, data, len)) < 0) {
DEBUG_ERROR("unable to write to picosock=%p, err=%d (%s)", DEBUG_ERROR("unable to write to picosock=%p, err=%d (%s)",
@@ -805,28 +943,24 @@ namespace ZeroTier {
else { else {
err = r; // successful write err = r; // successful write
} }
// DEBUG_TRANS("[ UDP TX -> STACK] :: vs=%p, len=%d", vs, r);
} }
if(vs->socket_type == SOCK_STREAM) if(vs->socket_type == SOCK_STREAM) {
{
int original_txsz = vs->TXbuf->count(); int original_txsz = vs->TXbuf->count();
if(original_txsz + len >= ZT_TCP_TX_BUF_SZ) { if(original_txsz + len >= ZT_TCP_TX_BUF_SZ) {
DEBUG_ERROR("txsz=%d, len=%d", original_txsz, len); DEBUG_ERROR("txsz=%d, len=%d", original_txsz, len);
DEBUG_ERROR("TX buffer is too small, try increasing ZT_TCP_TX_BUF_SZ in libzt.h"); DEBUG_ERROR("TX buffer is too small, try increasing ZT_TCP_TX_BUF_SZ in libzt.h");
exit(0); handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
} }
int buf_w = vs->TXbuf->write((const unsigned char*)data, len); int buf_w = vs->TXbuf->write((const unsigned char*)data, len);
if (buf_w != len) { if (buf_w != len) {
// because we checked ZT_TCP_TX_BUF_SZ above, this should not happen // because we checked ZT_TCP_TX_BUF_SZ above, this should not happen
DEBUG_ERROR("TX wrote only %d but expected to write %d", buf_w, len); DEBUG_ERROR("TX wrote only %d but expected to write %d", buf_w, len);
exit(0); handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
} }
//DEBUG_INFO("TXbuf->count() = %d", vs->TXbuf->count());
int txsz = vs->TXbuf->count(); int txsz = vs->TXbuf->count();
int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX);
int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX);
//int buf_r = vs->TXbuf->read(vs->tmptxbuf, max_write_len);
if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) { if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
DEBUG_ERROR("unable to write to picosock=%p, r=%d", vs->picosock, r); DEBUG_ERROR("unable to write to picosock=%p, r=%d", vs->picosock, r);
err = -1; err = -1;
@@ -844,6 +978,11 @@ namespace ZeroTier {
int picoTCP::pico_Close(VirtualSocket *vs) int picoTCP::pico_Close(VirtualSocket *vs)
{ {
if(!vs) {
DEBUG_ERROR("invalid vs");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
DEBUG_INFO("vs=%p, picosock=%p, fd=%d", vs, vs->picosock, vs->app_fd); DEBUG_INFO("vs=%p, picosock=%p, fd=%d", vs, vs->picosock, vs->app_fd);
if(!vs || !vs->picosock) if(!vs || !vs->picosock)
return ZT_ERR_GENERAL_FAILURE; return ZT_ERR_GENERAL_FAILURE;

11
src/picoTCP.hpp
View File

@@ -40,7 +40,7 @@
#include "VirtualTap.hpp" #include "VirtualTap.hpp"
/****************************************************************************/ /****************************************************************************/
/* PicoTCP API Signatures (See libzt.h for the API an app should use) */ /* PicoTCP API Signatures (See libzt.h for the application-facing API) */
/****************************************************************************/ /****************************************************************************/
#define PICO_IPV4_TO_STRING_SIG char *ipbuf, const uint32_t ip #define PICO_IPV4_TO_STRING_SIG char *ipbuf, const uint32_t ip
@@ -94,7 +94,12 @@ namespace ZeroTier
/* /*
* Set up an interface in the network stack for the VirtualTap * Set up an interface in the network stack for the VirtualTap
*/ */
bool pico_init_interface(ZeroTier::VirtualTap *tap, const ZeroTier::InetAddress &ip); bool pico_init_interface(ZeroTier::VirtualTap *tap);
/*
* Register an address with the stack
*/
bool pico_register_address(VirtualTap *tap, const InetAddress &ip);
/* /*
* Adds a route to the picoTCP device * Adds a route to the picoTCP device
@@ -129,7 +134,7 @@ namespace ZeroTier
/* /*
* Write bytes from TX buffer to stack (prepare to be sent to ZT virtual wire) * Write bytes from TX buffer to stack (prepare to be sent to ZT virtual wire)
*/ */
static void pico_cb_socket_activity(uint16_t ev, struct pico_socket *s); static void pico_cb_socket_ev(uint16_t ev, struct pico_socket *s);
/* /*
* Packets from the ZeroTier virtual wire enter the stack here * Packets from the ZeroTier virtual wire enter the stack here

367
test/selftest.cpp
View File

@@ -47,6 +47,7 @@
#include <map> #include <map>
#include <ctime> #include <ctime>
#include <sys/time.h> #include <sys/time.h>
#include <pthread.h>
#include "libzt.h" #include "libzt.h"
@@ -98,8 +99,6 @@
#define DETAILS_STR_LEN 128 #define DETAILS_STR_LEN 128
char str[STR_SIZE];
std::map<std::string, std::string> testConf; std::map<std::string, std::string> testConf;
/* Tests in this file: /* Tests in this file:
@@ -213,7 +212,6 @@ void RECORD_RESULTS(int *test_number, bool passed, char *details, std::vector<st
(*test_number) = 0; (*test_number) = 0;
char *ok_str = (char*)"[ OK ]"; char *ok_str = (char*)"[ OK ]";
char *fail_str = (char*)"[ FAIL ]"; char *fail_str = (char*)"[ FAIL ]";
if(passed == PASSED) { if(passed == PASSED) {
DEBUG_TEST("[%d]%s", *test_number, ok_str); DEBUG_TEST("[%d]%s", *test_number, ok_str);
results->push_back(std::string(ok_str) + " " + std::string(details)); results->push_back(std::string(ok_str) + " " + std::string(details));
@@ -242,8 +240,9 @@ void RECORD_RESULTS(int *test_number, bool passed, char *details, std::vector<st
// //
void tcp_client_4(TCP_UNIT_TEST_SIG_4) void tcp_client_4(TCP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\ntcp_client_4\n"); std::string msg = "tcp_client_4";
int r, w, sockfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0)
@@ -252,26 +251,28 @@ void tcp_client_4(TCP_UNIT_TEST_SIG_4)
DEBUG_ERROR("error connecting to remote host (%d)", err); DEBUG_ERROR("error connecting to remote host (%d)", err);
// TODO: Put this test in the general API section // TODO: Put this test in the general API section
struct sockaddr_in peer_addr; struct sockaddr_storage peer_addr;
struct sockaddr_in *in4 = (struct sockaddr_in*)&peer_addr;
socklen_t peer_addrlen; socklen_t peer_addrlen;
zts_getpeername(sockfd, (struct sockaddr*)&peer_addr, &peer_addrlen); zts_getpeername(sockfd, (struct sockaddr*)&peer_addr, &peer_addrlen);
DEBUG_INFO("getpeername() => %s : %d", inet_ntoa(peer_addr.sin_addr), ntohs(peer_addr.sin_port)); DEBUG_INFO("getpeername() => %s : %d", inet_ntoa(in4->sin_addr), ntohs(in4->sin_port));
w = zts_write(sockfd, str, len); w = zts_write(sockfd, msg.c_str(), len);
r = zts_read(sockfd, rbuf, len); r = zts_read(sockfd, rbuf, len);
DEBUG_TEST("Sent : %s", str); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
sprintf(details, "tcp_client_4, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
// //
void tcp_server_4(TCP_UNIT_TEST_SIG_4) void tcp_server_4(TCP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\ntcp_server_4\n"); std::string msg = "tcp_server_4";
int w=0, r=0, sockfd, accfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int w=0, r=0, sockfd, accfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0)
@@ -284,10 +285,11 @@ void tcp_server_4(TCP_UNIT_TEST_SIG_4)
DEBUG_ERROR("error accepting connection (%d)", err); DEBUG_ERROR("error accepting connection (%d)", err);
// TODO: Put this test in the general API section // TODO: Put this test in the general API section
struct sockaddr_in peer_addr; struct sockaddr_storage peer_addr;
struct sockaddr_in *in4 = (struct sockaddr_in*)&peer_addr;
socklen_t peer_addrlen; socklen_t peer_addrlen;
zts_getpeername(accfd, (struct sockaddr*)&peer_addr, &peer_addrlen); zts_getpeername(accfd, (struct sockaddr*)&peer_addr, &peer_addrlen);
DEBUG_INFO("getpeername() => %s : %d", inet_ntoa(peer_addr.sin_addr), ntohs(peer_addr.sin_port)); DEBUG_INFO("getpeername() => %s : %d", inet_ntoa(in4->sin_addr), ntohs(in4->sin_port));
r = zts_read(accfd, rbuf, sizeof rbuf); r = zts_read(accfd, rbuf, sizeof rbuf);
w = zts_write(accfd, rbuf, len); w = zts_write(accfd, rbuf, len);
@@ -295,15 +297,16 @@ void tcp_server_4(TCP_UNIT_TEST_SIG_4)
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
err = zts_close(accfd); err = zts_close(accfd);
sprintf(details, "tcp_server_4, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
// //
void tcp_client_6(TCP_UNIT_TEST_SIG_6) void tcp_client_6(TCP_UNIT_TEST_SIG_6)
{ {
fprintf(stderr, "\n\n\ntcp_client_6\n"); std::string msg = "tcp_client_6";
int r, w, sockfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
if((sockfd = zts_socket(AF_INET6, SOCK_STREAM, 0)) < 0) if((sockfd = zts_socket(AF_INET6, SOCK_STREAM, 0)) < 0)
@@ -320,21 +323,22 @@ void tcp_client_6(TCP_UNIT_TEST_SIG_6)
inet_ntop(AF_INET6, &(p6->sin6_addr), peer_addrstr, INET6_ADDRSTRLEN); inet_ntop(AF_INET6, &(p6->sin6_addr), peer_addrstr, INET6_ADDRSTRLEN);
DEBUG_INFO("getpeername() => %s : %d", peer_addrstr, ntohs(p6->sin6_port)); DEBUG_INFO("getpeername() => %s : %d", peer_addrstr, ntohs(p6->sin6_port));
w = zts_write(sockfd, str, len); w = zts_write(sockfd, msg.c_str(), len);
r = zts_read(sockfd, rbuf, len); r = zts_read(sockfd, rbuf, len);
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
sprintf(details, "tcp_client_6, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", str); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
// //
void tcp_server_6(TCP_UNIT_TEST_SIG_6) void tcp_server_6(TCP_UNIT_TEST_SIG_6)
{ {
fprintf(stderr, "\n\n\ntcp_server_6\n"); std::string msg = "tcp_sever_6";
int w=0, r=0, sockfd, accfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int w=0, r=0, sockfd, accfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
if((sockfd = zts_socket(AF_INET6, SOCK_STREAM, 0)) < 0) if((sockfd = zts_socket(AF_INET6, SOCK_STREAM, 0)) < 0)
@@ -361,8 +365,8 @@ void tcp_server_6(TCP_UNIT_TEST_SIG_6)
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
err = zts_close(accfd); err = zts_close(accfd);
sprintf(details, "tcp_server_6, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
// UDP // UDP
@@ -370,8 +374,9 @@ void tcp_server_6(TCP_UNIT_TEST_SIG_6)
// //
void udp_client_4(UDP_UNIT_TEST_SIG_4) void udp_client_4(UDP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\nudp_client_4\n"); std::string msg = "udp_client_4";
int r, w, sockfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -386,7 +391,7 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
struct sockaddr_in saddr; struct sockaddr_in saddr;
while(1) { while(1) {
// tx // tx
if((w = zts_sendto(sockfd, str, strlen(str), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) { if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
DEBUG_ERROR("error sending packet, err=%d", errno); DEBUG_ERROR("error sending packet, err=%d", errno);
} }
sleep(1); sleep(1);
@@ -394,14 +399,14 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
int serverlen = sizeof(remote_addr); int serverlen = sizeof(remote_addr);
// rx // rx
r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen); r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
if(r == strlen(str)) { if(r == strlen(msg.c_str())) {
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
DEBUG_INFO("udp_client_4, n=%d, err=%d, r=%d, w=%d\n", count, err, r, w); DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
sprintf(details, "udp_client_4, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", str); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
return; return;
} }
} }
@@ -409,8 +414,9 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
void udp_server_4(UDP_UNIT_TEST_SIG_4) void udp_server_4(UDP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\nudp_server_4\n"); std::string msg = "udp_server_4";
int r, w, sockfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -419,7 +425,7 @@ void udp_server_4(UDP_UNIT_TEST_SIG_4)
if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in)) < 0)) if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in)) < 0))
DEBUG_ERROR("error binding to interface (%d)", err); DEBUG_ERROR("error binding to interface (%d)", err);
// rx // rx
fprintf(stderr, "waiting for UDP packet...\n"); DEBUG_INFO("waiting for UDP packet...");
struct sockaddr_in saddr; struct sockaddr_in saddr;
int serverlen = sizeof(saddr); int serverlen = sizeof(saddr);
memset(&saddr, 0, sizeof(saddr)); memset(&saddr, 0, sizeof(saddr));
@@ -433,29 +439,30 @@ void udp_server_4(UDP_UNIT_TEST_SIG_4)
long int tx_ti = get_now_ts(); long int tx_ti = get_now_ts();
while(1) { while(1) {
sleep(1); sleep(1);
DEBUG_INFO("sending UDP packet"); //DEBUG_INFO("sending UDP packet");
if((w = zts_sendto(sockfd, str, strlen(str), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) { if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
DEBUG_ERROR("error sending packet, err=%d", errno); DEBUG_ERROR("error sending packet, err=%d", errno);
} }
if(get_now_ts() >= tx_ti + 20000) { if(get_now_ts() >= tx_ti + 20000) {
//fprintf(stderr, "tx_ti=%d\n", tx_ti); DEBUG_INFO("get_now_ts()-tx_ti=%d\n", get_now_ts()-tx_ti);
break; break;
} }
} }
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
//err = zts_close(sockfd); //err = zts_close(sockfd);
DEBUG_INFO("udp_server_4, n=%d, err=%d, r=%d, w=%d\n", count, err, r, w); DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
sprintf(details, "udp_server_4, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", str); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
// //
void udp_client_6(UDP_UNIT_TEST_SIG_6) void udp_client_6(UDP_UNIT_TEST_SIG_6)
{ {
fprintf(stderr, "\n\n\nudp_client_6\n"); std::string msg = "udp_client_6";
int r, w, sockfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -463,29 +470,31 @@ void udp_client_6(UDP_UNIT_TEST_SIG_6)
DEBUG_ERROR("error creating ZeroTier socket"); DEBUG_ERROR("error creating ZeroTier socket");
if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0)) if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0))
std::cout << "error setting O_NONBLOCK (errno=" << strerror(errno) << ")" << std::endl; std::cout << "error setting O_NONBLOCK (errno=" << strerror(errno) << ")" << std::endl;
fprintf(stderr, "sending UDP packets until I get a single response...\n"); DEBUG_INFO("[1] sending UDP packets until I get a single response...\n");
if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0)) if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0))
DEBUG_ERROR("error binding to interface (%d)", err); DEBUG_ERROR("error binding to interface (%d)", err);
// start sending UDP packets in the hopes that at least one will be picked up by the server
struct sockaddr_in saddr; struct sockaddr_in saddr;
while(1) { while(1) {
// tx // tx
if((w = zts_sendto(sockfd, str, strlen(str), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) { if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
DEBUG_ERROR("error sending packet, err=%d", errno); DEBUG_ERROR("error sending packet, err=%d", errno);
} }
sleep(1); usleep(100000);
memset(rbuf, 0, sizeof(rbuf)); memset(rbuf, 0, sizeof(rbuf));
int serverlen = sizeof(remote_addr); int serverlen = sizeof(remote_addr);
// rx // rx
r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen); r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
if(r == strlen(str)) { if(r == strlen(msg.c_str())) {
DEBUG_INFO("[2] complete");
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
DEBUG_INFO("udp_client_6, n=%d, err=%d, r=%d, w=%d\n", count, err, r, w); DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
sprintf(details, "udp_client_6, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", str); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
return; return;
} }
} }
@@ -493,8 +502,9 @@ void udp_client_6(UDP_UNIT_TEST_SIG_6)
void udp_server_6(UDP_UNIT_TEST_SIG_6) void udp_server_6(UDP_UNIT_TEST_SIG_6)
{ {
fprintf(stderr, "\n\n\nudp_server_6\n"); std::string msg = "udp_server_6";
int r, w, sockfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
@@ -503,7 +513,7 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0)) if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0))
DEBUG_ERROR("error binding to interface (%d)", err); DEBUG_ERROR("error binding to interface (%d)", err);
// rx // rx
fprintf(stderr, "waiting for UDP packet...\n"); DEBUG_INFO("[1/4] waiting for UDP packet...\n");
struct sockaddr_in6 saddr; struct sockaddr_in6 saddr;
int serverlen = sizeof(saddr); int serverlen = sizeof(saddr);
memset(&saddr, 0, sizeof(saddr)); memset(&saddr, 0, sizeof(saddr));
@@ -512,29 +522,30 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
char addrstr[INET6_ADDRSTRLEN], remote_addrstr[INET6_ADDRSTRLEN]; char addrstr[INET6_ADDRSTRLEN], remote_addrstr[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, &(saddr.sin6_addr), addrstr, INET6_ADDRSTRLEN); inet_ntop(AF_INET6, &(saddr.sin6_addr), addrstr, INET6_ADDRSTRLEN);
inet_ntop(AF_INET6, &(remote_addr->sin6_addr), remote_addrstr, INET6_ADDRSTRLEN); inet_ntop(AF_INET6, &(remote_addr->sin6_addr), remote_addrstr, INET6_ADDRSTRLEN);
DEBUG_INFO("received DGRAM from %s : %d", addrstr, ntohs(saddr.sin6_port)); DEBUG_INFO("[2/4] received DGRAM from %s : %d", addrstr, ntohs(saddr.sin6_port));
DEBUG_INFO("sending DGRAM(s) to %s : %d", remote_addrstr, ntohs(remote_addr->sin6_port)); DEBUG_INFO("[2/4] sending DGRAM(s) to %s : %d", remote_addrstr, ntohs(remote_addr->sin6_port));
// once we receive a UDP packet, spend 10 seconds sending responses in the hopes that the client will see // once we receive a UDP packet, spend 10 seconds sending responses in the hopes that the client will see
// tx // tx
long int tx_ti = get_now_ts(); long int tx_ti = get_now_ts();
while(1) { while(1) {
sleep(1); usleep(100000);
DEBUG_INFO("sending UDP packet"); //DEBUG_INFO("sending UDP packet");
if((w = zts_sendto(sockfd, str, strlen(str), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) { if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
DEBUG_ERROR("error sending packet, err=%d", errno); DEBUG_ERROR("error sending packet, err=%d", errno);
} }
if(get_now_ts() >= tx_ti + 20000) { if(get_now_ts() >= tx_ti + 20000) {
//fprintf(stderr, "tx_ti=%d\n", tx_ti); DEBUG_INFO("[3/4] get_now_ts()-tx_ti=%d\n", get_now_ts()-tx_ti);
break; break;
} }
} }
DEBUG_INFO("[4/4] complete");
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
//err = zts_close(sockfd); //err = zts_close(sockfd);
DEBUG_INFO("udp_server_6, n=%d, err=%d, r=%d, w=%d\n", count, err, r, w); DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
sprintf(details, "udp_server_6, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", str); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
@@ -546,7 +557,8 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
// Maintain transfer for count OR count // Maintain transfer for count OR count
void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4) void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\ntcp_client_sustained_4\n"); std::string msg = "tcp_client_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int n=0, w=0, r=0, sockfd, err; int n=0, w=0, r=0, sockfd, err;
char *rxbuf = (char*)malloc(count*sizeof(char)); char *rxbuf = (char*)malloc(count*sizeof(char));
char *txbuf = (char*)malloc(count*sizeof(char)); char *txbuf = (char*)malloc(count*sizeof(char));
@@ -608,8 +620,8 @@ void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
float tx_rate = (float)count / (float)tx_dt; float tx_rate = (float)count / (float)tx_dt;
float rx_rate = (float)count / (float)rx_dt; float rx_rate = (float)count / (float)rx_dt;
sprintf(details, "tcp_client_sustained_4, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", sprintf(details, "%s, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s",
match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) )); msg.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
*passed = (r == count && w == count && match && err>=0); *passed = (r == count && w == count && match && err>=0);
} }
@@ -622,7 +634,8 @@ void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
// Maintain transfer for count OR count // Maintain transfer for count OR count
void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6) void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
{ {
fprintf(stderr, "\n\n\ntcp_client_sustained_6\n"); std::string msg = "tcp_server_sustained_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int n=0, w=0, r=0, sockfd, err; int n=0, w=0, r=0, sockfd, err;
char *rxbuf = (char*)malloc(count*sizeof(char)); char *rxbuf = (char*)malloc(count*sizeof(char));
char *txbuf = (char*)malloc(count*sizeof(char)); char *txbuf = (char*)malloc(count*sizeof(char));
@@ -685,8 +698,8 @@ void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
float tx_rate = (float)count / (float)tx_dt; float tx_rate = (float)count / (float)tx_dt;
float rx_rate = (float)count / (float)rx_dt; float rx_rate = (float)count / (float)rx_dt;
sprintf(details, "tcp_client_sustained_6, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", sprintf(details, "%s, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s",
match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) )); msg.c_str(), msg.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
*passed = (r == count && w == count && match && err>=0); *passed = (r == count && w == count && match && err>=0);
} }
@@ -698,7 +711,8 @@ void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
// Maintain transfer for count OR count // Maintain transfer for count OR count
void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4) void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\ntcp_server_sustained_4\n"); std::string msg = "tcp_server_sustained_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int n=0, w=0, r=0, sockfd, accfd, err; int n=0, w=0, r=0, sockfd, accfd, err;
char *rxbuf = (char*)malloc(count*sizeof(char)); char *rxbuf = (char*)malloc(count*sizeof(char));
memset(rxbuf, 0, count); memset(rxbuf, 0, count);
@@ -752,8 +766,8 @@ void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
float tx_rate = (float)count / (float)tx_dt; float tx_rate = (float)count / (float)tx_dt;
float rx_rate = (float)count / (float)rx_dt; float rx_rate = (float)count / (float)rx_dt;
sprintf(details, "tcp_server_sustained_4, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", sprintf(details, "%s, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s",
count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) )); msg.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
*passed = (r == count && w == count && err>=0); *passed = (r == count && w == count && err>=0);
} }
@@ -764,7 +778,8 @@ void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
// Maintain transfer for count OR count // Maintain transfer for count OR count
void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6) void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
{ {
fprintf(stderr, "\n\n\ntcp_server_sustained_6\n"); std::string msg = "tcp_server_sustained_6";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int n=0, w=0, r=0, sockfd, accfd, err; int n=0, w=0, r=0, sockfd, accfd, err;
char *rxbuf = (char*)malloc(count*sizeof(char)); char *rxbuf = (char*)malloc(count*sizeof(char));
memset(rxbuf, 0, count); memset(rxbuf, 0, count);
@@ -816,8 +831,8 @@ void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
float tx_rate = (float)count / (float)tx_dt; float tx_rate = (float)count / (float)tx_dt;
float rx_rate = (float)count / (float)rx_dt; float rx_rate = (float)count / (float)rx_dt;
sprintf(details, "tcp_server_sustained_6, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", sprintf(details, "%s, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s",
count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) )); msg.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
*passed = (r == count && w == count && err>=0); *passed = (r == count && w == count && err>=0);
} }
@@ -826,15 +841,16 @@ void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4) void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\nudp_client_sustained_4\n"); std::string msg = "udp_client_sustained_4";
int r, w, sockfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
if((sockfd = zts_socket(AF_INET, SOCK_DGRAM, 0)) < 0) if((sockfd = zts_socket(AF_INET, SOCK_DGRAM, 0)) < 0)
DEBUG_ERROR("error creating ZeroTier socket"); DEBUG_ERROR("error creating ZeroTier socket");
for(int i=0; i<1000; i++) { for(int i=0; i<1000; i++) {
w = zts_sendto(sockfd, str, strlen(str), 0, (struct sockaddr *)addr, sizeof(addr)); w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)addr, sizeof(addr));
} }
memset(rbuf, 0, sizeof(rbuf)); memset(rbuf, 0, sizeof(rbuf));
int serverlen = sizeof(addr); int serverlen = sizeof(addr);
@@ -842,16 +858,17 @@ void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
sprintf(details, "udp_client_4, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", str); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
void udp_server_sustained_4(TCP_UNIT_TEST_SIG_4) void udp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\nudp_server_sustained_4\n"); std::string msg = "udp_server_sustained_4";
int r, w, sockfd, err, len = strlen(str); fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int r, w, sockfd, err, len = strlen(msg.c_str());
char rbuf[STR_SIZE]; char rbuf[STR_SIZE];
memset(rbuf, 0, sizeof rbuf); memset(rbuf, 0, sizeof rbuf);
if((sockfd = zts_socket(AF_INET, SOCK_DGRAM, 0)) < 0) if((sockfd = zts_socket(AF_INET, SOCK_DGRAM, 0)) < 0)
@@ -867,14 +884,14 @@ void udp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
} }
//memset(rbuf, 0, sizeof(rbuf)); //memset(rbuf, 0, sizeof(rbuf));
//w = zts_sendto(sockfd, str, strlen(str), 0, (struct sockaddr *)addr, sizeof(addr)); //w = zts_sendto(sockfd, msg.c_str()), strlen(msg.c_str())), 0, (struct sockaddr *)addr, sizeof(addr));
w = r; w = r;
//sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); //sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
//err = zts_close(sockfd); //err = zts_close(sockfd);
sprintf(details, "udp_server_4, n=%d, err=%d, r=%d, w=%d", count, err, r, w); sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
DEBUG_TEST("Sent : %s", str); DEBUG_TEST("Sent : %s", msg.c_str());
DEBUG_TEST("Received : %s", rbuf); DEBUG_TEST("Received : %s", rbuf);
*passed = (w == len && r == len && !err) && !strcmp(rbuf, str); *passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
} }
/****************************************************************************/ /****************************************************************************/
@@ -977,7 +994,8 @@ void tcp_server_perf_4(TCP_UNIT_TEST_SIG_4)
void tcp_perf_tx_echo_4(TCP_UNIT_TEST_SIG_4) void tcp_perf_tx_echo_4(TCP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\ntcp_perf_tx_echo_4\n"); std::string msg = "tcp_perf_tx_echo_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int err = 0; int err = 0;
int tot = 0; int tot = 0;
@@ -1035,7 +1053,7 @@ void tcp_perf_tx_echo_4(TCP_UNIT_TEST_SIG_4)
float ts_delta = (end_time - start_time) / (float)1000; float ts_delta = (end_time - start_time) / (float)1000;
float rate = (float)tot / (float)ts_delta; float rate = (float)tot / (float)ts_delta;
sprintf(details, "tcp_perf_tx_echo_4, tot=%d, dt=%.2f, rate=%.2f MB/s", tot, ts_delta, (rate / float(ONE_MEGABYTE) )); sprintf(details, "%s, tot=%d, dt=%.2f, rate=%.2f MB/s", msg.c_str(), tot, ts_delta, (rate / float(ONE_MEGABYTE) ));
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
@@ -1045,7 +1063,8 @@ void tcp_perf_tx_echo_4(TCP_UNIT_TEST_SIG_4)
void tcp_perf_rx_echo_4(TCP_UNIT_TEST_SIG_4) void tcp_perf_rx_echo_4(TCP_UNIT_TEST_SIG_4)
{ {
fprintf(stderr, "\n\n\ntcp_perf_rx_echo_4\n"); std::string msg = "tcp_perf_rx_echo_4";
fprintf(stderr, "\n\n%s\n\n", msg.c_str());
int err = 0; int err = 0;
int mode = 0; int mode = 0;
@@ -1102,7 +1121,7 @@ void tcp_perf_rx_echo_4(TCP_UNIT_TEST_SIG_4)
long int end_time = get_now_ts(); long int end_time = get_now_ts();
float ts_delta = (end_time - start_time) / (float)1000; float ts_delta = (end_time - start_time) / (float)1000;
float rate = (float)tot / (float)ts_delta; float rate = (float)tot / (float)ts_delta;
sprintf(details, "tcp_perf_rx_echo_4, tot=%d, dt=%.2f, rate=%.2f MB/s", tot, ts_delta, (rate / float(ONE_MEGABYTE) )); sprintf(details, "%s, tot=%d, dt=%.2f, rate=%.2f MB/s", msg.c_str(), tot, ts_delta, (rate / float(ONE_MEGABYTE) ));
sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE); sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
err = zts_close(sockfd); err = zts_close(sockfd);
@@ -1505,24 +1524,145 @@ void test_bad_args()
DEBUG_TEST("SOCK_DGRAM = %d", SOCK_DGRAM); DEBUG_TEST("SOCK_DGRAM = %d", SOCK_DGRAM);
} }
void close_while_writing_test()
{
// TODO: Close a socket while another thread is writing to it or reading from it
}
void* create_socket(void *arg)
{
/*
unsigned long i = 0;
pthread_t id = pthread_self();
if(pthread_equal(id,tid[0]))
{
printf("\n First thread processing\n");
}
else
{
printf("\n Second thread processing\n");
}
for(i=0; i<(0xFFFFFFFF);i++);
return NULL;
*/
}
void multithread_socket_creation()
{
/*
pthread_t tid[2];
err = pthread_create(&(tid[i]), NULL, &create_socket, NULL);
if (err != 0)
printf("\ncan't create thread :[%s]", strerror(err));
else
printf("\n Thread created successfully\n");
*/
// TODO:
}
void multithread_rw()
{
// TODO: Test read/writes from multiple threads
}
// Tests rapid opening and closure of sockets // Tests rapid opening and closure of sockets
void close_test(struct sockaddr *bind_addr) void close_test(struct sockaddr *bind_addr)
{ {
// 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.
bool extended = false;
int tries = !extended ? 32 : 1024;
int err = 0; int err = 0;
for(int i=0; i<64; i++) for(int i=0; i<tries; i++)
{ {
int fd = zts_socket(AF_INET, SOCK_STREAM, 0); int fd;
if((err = zts_bind(fd, (struct sockaddr *)&bind_addr, sizeof(struct sockaddr_in)) < 0)) if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
DEBUG_INFO("error creating socket. sleeping until timers are released");
sleep(30);
}
if((err = zts_bind(fd, (struct sockaddr *)bind_addr, sizeof(struct sockaddr_in)) < 0)) {
DEBUG_ERROR("error binding to interface (%d)", err); DEBUG_ERROR("error binding to interface (%d)", err);
}
usleep(100000);
if((err = zts_close(fd)) < 0) { if((err = zts_close(fd)) < 0) {
DEBUG_ERROR("error closing socket (%d)", err); DEBUG_ERROR("error closing socket (%d)", err);
} }
DEBUG_INFO("i=%d, close() = %d", i, err); DEBUG_INFO("i=%d, close() = %d", i, err);
usleep(100000);
((struct sockaddr_in *)bind_addr)->sin_port++; ((struct sockaddr_in *)bind_addr)->sin_port++;
} }
} }
void bind_to_localhost_test(int port)
{
int fd, err = 0;
// ipv4, 0.0.0.0
struct sockaddr 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) {
if((err = zts_bind(fd, (struct sockaddr *)&bind_addr, sizeof(struct sockaddr_in))) == 0) {
usleep(100000);
if((err = zts_close(fd)) < 0) {
DEBUG_ERROR("error closing socket (%d)", err);
}
}
else{
DEBUG_ERROR("error binding to interface (%d)", err);
}
}
else {
DEBUG_ERROR("error creating socket", err);
}
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);
if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) > 0) {
if((err = zts_bind(fd, (struct sockaddr *)&bind_addr, sizeof(struct sockaddr_in))) == 0) {
usleep(100000);
if((err = zts_close(fd)) < 0) {
DEBUG_ERROR("error closing socket (%d)", err);
}
}
else{
DEBUG_ERROR("error binding to interface (%d)", err);
}
}
else {
DEBUG_ERROR("error creating socket", err);
}
port++;
// ipv6, [::]
DEBUG_INFO("binding to [::]");
create_addr("::", port, 6, (struct sockaddr *)&bind_addr);
if((fd = zts_socket(AF_INET6, SOCK_STREAM, 0)) > 0) {
if((err = zts_bind(fd, (struct sockaddr *)&bind_addr, sizeof(struct sockaddr_in))) == 0) {
usleep(100000);
if((err = zts_close(fd)) < 0) {
DEBUG_ERROR("error closing socket (%d)", err);
}
}
else{
DEBUG_ERROR("error binding to interface (%d)", err);
}
}
else {
DEBUG_ERROR("error creating socket", err);
}
}
/****************************************************************************/ /****************************************************************************/
/* main(), calls test_driver(...) */ /* main(), calls test_driver(...) */
/****************************************************************************/ /****************************************************************************/
@@ -1553,7 +1693,6 @@ int main(int argc , char *argv[])
std::string remote_echo_ipv4, smode; std::string remote_echo_ipv4, smode;
std::string nwid, stype, path = argv[1]; std::string nwid, stype, path = argv[1];
std::string ipstr, ipstr6, local_ipstr, local_ipstr6, remote_ipstr, remote_ipstr6; std::string ipstr, ipstr6, local_ipstr, local_ipstr6, remote_ipstr, remote_ipstr6;
memcpy(str, "welcome to the machine", 22);
// loaf config file // loaf config file
if(path.find(".conf") == std::string::npos) { if(path.find(".conf") == std::string::npos) {
@@ -1626,15 +1765,25 @@ int main(int argc , char *argv[])
memset(&details, 0, sizeof details); memset(&details, 0, sizeof details);
bool passed = 0; bool passed = 0;
struct sockaddr local_addr; struct sockaddr_storage local_addr;
struct sockaddr remote_addr; struct sockaddr_storage remote_addr;
// closure test // closure test
port = 1000; /*
port = 1000;
struct sockaddr_in in4; struct sockaddr_in in4;
DEBUG_INFO("testing closures by binding to: %s", local_ipstr.c_str());
create_addr(local_ipstr, port, 4, (struct sockaddr *)&in4); create_addr(local_ipstr, port, 4, (struct sockaddr *)&in4);
close_test((struct sockaddr*)&in4); close_test((struct sockaddr*)&in4);
*/
close_while_writing_test();
// localhost bind test
//bind_to_localhost_test(1000);
// Transmission Tests // Transmission Tests
@@ -1644,6 +1793,8 @@ int main(int argc , char *argv[])
operation = TEST_OP_N_BYTES; operation = TEST_OP_N_BYTES;
// ipv4 client/server (UDP) // ipv4 client/server (UDP)
/*
ipv = 4; ipv = 4;
if(mode == TEST_MODE_SERVER) { if(mode == TEST_MODE_SERVER) {
create_addr(local_ipstr, port, ipv, (struct sockaddr *)&local_addr); create_addr(local_ipstr, port, ipv, (struct sockaddr *)&local_addr);
@@ -1672,12 +1823,14 @@ int main(int argc , char *argv[])
} }
RECORD_RESULTS(&test_number, passed, details, &results); RECORD_RESULTS(&test_number, passed, details, &results);
port++; port++;
*/
// ipv6 client/server (UDP) // ipv6 client/server (UDP)
ipv = 6; ipv = 6;
if(mode == TEST_MODE_SERVER) { if(mode == TEST_MODE_SERVER) {
create_addr(local_ipstr6, port, ipv, (struct sockaddr *)&local_addr); create_addr(local_ipstr6, port, ipv, (struct sockaddr*)&local_addr);
create_addr(remote_ipstr6, port, ipv, (struct sockaddr *)&remote_addr); create_addr(remote_ipstr6, port, ipv, (struct sockaddr*)&remote_addr);
udp_server_6((struct sockaddr_in6 *)&local_addr, (struct sockaddr_in6 *)&remote_addr, operation, count, delay, details, &passed); udp_server_6((struct sockaddr_in6 *)&local_addr, (struct sockaddr_in6 *)&remote_addr, operation, count, delay, details, &passed);
} }
else if(mode == TEST_MODE_CLIENT) { else if(mode == TEST_MODE_CLIENT) {
@@ -1703,6 +1856,8 @@ int main(int argc , char *argv[])
RECORD_RESULTS(&test_number, passed, details, &results); RECORD_RESULTS(&test_number, passed, details, &results);
port++; port++;
exit(0);
// ipv4 sustained transfer (UDP) // ipv4 sustained transfer (UDP)
ipv = 4; ipv = 4;
if(mode == TEST_MODE_SERVER) { if(mode == TEST_MODE_SERVER) {