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

135
src/Utilities.cpp
View File

@@ -24,4 +24,137 @@
* 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
#define UTILITIES_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";
}
/*
* Returns masked address for subnet comparisons
*/
//ZeroTier::InetAddress *ztipv6_mask(ZeroTier::InetAddress *addr, unsigned int bits);
bool ipv6_in_subnet(ZeroTier::InetAddress *subnet, ZeroTier::InetAddress *addr);
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]);
}
/*
* Convert protocol numbers to human-readable strings
*/
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)
#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[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)
{
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;
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);
RXbuf = new RingBuffer<unsigned char>(ZT_TCP_RX_BUF_SZ);
@@ -98,7 +97,11 @@ namespace ZeroTier {
app_fd = fdpair[1];
}
~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;
static bool picodev_initialized;
namespace ZeroTier {
int VirtualTap::devno = 0;
@@ -94,14 +96,12 @@ namespace ZeroTier {
_phy(this,false,true)
{
vtaps.push_back((void*)this);
// set interface name
char tmp3[17];
ifindex = devno;
sprintf(tmp3, "libzt%d", devno++);
sprintf(tmp3, "libzt%d-%lx", devno++, _nwid);
_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);
}
@@ -111,10 +111,6 @@ namespace ZeroTier {
_phy.whack();
Thread::join(_thread);
_phy.close(_unixListenSocket,false);
for(int i=0; i<_VirtualSockets.size(); i++) {
delete _VirtualSockets[i];
_VirtualSockets[i] = NULL;
}
}
void VirtualTap::setEnabled(bool en)
@@ -131,7 +127,7 @@ namespace ZeroTier {
{
#if defined(STACK_PICO)
if(picostack){
picostack->pico_init_interface(this, ip);
picostack->pico_register_address(this, ip);
return true;
}
#endif
@@ -153,15 +149,18 @@ namespace ZeroTier {
std::sort(_ips.begin(),_ips.end());
return true;
#endif
if(registerIpWithStack(ip))
{
// only start the stack if we successfully registered and initialized a device to
// the given address
_ips.push_back(ip);
std::sort(_ips.begin(),_ips.end());
#if defined(STACK_PICO) || defined(STACK_LWIP)
char ipbuf[64];
DEBUG_INFO("addIp (%s)", ip.toString(ipbuf));
if(registerIpWithStack(ip)) {
if (std::find(_ips.begin(),_ips.end(),ip) == _ips.end()) {
_ips.push_back(ip);
std::sort(_ips.begin(),_ips.end());
}
return true;
}
return false;
#endif
}
bool VirtualTap::removeIp(const InetAddress &ip)
@@ -204,6 +203,19 @@ namespace ZeroTier {
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)
{
DEBUG_INFO("%s", friendlyName);
@@ -215,14 +227,14 @@ namespace ZeroTier {
{
std::vector<MulticastGroup> newGroups;
Mutex::Lock _l(_multicastGroups_m);
// TODO: get multicast subscriptions from network stack
// TODO: get multicast subscriptions
std::vector<InetAddress> allIps(ips());
for(std::vector<InetAddress>::iterator ip(allIps.begin());ip!=allIps.end();++ip)
newGroups.push_back(MulticastGroup::deriveMulticastGroupForAddressResolution(*ip));
std::sort(newGroups.begin(),newGroups.end());
std::unique(newGroups.begin(),newGroups.end());
for(std::vector<MulticastGroup>::iterator m(newGroups.begin());m!=newGroups.end();++m) {
if (!std::binary_search(_multicastGroups.begin(),_multicastGroups.end(),*m))
added.push_back(*m);
@@ -245,8 +257,12 @@ namespace ZeroTier {
throw()
{
#if defined(STACK_PICO)
if(picostack)
picostack->pico_loop(this);
if(picostack){
picostack->pico_init_interface(this);
if(should_start_stack) {
picostack->pico_loop(this);
}
}
#endif
#if defined(STACK_LWIP)
if(lwipstack)
@@ -284,12 +300,18 @@ namespace ZeroTier {
// Adds a route to the virtual tap
bool VirtualTap::routeAdd(const InetAddress &addr, const InetAddress &nm, const InetAddress &gw)
{
#if defined(NO_STACK)
return false;
#endif
#if defined(STACK_PICO)
if(picostack)
if(picostack) {
return picostack->pico_route_add(this, addr, nm, gw, 0);
}
#endif
#if defined(STACK_LWIP)
return true;
if(lwipstack) {
return true;
}
#endif
return false;
}
@@ -297,16 +319,40 @@ namespace ZeroTier {
// Deletes a route from the virtual tap
bool VirtualTap::routeDelete(const InetAddress &addr, const InetAddress &nm)
{
#if defined(NO_STACK)
return false;
#endif
#if defined(STACK_PICO)
if(picostack)
if(picostack) {
return picostack->pico_route_del(this, addr, nm, 0);
}
#endif
#if defined(STACK_LWIP)
return true;
if(lwipstack) {
return true;
}
#endif
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 */
/****************************************************************************/
@@ -317,15 +363,17 @@ namespace ZeroTier {
return -1;
#endif
#if defined(STACK_PICO)
if(picostack)
if(picostack) {
Mutex::Lock _l(_tcpconns_m);
return picostack->pico_Connect(vs, addr, addrlen);
}
#endif
#if defined(STACK_LWIP)
if(lwipstack)
if(lwipstack) {
return lwipstack->lwip_Connect(vs, addr, addrlen);
}
#endif
return ZT_ERR_GENERAL_FAILURE;
return -1;
}
// Bind VirtualSocket to a network stack's interface
@@ -333,16 +381,19 @@ namespace ZeroTier {
#if defined(NO_STACK)
return -1;
#endif
Mutex::Lock _l(_tcpconns_m);
#if defined(STACK_PICO)
if(picostack)
if(picostack) {
Mutex::Lock _l(_tcpconns_m);
return picostack->pico_Bind(vs, addr, addrlen);
}
#endif
#if defined(STACK_LWIP)
if(lwipstack)
if(lwipstack) {
Mutex::Lock _l(_tcpconns_m);
return lwipstack->lwip_Bind(this, vs, addr, addrlen);
}
#endif
return ZT_ERR_GENERAL_FAILURE;
return -1;
}
// Listen for an incoming VirtualSocket
@@ -350,18 +401,24 @@ namespace ZeroTier {
#if defined(NO_STACK)
return -1;
#endif
Mutex::Lock _l(_tcpconns_m);
#if defined(STACK_PICO)
if(picostack)
if(picostack) {
Mutex::Lock _l(_tcpconns_m);
return picostack->pico_Listen(vs, backlog);
return ZT_ERR_GENERAL_FAILURE;
}
else {
return ZT_ERR_GENERAL_FAILURE;
}
#endif
#if defined(STACK_LWIP)
if(lwipstack)
if(lwipstack) {
Mutex::Lock _l(_tcpconns_m);
return lwipstack->lwip_Listen(vs, backlog);
return ZT_ERR_GENERAL_FAILURE;
}
else {
return ZT_ERR_GENERAL_FAILURE;
}
#endif
return ZT_ERR_GENERAL_FAILURE;
}
// Accept a VirtualSocket
@@ -370,28 +427,37 @@ namespace ZeroTier {
return NULL;
#endif
#if defined(STACK_PICO)
if(picostack)
// TODO: separation of church and state
if(picostack) {
Mutex::Lock _l(_tcpconns_m);
return picostack->pico_Accept(vs);
return NULL;
}
else {
return NULL;
}
#endif
#if defined(STACK_LWIP)
if(lwipstack)
if(lwipstack) {
Mutex::Lock _l(_tcpconns_m);
return lwipstack->lwip_Accept(vs);
return NULL;
}
else {
return NULL;
}
#endif
return NULL;
}
// Read from stack/buffers into the app's socket
int VirtualTap::Read(PhySocket *sock,void **uptr,bool stack_invoked) {
#if defined(STACK_PICO)
if(picostack)
if(picostack) {
return picostack->pico_Read(this, sock, (VirtualSocket*)uptr, stack_invoked);
}
#endif
#if defined(STACK_LWIP)
if(lwipstack)
if(lwipstack) {
return lwipstack->lwip_Read((VirtualSocket*)*(_phy.getuptr(sock)), stack_invoked);
}
#endif
return -1;
}
@@ -409,12 +475,14 @@ namespace ZeroTier {
return len;
}
#if defined(STACK_PICO)
if(picostack)
if(picostack) {
return picostack->pico_Write(vs, data, len);
}
#endif
#if defined(STACK_LWIP)
if(lwipstack)
if(lwipstack) {
return lwipstack->lwip_Write(vs, data, len);
}
#endif
return -1;
}
@@ -426,8 +494,14 @@ namespace ZeroTier {
int err = 0;
#if defined(STACK_PICO)
if(picostack) {
err = picostack->pico_Connect(vs, addr, addrlen); // implicit
err = picostack->pico_Write(vs, (void*)buf, len);
if((err = picostack->pico_Connect(vs, addr, addrlen)) < 0) { // implicit
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
#if defined(STACK_LWIP)
@@ -439,36 +513,22 @@ namespace ZeroTier {
}
int VirtualTap::Close(VirtualSocket *vs) {
#if defined(STACK_PICO)
int err = 0;
if(!vs) {
DEBUG_ERROR("invalid VirtualSocket");
return -1;
}
picostack->pico_Close(vs);
if(!vs->sock) {
// 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));
#if defined(STACK_PICO)
err = picostack->pico_Close(vs);
#endif
#if defined(STACK_LWIP)
if(lwipstack)
lwipstack->lwip_Close(vs);
#endif
return 0; // TODO
if(vs->sock) {
_phy.close(vs->sock, false);
}
return err;
}
void VirtualTap::Housekeeping()

26
src/VirtualTap.hpp
View File

@@ -109,10 +109,15 @@ namespace ZeroTier {
unsigned int len);
/*
* Get device name
* Get VirtualTap device name (e.g. 'libzt4-17d72843bc2c5760')
*/
std::string deviceName() const;
/*
* Get Node ID (ZT address)
*/
std::string nodeId() const;
/*
* Set friendly name
*/
@@ -153,7 +158,7 @@ namespace ZeroTier {
/*
* 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
@@ -165,19 +170,24 @@ namespace ZeroTier {
*/
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 */
/****************************************************************************/
#if defined(STACK_PICO)
/*
* Whether our picoTCP device has been initialized
*/
bool picodev_initialized = false;
bool should_start_stack = false;
struct pico_device *picodev = NULL;
struct pico_device *picodev6 = NULL;
/****************************************************************************/
/* 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_device.h"
#include "pico_ipv6.h"
#include "pico_tcp.h"
#include "libzt.h"
#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);
*/
extern std::vector<void*> vtaps;
/*
* Whether our picoTCP device has been initialized
*/
static bool picodev_initialized;
namespace ZeroTier {
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];
uint8_t hwaddr[6];
if (std::find(tap->_ips.begin(),tap->_ips.end(),ip) == tap->_ips.end()) {
tap->_ips.push_back(ip);
std::sort(tap->_ips.begin(),tap->_ips.end());
if(!tap->picodev_initialized)
{
picodev.send = pico_eth_tx; // tx
picodev.poll = pico_eth_poll; // calls pico_eth_rx
picodev.mtu = tap->_mtu;
picodev.tap = tap;
uint8_t mac[PICO_SIZE_ETH];
tap->_mac.copyTo(mac, PICO_SIZE_ETH);
if(pico_device_init(&picodev, tap->_dev.c_str(), mac) != 0) {
DEBUG_ERROR("dev init failed");
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;
bool err = false;
_picostack_driver_lock.lock();
// give right to vtap to start the stack
// only one stack loop is permitted
if(!picodev_initialized) {
tap->should_start_stack = true;
picodev.send = pico_eth_tx; // tx
picodev.poll = pico_eth_poll; // calls pico_eth_rx
picodev.mtu = tap->_mtu;
picodev.tap = tap;
uint8_t mac[PICO_SIZE_ETH];
tap->_mac.copyTo(mac, PICO_SIZE_ETH);
if(pico_device_init(&picodev, tap->_dev.c_str(), mac) != 0) {
DEBUG_ERROR("dev init failed");
handle_general_failure();
err = false;
}
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:
@@ -177,7 +194,9 @@ namespace ZeroTier {
while(tap->_run)
{
tap->_phy.poll(ZT_PHY_POLL_INTERVAL);
//_picostack_driver_lock.lock();
pico_stack_tick();
//_picostack_driver_lock.unlock();
tap->Housekeeping();
}
}
@@ -185,7 +204,12 @@ namespace ZeroTier {
// from stack socket to app socket
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);
if(!tap) {
@@ -211,6 +235,12 @@ namespace ZeroTier {
//DEBUG_INFO("RXbuf->count() = %d", vs->RXbuf->count());
int avail = ZT_TCP_RX_BUF_SZ - vs->RXbuf->count();
if(avail) {
DEBUG_INFO("vs->RXbuf->get_buf()= %p", vs->RXbuf->get_buf());
DEBUG_INFO("vs->RXbuf->count() = %d", vs->RXbuf->count());
DEBUG_INFO("s = %p", s);
DEBUG_INFO("avail = %d", avail);
DEBUG_INFO("tap = %p", tap);
DEBUG_INFO("peer.ip4.addr = %p", peer.ip4.addr);
r = pico_socket_recvfrom(s, vs->RXbuf->get_buf(), ZT_STACK_SOCKET_RD_MAX,
(void *)&peer.ip4.addr, &port);
if (r > 0)
@@ -245,7 +275,12 @@ namespace ZeroTier {
void picoTCP::pico_cb_udp_read(VirtualTap *tap, struct pico_socket *s)
{
// 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);
if(!tap) {
@@ -264,8 +299,8 @@ namespace ZeroTier {
struct pico_ip4 ip4;
struct pico_ip6 ip6;
} peer;
int r = 0;
int r = 0, w = 0;
// TODO: Consolidate this
if(vs->socket_family == AF_INET) {
struct sockaddr_in in4;
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 + sizeof(len), &in4, sizeof(in4)); // sockaddr
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) {
struct sockaddr_in6 in6;
@@ -300,13 +337,20 @@ namespace ZeroTier {
memcpy(udp_msg_buf, &len, sizeof(len)); // len: sockaddr+payload
memcpy(udp_msg_buf + sizeof(len), &in6, sizeof(in6)); // sockaddr
memcpy(udp_msg_buf + sizeof(len) + sizeof(in6), &udp_payload_buf, r); // payload
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)
{
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);
if(!vs) {
DEBUG_ERROR("invalid VirtualSocket");
@@ -340,32 +384,31 @@ namespace ZeroTier {
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)))
return;
VirtualTap *tap = (VirtualTap*)((VirtualBindingPair*)(s->priv))->tap;
VirtualSocket *vs = (VirtualSocket*)((VirtualBindingPair*)(s->priv))->vs;
if(!tap || !vs) {
DEBUG_ERROR("invalid tap or vs");
//DEBUG_EXTRA("s=%p, s->state=%d %s", s, s->state, beautify_pico_state(s->state));
VirtualBindingPair *vbp = (VirtualBindingPair*)(s->priv);
if(!vbp) {
DEBUG_ERROR("s->priv yielded no valid VirtualBindingPair");
handle_general_failure();
return;
}
VirtualTap *tap = static_cast<VirtualTap*>(vbp->tap);
VirtualSocket *vs = static_cast<VirtualSocket*>(vbp->vs);
int err = 0;
if(!vs) {
DEBUG_ERROR("invalid VirtualSocket");
handle_general_failure();
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
// has been established, or on a listening socket, indicating that a call to pico socket accept
// may now be issued in order to accept the incoming VirtualSocket from a remote host.
if (ev & PICO_SOCK_EV_CONN) {
//DEBUG_EXTRA("PICO_SOCK_EV_CONN");
if(vs->state == ZT_SOCK_STATE_LISTENING)
{
Mutex::Lock _l(tap->_tcpconns_m);
uint16_t port;
struct pico_socket *client_psock = nullptr;
struct pico_ip4 orig4;
@@ -381,7 +424,8 @@ namespace ZeroTier {
if(!client_psock) {
DEBUG_ERROR("pico_err=%s, picosock=%p", beautify_pico_error(pico_err), s);
return;
}
}
// Create a new VirtualSocket and add it to the queue,
// 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
@@ -389,42 +433,41 @@ namespace ZeroTier {
VirtualSocket *new_vs = new VirtualSocket();
new_vs->socket_type = SOCK_STREAM;
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
if(vs->socket_family == AF_INET)
{
char addrstr[INET6_ADDRSTRLEN];
if(vs->socket_family == AF_INET) {
struct sockaddr_in in4;
in4.sin_addr.s_addr = orig4.addr;
in4.sin_port = Utils::hton(port);
memcpy(&(new_vs->peer_addr), &in4, sizeof(new_vs->peer_addr));
char addrstr[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(in4.sin_addr), addrstr, INET_ADDRSTRLEN);
inet_ntop(AF_INET, &(in4.sin_addr), addrstr, INET6_ADDRSTRLEN);
DEBUG_EXTRA("accepted connection from: %s : %d", addrstr, port);
ZeroTier::InetAddress inet;
inet.fromString(addrstr);
new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
}
if(vs->socket_family == AF_INET6)
{
if(vs->socket_family == AF_INET6) {
struct sockaddr_in6 in6;
memcpy(&(in6.sin6_addr.s6_addr), &orig6, sizeof(in6.sin6_addr.s6_addr));
in6.sin6_port = Utils::hton(port);
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);
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
}
// int value = 1;
// pico_socket_setoption(new_vs->picosock, PICO_TCP_NODELAY, &value);
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);
if(!new_vs->tap) {
DEBUG_ERROR("no valid VirtualTap could be found for this incoming connect address <%s>", addrstr);
handle_general_failure();
return;
}
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) {
// 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,
// allowing new data to be sent in the TCP CLOSE WAIT state.
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);
vs->closure_ts = std::time(nullptr);
return;
@@ -476,8 +521,9 @@ namespace ZeroTier {
int pico_eth_tx(struct pico_device *dev, void *buf, int len)
{
//_picostack_driver_lock.lock();
//DEBUG_INFO("len = %d", len);
VirtualTap *tap = (VirtualTap*)(dev->tap);
VirtualTap *tap = static_cast<VirtualTap*>(dev->tap);
if(!tap) {
DEBUG_ERROR("invalid dev->tap");
handle_general_failure();
@@ -489,19 +535,65 @@ namespace ZeroTier {
MAC dest_mac;
src_mac.setTo(ethhdr->saddr, 6);
dest_mac.setTo(ethhdr->daddr, 6);
if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
char macBuf[18], nodeBuf[11];
mac2str(macBuf, sizeof(macBuf), ethhdr->daddr);
ZeroTier::MAC mac;
mac.setTo(ethhdr->daddr, 6);
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,
Utils::ntoh((uint16_t)ethhdr->proto),0, ((char*)buf)
+ sizeof(struct pico_eth_hdr),len - sizeof(struct pico_eth_hdr));
//_picostack_driver_lock.unlock();
return len;
}
@@ -509,6 +601,7 @@ namespace ZeroTier {
void picoTCP::pico_eth_rx(VirtualTap *tap, const MAC &from,const MAC &to,unsigned int etherType,
const void *data,unsigned int len)
{
//_picostack_driver_lock.lock();
if(!tap) {
DEBUG_ERROR("invalid tap");
handle_general_failure();
@@ -530,45 +623,85 @@ namespace ZeroTier {
ZeroTier::MAC mac;
mac.setTo(ethhdr.saddr, 6);
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())
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot, &newlen, sizeof(newlen)); // size of frame + meta
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen), &ethhdr, sizeof(ethhdr)); // new eth header
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen) + sizeof(ethhdr), data, len); // frame data
tap->pico_frame_rxbuf_tot += newlen;
//_picostack_driver_lock.unlock();
}
// 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)
{
VirtualTap *tap = (VirtualTap*)(dev->tap);
VirtualTap *tap = static_cast<VirtualTap*>(dev->tap);
if(!tap) {
DEBUG_ERROR("invalid dev->tap");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
// FIXME: The copy logic and/or buffer structure should be reworked for better performance after the BETA
// VirtualTap *tap = (VirtualTap*)netif->state;
// TODO: Optimize
Mutex::Lock _l(tap->_pico_frame_rxbuf_m);
unsigned char frame[ZT_SDK_MTU];
int len;
int err = 0;
int len, err = 0;
while (tap->pico_frame_rxbuf_tot > 0 && loop_score > 0) {
//DEBUG_FLOW(" [ FBUF -> STACK] Frame buffer SZ=%d", tap->pico_frame_rxbuf_tot);
memset(frame, 0, sizeof(frame));
len = 0;
memcpy(&len, tap->pico_frame_rxbuf, sizeof(len)); // get frame len
if(len >= 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);
memcpy(frame, tap->pico_frame_rxbuf + sizeof(len), len-(sizeof(len)) ); // get frame data
memmove(tap->pico_frame_rxbuf, tap->pico_frame_rxbuf + len, MAX_PICO_FRAME_RX_BUF_SZ-len); // shift buffer
err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(len)));
// DEBUG_INFO("pico_stack_recv() = %d", err);
if((err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(len)))) < 0) {
if(picostack) {
DEBUG_ERROR("pico_stack_recv()=%d, %s", err, picostack->beautify_pico_error(pico_err));
}
}
tap->pico_frame_rxbuf_tot-=len;
}
else {
DEBUG_ERROR("Invalid frame size (%d). Exiting.",len);
DEBUG_ERROR("invalid frame size (%d)",len);
handle_general_failure();
}
loop_score--;
@@ -580,7 +713,7 @@ namespace ZeroTier {
{
int err = 0;
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;
err = -1;
}
@@ -596,14 +729,14 @@ namespace ZeroTier {
if(socket_type == SOCK_DGRAM) {
DEBUG_INFO("SOCK_DGRAM");
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
// TODO
}
}
if(socket_type == SOCK_STREAM) {
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
int tx_buf_sz = ZT_STACK_TCP_SOCKET_TX_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);
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)
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) {
int linger_time_ms = ZT_SOCK_BEHAVIOR_LINGER_TIME;
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_LINGER, &linger_time_ms)) < 0)
DEBUG_ERROR("unable to set LINGER, err = %d, pico_err = %d", t_err, pico_err);
DEBUG_ERROR("unable to set LINGER, err=%d, pico_err=%d", t_err, pico_err);
}
}
}
@@ -646,6 +779,7 @@ namespace ZeroTier {
uint32_t ipval = 0;
pico_string_to_ipv4(ipv4_str, &ipval);
zaddr.addr = ipval;
//DEBUG_EXTRA("connecting to addr=%s port=%d", ipv4_str, Utils::ntoh(in4->sin_port));
err = pico_socket_connect(vs->picosock, &zaddr, in4->sin_port);
}
if(vs->socket_family == AF_INET6) {
@@ -654,6 +788,7 @@ namespace ZeroTier {
char ipv6_str[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN);
pico_string_to_ipv6(ipv6_str, zaddr.addr);
//DEBUG_EXTRA("connecting to addr=%s port=%d", ipv6_str, Utils::ntoh(in6->sin6_port));
err = pico_socket_connect(vs->picosock, &zaddr, in6->sin6_port);
}
if(err) {
@@ -688,7 +823,7 @@ namespace ZeroTier {
inet_ntop(AF_INET, (const void *)&in4->sin_addr.s_addr, ipv4_str, INET_ADDRSTRLEN);
pico_string_to_ipv4(ipv4_str, &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));
}
if(vs->socket_family == AF_INET6) {
@@ -698,7 +833,7 @@ namespace ZeroTier {
inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN);
// TODO: This isn't proper
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));
}
if(err < 0) {
@@ -778,6 +913,11 @@ namespace ZeroTier {
int err = 0;
// TODO: Add RingBuffer overflow checks
// 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);
if(len <= 0) {
DEBUG_ERROR("invalid write length (len=%d)", len);
@@ -793,9 +933,7 @@ namespace ZeroTier {
handle_general_failure();
return -1;
}
if(vs->socket_type == SOCK_DGRAM)
{
if(vs->socket_type == SOCK_DGRAM) {
int r;
if((r = pico_socket_write(vs->picosock, data, len)) < 0) {
DEBUG_ERROR("unable to write to picosock=%p, err=%d (%s)",
@@ -805,28 +943,24 @@ namespace ZeroTier {
else {
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();
if(original_txsz + len >= ZT_TCP_TX_BUF_SZ) {
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");
exit(0);
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
int buf_w = vs->TXbuf->write((const unsigned char*)data, len);
if (buf_w != len) {
// 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);
exit(0);
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
//DEBUG_INFO("TXbuf->count() = %d", 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 buf_r = vs->TXbuf->read(vs->tmptxbuf, max_write_len);
int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX);
if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
DEBUG_ERROR("unable to write to picosock=%p, r=%d", vs->picosock, r);
err = -1;
@@ -844,6 +978,11 @@ namespace ZeroTier {
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);
if(!vs || !vs->picosock)
return ZT_ERR_GENERAL_FAILURE;

11
src/picoTCP.hpp
View File

@@ -40,7 +40,7 @@
#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
@@ -94,7 +94,12 @@ namespace ZeroTier
/*
* 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
@@ -129,7 +134,7 @@ namespace ZeroTier
/*
* 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