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

picotcp udp updates

Browse Source
This commit is contained in:
Joseph Henry
2016-12-05 10:28:02 -08:00
parent 152938d7e7
commit e640cd016b
16 changed files with 263 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ext/picotcp/include/pico_protocol.h
View File

@@ -92,6 +92,4 @@ int pico_protocol_network_loop(int loop_score, int direction);
int pico_protocol_transport_loop(int loop_score, int direction); int pico_protocol_transport_loop(int loop_score, int direction);
int pico_protocol_socket_loop(int loop_score, int direction); int pico_protocol_socket_loop(int loop_score, int direction);
// static pico_err_t get_pico_err();
#endif #endif

7
ext/picotcp/stack/pico_protocol.c
View File

@@ -11,13 +11,6 @@
#include "pico_protocol.h" #include "pico_protocol.h"
#include "pico_tree.h" #include "pico_tree.h"
/*
static pico_err_t get_pico_err()
{
return pico_err;
}
*/
struct pico_proto_rr struct pico_proto_rr
{ {
struct pico_tree *t; struct pico_tree *t;

4
make-linux.mk
View File

@@ -221,10 +221,10 @@ linux_service_and_intercept: linux_intercept linux_sdk_service
# Builds a single shared library which contains everything # Builds a single shared library which contains everything
ifeq ($(SDK_LWIP),1) ifeq ($(SDK_LWIP),1)
linux_shared_lib: $(OBJS) linux_shared_lib: $(OBJS)
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) $(ZTFLAGS) -DSDK_SERVICE -shared -o $(SHARED_LIB) $(OBJS) $(LWIP_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(SDK_INTERCEPT_C_FILES) $(LDLIBS) -ldl $(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) $(ZTFLAGS) -DSDK_INTERCEPT -shared -o $(SHARED_LIB) $(OBJS) $(LWIP_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl
else else
linux_shared_lib: $(OBJS) linux_shared_lib: $(OBJS)
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) $(ZTFLAGS) -DSDK_SERVICE -shared -o $(SHARED_LIB) $(OBJS) $(PICOTCP_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(SDK_INTERCEPT_C_FILES) $(LDLIBS) -ldl $(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) $(ZTFLAGS) -DSDK_INTERCEPT -shared -o $(SHARED_LIB) $(OBJS) $(PICO_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl
endif endif

2
make-mac.mk
View File

@@ -225,7 +225,7 @@ osx_shared_lib: lwip $(OBJS)
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(INCLUDES) $(ZTFLAGS) -DSDK_INTERCEPT -shared -o $(SHARED_LIB) $(OBJS) $(LWIP_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl $(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(INCLUDES) $(ZTFLAGS) -DSDK_INTERCEPT -shared -o $(SHARED_LIB) $(OBJS) $(LWIP_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl
else else
osx_shared_lib: pico $(OBJS) osx_shared_lib: pico $(OBJS)
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(INCLUDES) $(ZTFLAGS) -shared -o $(SHARED_LIB) $(OBJS) $(PICO_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl $(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(INCLUDES) $(ZTFLAGS) -DSDK_INTERCEPT -shared -o $(SHARED_LIB) $(OBJS) $(PICO_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl
endif endif
osx_intercept: osx_intercept:

28
src/defs.h
View File

@@ -1,3 +1,30 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
// --- lwIP // --- lwIP
#define APPLICATION_POLL_FREQ 2 #define APPLICATION_POLL_FREQ 2
#define ZT_LWIP_TCP_TIMER_INTERVAL 50 #define ZT_LWIP_TCP_TIMER_INTERVAL 50
@@ -8,7 +35,6 @@
// --- jip // --- jip
// --- General // --- General
// TCP Buffer sizes // TCP Buffer sizes

6
src/intercept.c
View File

@@ -167,7 +167,7 @@ pthread_key_t thr_id_key;
ssize_t sendto(SENDTO_SIG) ssize_t sendto(SENDTO_SIG)
{ {
DEBUG_INFO("fd=%d, len=%d", fd, (int)len); DEBUG_INFO("fd=%d, len=%d", fd, (int)len);
//if (!check_intercept_enabled()) if (!check_intercept_enabled())
return realsendto(fd, buf, len, flags, addr, addrlen); return realsendto(fd, buf, len, flags, addr, addrlen);
return zts_sendto(fd, buf, len, flags, addr, addrlen); return zts_sendto(fd, buf, len, flags, addr, addrlen);
} }
@@ -198,8 +198,8 @@ pthread_key_t thr_id_key;
ssize_t recvfrom(RECVFROM_SIG) ssize_t recvfrom(RECVFROM_SIG)
{ {
DEBUG_INFO("fd=%d", fd); DEBUG_INFO("fd=%d", fd);
if(!check_intercept_enabled()) //if(!check_intercept_enabled())
return realrecvfrom(fd, buf, len, flags, addr, addrlen); // return realrecvfrom(fd, buf, len, flags, addr, addrlen);
return zts_recvfrom(fd, buf, len, flags, addr, addrlen); return zts_recvfrom(fd, buf, len, flags, addr, addrlen);
} }
#endif #endif

13
src/sockets.c
View File

@@ -279,12 +279,15 @@ int (*realclose)(CLOSE_SIG);
ssize_t zts_recvfrom(RECVFROM_SIG) ssize_t zts_recvfrom(RECVFROM_SIG)
#endif #endif
{ {
int tmpsz = 0; // payload size int payload_offset, tmpsz = 0; // payload size
if(read(fd, buf, ZT_MAX_MTU) > 0) { char tmpbuf[ZT_MAX_MTU];
if(read(fd, tmpbuf, ZT_MAX_MTU) > 0) {
// TODO: case for address size mismatch? // TODO: case for address size mismatch?
memcpy(addr, buf, *addrlen); memcpy(addr, tmpbuf, *addrlen);
DEBUG_ERROR("addrlen = %d", *addrlen); memcpy(&tmpsz, tmpbuf + sizeof(struct sockaddr_storage), sizeof(tmpsz));
memcpy(&tmpsz, buf + sizeof(struct sockaddr_storage), sizeof(tmpsz)); char body[2800];
payload_offset = sizeof(int) + sizeof(struct sockaddr_storage);
memcpy(buf, tmpbuf + payload_offset, ZT_MAX_MTU-payload_offset);
} }
else { else {
perror("read:\n"); perror("read:\n");

202
src/stack_drivers/picotcp/picotcp.cpp
View File

@@ -37,22 +37,23 @@
#include "pico_protocol.h" #include "pico_protocol.h"
#include "pico_socket.h" #include "pico_socket.h"
/*
static inline uint32_t long_be2(uint32_t le)
{
uint8_t *b = (uint8_t *)&le;
uint32_t be = 0;
uint32_t b0, b1, b2;
b0 = b[0];
b1 = b[1];
b2 = b[2];
be = b[3] + (b2 << 8) + (b1 << 16) + (b0 << 24);
return be;
}
*/
namespace ZeroTier { namespace ZeroTier {
// This may be removed in production
void check_buffer_states(Connection *conn)
{
#if defined(SDK_DEBUG)
if(conn->rxsz < 0) {
DEBUG_ERROR("conn->rxsz < 0");
exit(0);
}
if(conn->txsz < 0) {
DEBUG_ERROR("conn->txsz < 0");
exit(0);
}
#endif
}
// Reference to the tap interface // Reference to the tap interface
// This is needed due to the fact that there's a lot going on in the tap interface // This is needed due to the fact that there's a lot going on in the tap interface
// that needs to be updated on each of the network stack's callbacks and not every // that needs to be updated on each of the network stack's callbacks and not every
@@ -169,10 +170,80 @@ namespace ZeroTier {
} }
while(r > 0); while(r > 0);
return; return;
} }
DEBUG_ERROR("invalid connection"); DEBUG_ERROR("invalid connection");
} }
// RX packets from network onto internal buffer
// Also notifies the tap service that data can be read
// -----------------------------------------
// | TAP <-> MEM BUFFER <-> STACK <-> APP |
// | |
// | APP <-> I/O BUFFER <-> STACK <-> TAP |
// | |<-----------------| | RX
// -----------------------------------------
// After this step, buffer will be emptied periodically by pico_handleRead()
// Read payload is encapsulated as such:
//
// [addr|payload_len|payload]
//
void pico_cb_udp_read(NetconEthernetTap *tap, struct pico_socket *s)
{
Connection *conn = tap->getConnection(s);
if(conn) {
uint16_t port = 0;
union {
struct pico_ip4 ip4;
struct pico_ip6 ip6;
} peer;
char tmpbuf[ZT_MAX_MTU];
int tot = 0;
unsigned char *addr_pos, *sz_pos, *payload_pos;
struct sockaddr_in addr_in;
addr_in.sin_addr.s_addr = peer.ip4.addr;
addr_in.sin_port = port;
// RX
int r = tap->picostack->__pico_socket_recvfrom(s, tmpbuf, ZT_MAX_MTU, (void *)&peer.ip4.addr, &port);
DEBUG_EXTRA("read=%d", r);
// Mutex::Lock _l2(tap->_rx_buf_m);
// struct sockaddr_in6 addr_in6;
// addr_in6.sin6_addr.s6_addr;
// addr_in6.sin6_port = Utils::ntoh(s->remote_port);
// DEBUG_ATTN("remote_port=%d, local_port=%d", s->remote_port, Utils::ntoh(s->local_port));
if(conn->rxsz == DEFAULT_UDP_RX_BUF_SZ) { // if UDP buffer full
DEBUG_INFO("UDP RX buffer full. Discarding oldest payload segment");
memmove(conn->rxbuf, conn->rxbuf + ZT_MAX_MTU, DEFAULT_UDP_RX_BUF_SZ - ZT_MAX_MTU);
addr_pos = conn->rxbuf + (DEFAULT_UDP_RX_BUF_SZ - ZT_MAX_MTU); // TODO:
sz_pos = addr_pos + sizeof(struct sockaddr_storage);
conn->rxsz -= ZT_MAX_MTU;
}
else {
addr_pos = conn->rxbuf + conn->rxsz; // where we'll prepend the size of the address
sz_pos = addr_pos + sizeof(struct sockaddr_storage);
}
payload_pos = addr_pos + sizeof(struct sockaddr_storage) + sizeof(tot);
memcpy(addr_pos, &addr_in, sizeof(struct sockaddr_storage));
// Adjust buffer size
if(r) {
conn->rxsz += ZT_MAX_MTU;
memcpy(sz_pos, &r, sizeof(r));
tap->phyOnUnixWritable(conn->sock, NULL, false);
tap->_phy.setNotifyWritable(conn->sock, false);
}
if (r < 0) {
DEBUG_ERROR("unable to read from picosock=%p", s);
}
memcpy(payload_pos, tmpbuf, r); // write payload to app's socket
return;
}
}
// TX packets from internal buffer to network // TX packets from internal buffer to network
void pico_cb_tcp_write(NetconEthernetTap *tap, struct pico_socket *s) void pico_cb_tcp_write(NetconEthernetTap *tap, struct pico_socket *s)
{ {
@@ -187,7 +258,7 @@ namespace ZeroTier {
if(conn->txsz > 0) { if(conn->txsz > 0) {
int r = conn->txsz < ZT_MAX_MTU ? conn->txsz : ZT_MAX_MTU; int r = conn->txsz < ZT_MAX_MTU ? conn->txsz : ZT_MAX_MTU;
if((r = tap->picostack->__pico_socket_write(s, &conn->txbuf, r)) < 0) { if((r = tap->picostack->__pico_socket_write(s, &conn->txbuf, r)) < 0) {
DEBUG_ERROR("unable to write to pico_socket=%p", (void*)s); DEBUG_ERROR("unable to write to picosock=%p", (void*)s);
return; return;
} }
int sz = (conn->txsz)-r; int sz = (conn->txsz)-r;
@@ -195,14 +266,14 @@ namespace ZeroTier {
memmove(&conn->txbuf, (conn->txbuf+r), sz); memmove(&conn->txbuf, (conn->txbuf+r), sz);
conn->txsz -= r; conn->txsz -= r;
int max = conn->type == SOCK_STREAM ? DEFAULT_TCP_TX_BUF_SZ : DEFAULT_UDP_TX_BUF_SZ; int max = conn->type == SOCK_STREAM ? DEFAULT_TCP_TX_BUF_SZ : DEFAULT_UDP_TX_BUF_SZ;
DEBUG_TRANS("[TCP TX] ---> :: {TX: %.3f%%, RX: %.3f%%, sock=%p} :: %d bytes", DEBUG_TRANS("[TCP TX] ---> :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
(float)conn->txsz / (float)max, (float)conn->rxsz / max, (void*)&conn->sock, r); (float)conn->txsz / (float)max, (float)conn->rxsz / max, conn->sock, r);
return; return;
} }
} }
// Main callback for TCP connections // Main callback for TCP connections
void pico_cb_tcp(uint16_t ev, struct pico_socket *s) void pico_cb_socket_activity(uint16_t ev, struct pico_socket *s)
{ {
int err; int err;
Mutex::Lock _l(picotap->_tcpconns_m); Mutex::Lock _l(picotap->_tcpconns_m);
@@ -210,18 +281,14 @@ namespace ZeroTier {
if(!conn) { if(!conn) {
DEBUG_ERROR("invalid connection"); DEBUG_ERROR("invalid connection");
} }
if (ev & PICO_SOCK_EV_RD) {
pico_cb_tcp_read(picotap, s);
}
// Accept connection (analogous to lwip_nc_accept) // Accept connection (analogous to lwip_nc_accept)
if (ev & PICO_SOCK_EV_CONN) { if (ev & PICO_SOCK_EV_CONN) {
DEBUG_INFO("connection established with server, sock=%p", (void*)(conn->picosock)); DEBUG_INFO("connection established with server, picosock=%p", (void*)(conn->picosock));
uint32_t peer; uint32_t peer;
uint16_t port; uint16_t port;
struct pico_socket *client = picotap->picostack->__pico_socket_accept(s, &peer, &port); struct pico_socket *client = picotap->picostack->__pico_socket_accept(s, &peer, &port);
if(!client) { if(!client) {
DEBUG_EXTRA("unable to accept conn. (event might not be incoming, not necessarily an error), sock=%p", (void*)(conn->picosock)); DEBUG_EXTRA("unable to accept conn. (event might not be incoming, not necessarily an error), picosock=%p", (void*)(conn->picosock));
} }
ZT_PHY_SOCKFD_TYPE fds[2]; ZT_PHY_SOCKFD_TYPE fds[2];
if(socketpair(PF_LOCAL, SOCK_STREAM, 0, fds) < 0) { if(socketpair(PF_LOCAL, SOCK_STREAM, 0, fds) < 0) {
@@ -248,7 +315,6 @@ namespace ZeroTier {
} }
if (ev & PICO_SOCK_EV_ERR) { if (ev & PICO_SOCK_EV_ERR) {
DEBUG_INFO("socket error received" /*, strerror(pico_err)*/); DEBUG_INFO("socket error received" /*, strerror(pico_err)*/);
//exit(1);
} }
if (ev & PICO_SOCK_EV_CLOSE) { if (ev & PICO_SOCK_EV_CLOSE) {
err = picotap->picostack->__pico_socket_close(s); err = picotap->picostack->__pico_socket_close(s);
@@ -256,6 +322,15 @@ namespace ZeroTier {
picotap->closeConnection(conn); picotap->closeConnection(conn);
return; return;
} }
// Read from picoTCP socket
if (ev & PICO_SOCK_EV_RD) {
if(conn->type==SOCK_STREAM)
pico_cb_tcp_read(picotap, s);
if(conn->type==SOCK_DGRAM)
pico_cb_udp_read(picotap, s);
}
// Write to picoTCP socket
if (ev & PICO_SOCK_EV_WR) { if (ev & PICO_SOCK_EV_WR) {
pico_cb_tcp_write(picotap, s); pico_cb_tcp_write(picotap, s);
} }
@@ -374,19 +449,30 @@ namespace ZeroTier {
{ {
DEBUG_INFO(); DEBUG_INFO();
struct pico_socket * psock; struct pico_socket * psock;
int protocol, protocol_version;
#if defined(SDK_IPV4) #if defined(SDK_IPV4)
psock = picotap->picostack->__pico_socket_open(PICO_PROTO_IPV4, PICO_PROTO_TCP, &pico_cb_tcp); protocol_version = PICO_PROTO_IPV4;
#elif defined(SDK_IPV6) #elif defined(SDK_IPV6)
psock = picotap->picostack->__pico_socket_open(PICO_PROTO_IPV6, PICO_PROTO_TCP, &pico_cb_tcp); protocol_version = PICO_PROTO_IPV6;
#endif #endif
if(socket_rpc->socket_type == SOCK_DGRAM) {
protocol = PICO_PROTO_UDP;
psock = picotap->picostack->__pico_socket_open(protocol_version, protocol, &pico_cb_socket_activity);
}
if(socket_rpc->socket_type == SOCK_STREAM) {
protocol = PICO_PROTO_TCP;
psock = picotap->picostack->__pico_socket_open(protocol_version, protocol, &pico_cb_socket_activity);
}
if(psock) { if(psock) {
DEBUG_ATTN("psock = %p", (void*)psock); DEBUG_ATTN("physock=%p, picosock=%p", sock, (void*)psock);
Connection * newConn = new Connection(); Connection * newConn = new Connection();
*uptr = newConn; *uptr = newConn;
newConn->type = socket_rpc->socket_type; newConn->type = socket_rpc->socket_type;
newConn->sock = sock; newConn->sock = sock;
newConn->local_addr = NULL; newConn->local_addr = NULL;
newConn->peer_addr = NULL; // newConn->peer_addr = NULL;
newConn->picosock = psock; newConn->picosock = psock;
picotap->_Connections.push_back(newConn); picotap->_Connections.push_back(newConn);
return newConn; return newConn;
@@ -412,12 +498,14 @@ namespace ZeroTier {
return; return;
} }
int r, max_write_len = conn->txsz < ZT_MAX_MTU ? conn->txsz : ZT_MAX_MTU; int max, r, max_write_len = conn->txsz < ZT_MAX_MTU ? conn->txsz : ZT_MAX_MTU;
if((r = picotap->picostack->__pico_socket_write(conn->picosock, &conn->txbuf, max_write_len)) < 0) { if((r = picotap->picostack->__pico_socket_write(conn->picosock, &conn->txbuf, max_write_len)) < 0) {
DEBUG_ERROR("unable to write to pico_socket(%p), r=%d", (void*)&(conn->picosock), r); DEBUG_ERROR("unable to write to pico_socket(%p), r=%d", (conn->picosock), r);
return; return;
} }
// TODO: Errors
/* /*
if(pico_err == PICO_ERR_EINVAL) if(pico_err == PICO_ERR_EINVAL)
DEBUG_ERROR("PICO_ERR_EINVAL - invalid argument"); DEBUG_ERROR("PICO_ERR_EINVAL - invalid argument");
@@ -436,14 +524,23 @@ namespace ZeroTier {
if(pico_err == PICO_ERR_EAGAIN) if(pico_err == PICO_ERR_EAGAIN)
DEBUG_ERROR("PICO_ERR_EAGAIN - resource temporarily unavailable"); DEBUG_ERROR("PICO_ERR_EAGAIN - resource temporarily unavailable");
*/ */
// adjust buffer // adjust buffer
int sz = (conn->txsz)-r; int sz = (conn->txsz)-r;
if(sz) if(sz)
memmove(&conn->txbuf, (conn->txbuf+r), sz); memmove(&conn->txbuf, (conn->txbuf+r), sz);
conn->txsz -= r; conn->txsz -= r;
int max = conn->type == SOCK_STREAM ? DEFAULT_TCP_TX_BUF_SZ : DEFAULT_UDP_TX_BUF_SZ;
DEBUG_TRANS("[TCP TX] ---> :: {TX: %.3f%%, RX: %.3f%%, sock=%p} :: %d bytes", if(conn->type == SOCK_STREAM) {
(float)conn->txsz / (float)max, (float)conn->rxsz / max, (void*)&conn->sock, r); max = DEFAULT_TCP_TX_BUF_SZ;
DEBUG_TRANS("[TCP TX] ---> :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
(float)conn->txsz / (float)max, (float)conn->rxsz / max, conn->sock, r);
}
if(conn->type == SOCK_DGRAM) {
max = DEFAULT_UDP_TX_BUF_SZ;
DEBUG_TRANS("[UDP TX] ---> :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %d bytes",
(float)conn->txsz / (float)max, (float)conn->rxsz / max, conn->sock, r);
}
} }
// Instructs the stack to connect to a remote host // Instructs the stack to connect to a remote host
@@ -505,7 +602,7 @@ namespace ZeroTier {
char ipv4_str[INET_ADDRSTRLEN]; char ipv4_str[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(in4->sin_addr), ipv4_str, INET_ADDRSTRLEN); inet_ntop(AF_INET, &(in4->sin_addr), ipv4_str, INET_ADDRSTRLEN);
picotap->picostack->__pico_string_to_ipv4(ipv4_str, &(zaddr.addr)); picotap->picostack->__pico_string_to_ipv4(ipv4_str, &(zaddr.addr));
DEBUG_ATTN("addr=%s:%d", ipv4_str, Utils::ntoh(addr->sin_port)); DEBUG_ATTN("addr=%s:%d, physock=%p, picosock=%p", ipv4_str, Utils::ntoh(addr->sin_port), sock, (conn->picosock));
ret = picotap->picostack->__pico_socket_bind(conn->picosock, &zaddr, (uint16_t*)&(addr->sin_port)); ret = picotap->picostack->__pico_socket_bind(conn->picosock, &zaddr, (uint16_t*)&(addr->sin_port));
#elif defined(SDK_IPV6) #elif defined(SDK_IPV6)
struct pico_ip6 zaddr; struct pico_ip6 zaddr;
@@ -513,7 +610,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);
picotap->picostack->__pico_string_to_ipv6(ipv6_str, zaddr.addr); picotap->picostack->__pico_string_to_ipv6(ipv6_str, zaddr.addr);
DEBUG_ATTN("addr=%s:%d", ipv6_str, Utils::ntoh(addr->sin_port)); DEBUG_ATTN("addr=%s:%d, physock=%p, picosock=%p", ipv6_str, Utils::ntoh(addr->sin_port), sock, (conn->picosock));
ret = picotap->picostack->__pico_socket_bind(conn->picosock, &zaddr, (uint16_t*)&(addr->sin_port)); ret = picotap->picostack->__pico_socket_bind(conn->picosock, &zaddr, (uint16_t*)&(addr->sin_port));
#endif #endif
if(ret < 0) { if(ret < 0) {
@@ -567,13 +664,23 @@ namespace ZeroTier {
// ----------------------------------------- // -----------------------------------------
void pico_handleRead(PhySocket *sock,void **uptr,bool lwip_invoked) void pico_handleRead(PhySocket *sock,void **uptr,bool lwip_invoked)
{ {
// DEBUG_INFO(); /*
if(!lwip_invoked) {
picotap->_tcpconns_m.lock();
//picotap->_rx_buf_m.lock();
}
*/
DEBUG_ATTN();
Connection *conn = picotap->getConnection(sock); Connection *conn = picotap->getConnection(sock);
if(conn && conn->rxsz) { if(conn && conn->rxsz) {
float max = conn->type == SOCK_STREAM ? (float)DEFAULT_TCP_RX_BUF_SZ : (float)DEFAULT_UDP_RX_BUF_SZ; float max = conn->type == SOCK_STREAM ? (float)DEFAULT_TCP_RX_BUF_SZ : (float)DEFAULT_UDP_RX_BUF_SZ;
long n = picotap->_phy.streamSend(conn->sock, conn->rxbuf, /* ZT_MAX_MTU */ conn->rxsz); long n = -1;
// extract address and payload size info // extract address and payload size info
if(conn->type==SOCK_DGRAM) { if(conn->type==SOCK_DGRAM) {
n = picotap->_phy.streamSend(conn->sock, conn->rxbuf, ZT_MAX_MTU);
DEBUG_EXTRA("SOCK_DGRAM, physock=%p", sock);
int payload_sz, addr_sz_offset = sizeof(struct sockaddr_storage); int payload_sz, addr_sz_offset = sizeof(struct sockaddr_storage);
memcpy(&payload_sz, conn->rxbuf + addr_sz_offset, sizeof(int)); memcpy(&payload_sz, conn->rxbuf + addr_sz_offset, sizeof(int));
struct sockaddr_storage addr; struct sockaddr_storage addr;
@@ -583,29 +690,26 @@ namespace ZeroTier {
memcpy(conn->rxbuf, conn->rxbuf+ZT_MAX_MTU, conn->rxsz - ZT_MAX_MTU); memcpy(conn->rxbuf, conn->rxbuf+ZT_MAX_MTU, conn->rxsz - ZT_MAX_MTU);
conn->rxsz -= ZT_MAX_MTU; conn->rxsz -= ZT_MAX_MTU;
} }
if(conn->type==SOCK_STREAM) { if(conn->type==SOCK_STREAM) {
//int payload_sz, addr_sz_offset = sizeof(struct sockaddr_storage); n = picotap->_phy.streamSend(conn->sock, conn->rxbuf, conn->rxsz);
//memcpy(&payload_sz, conn->rxbuf + addr_sz_offset, sizeof(int)); DEBUG_EXTRA("SOCK_STREAM, physock=%p", sock);
//struct sockaddr_storage addr;
//memcpy(&addr, conn->rxbuf, addr_sz_offset);
// adjust buffer
if(conn->rxsz-n > 0) // If more remains on buffer if(conn->rxsz-n > 0) // If more remains on buffer
memcpy(conn->rxbuf, conn->rxbuf+n, conn->rxsz - n); memcpy(conn->rxbuf, conn->rxbuf+n, conn->rxsz - n);
conn->rxsz -= n; conn->rxsz -= n;
DEBUG_INFO("rxsz=%d", conn->rxsz);
} }
if(n) { if(n) {
//DEBUG_INFO("wrote %d bytes to client application", n); if(conn->type==SOCK_STREAM) {
if(conn->type==SOCK_STREAM) { // Only acknolwedge receipt of TCP packets DEBUG_TRANS("[TCP RX] <--- :: {TX: %.3f%%, RX: %.3f%%, physock=%p} :: %ld bytes",
DEBUG_TRANS("[TCP RX] <--- :: {TX: %.3f%%, RX: %.3f%%, sock=%p} :: %ld bytes",
(float)conn->txsz / max, (float)conn->rxsz / max, (void*)conn->sock, n); (float)conn->txsz / max, (float)conn->rxsz / max, (void*)conn->sock, n);
} }
picotap->_phy.setNotifyWritable(conn->sock, true); picotap->_phy.setNotifyWritable(conn->sock, true);
} }
if(!n || !(conn->rxsz)) { if(conn->rxsz == 0) {
picotap->_phy.setNotifyWritable(conn->sock, false); picotap->_phy.setNotifyWritable(conn->sock, false);
} }
} }
check_buffer_states(conn);
} }
// Closes a pico_socket // Closes a pico_socket

1
src/stack_drivers/picotcp/picotcp.hpp
View File

@@ -92,6 +92,7 @@ namespace ZeroTier {
void pico_init_interface(NetconEthernetTap *tap, const InetAddress &ip); void pico_init_interface(NetconEthernetTap *tap, const InetAddress &ip);
void pico_loop(NetconEthernetTap *tap); void pico_loop(NetconEthernetTap *tap);
void pico_cb_tcp_read(NetconEthernetTap *tap, struct pico_socket *s); void pico_cb_tcp_read(NetconEthernetTap *tap, struct pico_socket *s);
void pico_cb_udp_read(NetconEthernetTap *tap, struct pico_socket *s);
void pico_cb_tcp_write(NetconEthernetTap *tap, struct pico_socket *s); void pico_cb_tcp_write(NetconEthernetTap *tap, struct pico_socket *s);
void pico_cb_socket_activity(uint16_t ev, struct pico_socket *s); void pico_cb_socket_activity(uint16_t ev, struct pico_socket *s);

40
src/tap.cpp
View File

@@ -296,7 +296,7 @@ Connection *NetconEthernetTap::getConnection(struct pico_socket *sock)
void NetconEthernetTap::closeConnection(PhySocket *sock) void NetconEthernetTap::closeConnection(PhySocket *sock)
{ {
DEBUG_EXTRA("sock=%p", (void*)sock); DEBUG_EXTRA("physock=%p", (void*)sock);
Mutex::Lock _l(_close_m); Mutex::Lock _l(_close_m);
// Here we assume _tcpconns_m is already locked by caller // Here we assume _tcpconns_m is already locked by caller
if(!sock) { if(!sock) {
@@ -328,7 +328,7 @@ void NetconEthernetTap::closeConnection(PhySocket *sock)
} }
void NetconEthernetTap::phyOnUnixClose(PhySocket *sock,void **uptr) { void NetconEthernetTap::phyOnUnixClose(PhySocket *sock,void **uptr) {
DEBUG_EXTRA("sock=%p", (void*)&sock); DEBUG_EXTRA("physock=%p", (void*)&sock);
Mutex::Lock _l(_tcpconns_m); Mutex::Lock _l(_tcpconns_m);
//closeConnection(sock); //closeConnection(sock);
} }
@@ -343,12 +343,10 @@ void NetconEthernetTap::phyOnUnixClose(PhySocket *sock,void **uptr) {
// ----------------------------------------- // -----------------------------------------
void NetconEthernetTap::handleRead(PhySocket *sock,void **uptr,bool lwip_invoked) void NetconEthernetTap::handleRead(PhySocket *sock,void **uptr,bool lwip_invoked)
{ {
// DEBUG_EXTRA("handleRead(sock=%p): lwip_invoked = %d\n", (void*)&sock, lwip_invoked); // DEBUG_EXTRA("handleRead(physock=%p): lwip_invoked = %d\n", (void*)&sock, lwip_invoked);
// picoTCP
#if defined(SDK_PICOTCP) #if defined(SDK_PICOTCP)
pico_handleRead(sock, uptr, lwip_invoked); pico_handleRead(sock, uptr, lwip_invoked);
#endif #endif
// lwIP
#if defined(SDK_LWIP) #if defined(SDK_LWIP)
lwip_handleRead(this, sock, uptr, lwip_invoked); lwip_handleRead(this, sock, uptr, lwip_invoked);
#endif #endif
@@ -361,7 +359,7 @@ void NetconEthernetTap::phyOnUnixWritable(PhySocket *sock,void **uptr,bool lwip_
void NetconEthernetTap::phyOnUnixData(PhySocket *sock, void **uptr, void *data, ssize_t len) void NetconEthernetTap::phyOnUnixData(PhySocket *sock, void **uptr, void *data, ssize_t len)
{ {
DEBUG_EXTRA("sock=%p, len=%d", (void*)&sock, (int)len); DEBUG_EXTRA("physock=%p, len=%d", (void*)&sock, (int)len);
uint64_t CANARY_num; uint64_t CANARY_num;
pid_t pid, tid; pid_t pid, tid;
ssize_t wlen = len; ssize_t wlen = len;
@@ -383,10 +381,10 @@ void NetconEthernetTap::phyOnUnixData(PhySocket *sock, void **uptr, void *data,
if(detected_rpc) { if(detected_rpc) {
unloadRPC(data, pid, tid, timestamp, CANARY, cmd, payload); unloadRPC(data, pid, tid, timestamp, CANARY, cmd, payload);
memcpy(&CANARY_num, CANARY, CANARY_SZ); memcpy(&CANARY_num, CANARY, CANARY_SZ);
// DEBUG_EXTRA(" RPC: sock=%p, (pid=%d, tid=%d, timestamp=%s, cmd=%d)", (void*)&sock, pid, tid, timestamp, cmd); // DEBUG_EXTRA(" RPC: physock=%p, (pid=%d, tid=%d, timestamp=%s, cmd=%d)", (void*)&sock, pid, tid, timestamp, cmd);
if(cmd == RPC_SOCKET) { if(cmd == RPC_SOCKET) {
DEBUG_INFO("RPC_SOCKET, sock=%p", (void*)&sock); DEBUG_INFO("RPC_SOCKET, physock=%p", (void*)&sock);
// Create new lwip socket and associate it with this sock // Create new lwip socket and associate it with this sock
struct socket_st socket_rpc; struct socket_st socket_rpc;
memcpy(&socket_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct socket_st)); memcpy(&socket_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct socket_st));
@@ -475,34 +473,34 @@ void NetconEthernetTap::phyOnUnixData(PhySocket *sock, void **uptr, void *data,
rpcSock = sockdata.first; rpcSock = sockdata.first;
buf = (unsigned char*)sockdata.second; buf = (unsigned char*)sockdata.second;
unloadRPC(buf, pid, tid, timestamp, CANARY, cmd, payload); unloadRPC(buf, pid, tid, timestamp, CANARY, cmd, payload);
// DEBUG_EXTRA(" RPC: sock=%p, (pid=%d, tid=%d, timestamp=%s, cmd=%d)", (void*)&sock, pid, tid, timestamp, cmd); // DEBUG_EXTRA(" RPC: physock=%p, (pid=%d, tid=%d, timestamp=%s, cmd=%d)", (void*)&sock, pid, tid, timestamp, cmd);
switch(cmd) { switch(cmd) {
case RPC_BIND: case RPC_BIND:
DEBUG_INFO("RPC_BIND, sock=%p", (void*)&sock); DEBUG_INFO("RPC_BIND, physock=%p", (void*)&sock);
struct bind_st bind_rpc; struct bind_st bind_rpc;
memcpy(&bind_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct bind_st)); memcpy(&bind_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct bind_st));
handleBind(sock, rpcSock, uptr, &bind_rpc); handleBind(sock, rpcSock, uptr, &bind_rpc);
break; break;
case RPC_LISTEN: case RPC_LISTEN:
DEBUG_INFO("RPC_LISTEN, sock=%p", (void*)&sock); DEBUG_INFO("RPC_LISTEN, physock=%p", (void*)&sock);
struct listen_st listen_rpc; struct listen_st listen_rpc;
memcpy(&listen_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct listen_st)); memcpy(&listen_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct listen_st));
handleListen(sock, rpcSock, uptr, &listen_rpc); handleListen(sock, rpcSock, uptr, &listen_rpc);
break; break;
case RPC_GETSOCKNAME: case RPC_GETSOCKNAME:
DEBUG_INFO("RPC_GETSOCKNAME, sock=%p", (void*)&sock); DEBUG_INFO("RPC_GETSOCKNAME, physock=%p", (void*)&sock);
struct getsockname_st getsockname_rpc; struct getsockname_st getsockname_rpc;
memcpy(&getsockname_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct getsockname_st)); memcpy(&getsockname_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct getsockname_st));
handleGetsockname(sock, rpcSock, uptr, &getsockname_rpc); handleGetsockname(sock, rpcSock, uptr, &getsockname_rpc);
break; break;
case RPC_GETPEERNAME: case RPC_GETPEERNAME:
DEBUG_INFO("RPC_GETPEERNAME, sock=%p", (void*)&sock); DEBUG_INFO("RPC_GETPEERNAME, physock=%p", (void*)&sock);
struct getsockname_st getpeername_rpc; struct getsockname_st getpeername_rpc;
memcpy(&getpeername_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct getsockname_st)); memcpy(&getpeername_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct getsockname_st));
handleGetpeername(sock, rpcSock, uptr, &getpeername_rpc); handleGetpeername(sock, rpcSock, uptr, &getpeername_rpc);
break; break;
case RPC_CONNECT: case RPC_CONNECT:
DEBUG_INFO("RPC_CONNECT, sock=%p", (void*)&sock); DEBUG_INFO("RPC_CONNECT, physock=%p", (void*)&sock);
struct connect_st connect_rpc; struct connect_st connect_rpc;
memcpy(&connect_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct connect_st)); memcpy(&connect_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct connect_st));
handleConnect(sock, rpcSock, conn, &connect_rpc); handleConnect(sock, rpcSock, conn, &connect_rpc);
@@ -552,12 +550,10 @@ void NetconEthernetTap::handleGetpeername(PhySocket *sock, PhySocket *rpcSock, v
Connection * NetconEthernetTap::handleSocket(PhySocket *sock, void **uptr, struct socket_st* socket_rpc) Connection * NetconEthernetTap::handleSocket(PhySocket *sock, void **uptr, struct socket_st* socket_rpc)
{ {
DEBUG_ATTN("sock=%p, sock_type=%d", (void*)&sock, socket_rpc->socket_type); DEBUG_ATTN("physock=%p, sock_type=%d", sock, socket_rpc->socket_type);
// picoTCP
#if defined(SDK_PICOTCP) #if defined(SDK_PICOTCP)
return pico_handleSocket(sock, uptr, socket_rpc); return pico_handleSocket(sock, uptr, socket_rpc);
#endif #endif
// lwIP
#if defined(SDK_LWIP) #if defined(SDK_LWIP)
return lwip_handleSocket(this, sock, uptr, socket_rpc); return lwip_handleSocket(this, sock, uptr, socket_rpc);
#endif #endif
@@ -576,13 +572,11 @@ int NetconEthernetTap::handleConnectProxy(PhySocket *sock, struct sockaddr_in *r
// Connect a stack's PCB/socket/Connection object to a remote host // Connect a stack's PCB/socket/Connection object to a remote host
void NetconEthernetTap::handleConnect(PhySocket *sock, PhySocket *rpcSock, Connection *conn, struct connect_st* connect_rpc) void NetconEthernetTap::handleConnect(PhySocket *sock, PhySocket *rpcSock, Connection *conn, struct connect_st* connect_rpc)
{ {
DEBUG_ATTN("sock=%p", (void*)&sock); DEBUG_ATTN("physock=%p", (void*)&sock);
Mutex::Lock _l(_tcpconns_m); Mutex::Lock _l(_tcpconns_m);
// picoTCP
#if defined(SDK_PICOTCP) #if defined(SDK_PICOTCP)
pico_handleConnect(sock, rpcSock, conn, connect_rpc); pico_handleConnect(sock, rpcSock, conn, connect_rpc);
#endif #endif
// lwIP
#if defined(SDK_LWIP) #if defined(SDK_LWIP)
lwip_handleConnect(this, sock, rpcSock, conn, connect_rpc); lwip_handleConnect(this, sock, rpcSock, conn, connect_rpc);
#endif #endif
@@ -597,11 +591,9 @@ void NetconEthernetTap::handleBind(PhySocket *sock, PhySocket *rpcSock, void **u
sendReturnValue(_phy.getDescriptor(rpcSock), -1, ENOMEM); sendReturnValue(_phy.getDescriptor(rpcSock), -1, ENOMEM);
return; return;
} }
// picoTCP
#if defined(SDK_PICOTCP) #if defined(SDK_PICOTCP)
pico_handleBind(sock,rpcSock,uptr,bind_rpc); pico_handleBind(sock,rpcSock,uptr,bind_rpc);
#endif #endif
// lwIP
#if defined(SDK_LWIP) #if defined(SDK_LWIP)
lwip_handleBind(this, sock, rpcSock, uptr, bind_rpc); lwip_handleBind(this, sock, rpcSock, uptr, bind_rpc);
#endif #endif
@@ -610,11 +602,9 @@ void NetconEthernetTap::handleBind(PhySocket *sock, PhySocket *rpcSock, void **u
void NetconEthernetTap::handleListen(PhySocket *sock, PhySocket *rpcSock, void **uptr, struct listen_st *listen_rpc) void NetconEthernetTap::handleListen(PhySocket *sock, PhySocket *rpcSock, void **uptr, struct listen_st *listen_rpc)
{ {
Mutex::Lock _l(_tcpconns_m); Mutex::Lock _l(_tcpconns_m);
// picoTCP
#if defined(SDK_PICOTCP) #if defined(SDK_PICOTCP)
pico_handleListen(sock, rpcSock, uptr, listen_rpc); pico_handleListen(sock, rpcSock, uptr, listen_rpc);
#endif #endif
// lwIP
#if defined(SDK_LWIP) #if defined(SDK_LWIP)
lwip_handleListen(this, sock, rpcSock, uptr, listen_rpc); lwip_handleListen(this, sock, rpcSock, uptr, listen_rpc);
#endif #endif
@@ -623,11 +613,9 @@ void NetconEthernetTap::handleListen(PhySocket *sock, PhySocket *rpcSock, void *
// Write to the network stack (and thus out onto the network) // Write to the network stack (and thus out onto the network)
void NetconEthernetTap::handleWrite(Connection *conn) void NetconEthernetTap::handleWrite(Connection *conn)
{ {
// picoTCP
#if defined(SDK_PICOTCP) #if defined(SDK_PICOTCP)
pico_handleWrite(conn); pico_handleWrite(conn);
#endif #endif
// lwIP
#if defined(SDK_LWIP) #if defined(SDK_LWIP)
lwip_handleWrite(this, conn); lwip_handleWrite(this, conn);
#endif #endif

1
tests/api_test/tcpclient4.c
View File

@@ -41,7 +41,6 @@ int main(int argc , char *argv[])
while(1) while(1)
{ {
sleep(1);
// TX // TX
if(send(sock, msg, strlen(msg), 0) < 0) { if(send(sock, msg, strlen(msg), 0) < 0) {
printf("send failed"); printf("send failed");

22
tests/api_test/udpclient4.c
View File

@@ -23,7 +23,7 @@ void error(char *msg) {
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
int sockfd, portno, n; int sock, portno, n;
int serverlen; int serverlen;
struct sockaddr_in serveraddr; struct sockaddr_in serveraddr;
struct hostent *server; struct hostent *server;
@@ -39,8 +39,8 @@ int main(int argc, char **argv) {
portno = atoi(argv[2]); portno = atoi(argv[2]);
/* socket: create the socket */ /* socket: create the socket */
sockfd = socket(AF_INET, SOCK_DGRAM, 0); sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) if (sock < 0)
error("ERROR opening socket"); error("ERROR opening socket");
/* gethostbyname: get the server's DNS entry */ /* gethostbyname: get the server's DNS entry */
@@ -59,31 +59,27 @@ int main(int argc, char **argv) {
/* get a message from the user */ /* get a message from the user */
char *msg = "A message to the server!\0"; char *msg = "A message to the server!\0";
fcntl(sockfd, F_SETFL, O_NONBLOCK); fcntl(sock, F_SETFL, O_NONBLOCK);
long count = 0; long count = 0;
while(1) while(1)
{ {
count++; count++;
printf("\nTX(%lu)...\n", count); printf("\n\n\nTX(%lu)...\n", count);
usleep(10000); sleep(1);
//usleep(10000);
//bzero(buf, BUFSIZE); //bzero(buf, BUFSIZE);
//printf("\nPlease enter msg: "); //printf("\nPlease enter msg: ");
//fgets(buf, BUFSIZE, stdin); //fgets(buf, BUFSIZE, stdin);
/* send the message to the server */ /* send the message to the server */
serverlen = sizeof(serveraddr); serverlen = sizeof(serveraddr);
printf("A\n"); n = sendto(sock, msg, strlen(msg), 0, (struct sockaddr *)&serveraddr, serverlen);
n = sendto(sockfd, msg, strlen(msg), 0, (struct sockaddr *)&serveraddr, serverlen);
printf("B\n");
//if (n < 0) //if (n < 0)
// error("ERROR in sendto"); // error("ERROR in sendto");
/* print the server's reply */ /* print the server's reply */
printf("C\n");
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
printf("D\n"); n = recvfrom(sock, buf, BUFSIZE, 0, (struct sockaddr *)&serveraddr, (socklen_t *)&serverlen);
n = recvfrom(sockfd, buf, BUFSIZE, 0, (struct sockaddr *)&serveraddr, (socklen_t *)&serverlen);
printf("E\n");
//if (n < 0) //if (n < 0)
// printf("ERROR in recvfrom: %d", n); // printf("ERROR in recvfrom: %d", n);
printf("Echo from server: %s", buf); printf("Echo from server: %s", buf);

53
tests/api_test/udpclient6.c
View File

@@ -12,63 +12,32 @@
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
int sock;
int status; int status;
struct addrinfo sainfo, *psinfo; struct addrinfo sainfo, *psinfo;
struct sockaddr_in6 sin6; struct hostent *server;
socklen_t sin6len;
char buffer[MAXBUF]; char buffer[MAXBUF];
sin6len = sizeof(struct sockaddr_in6); int sock, portno, n;
struct sockaddr_in6 serv_addr;
if(argc < 2) if(argc < 2)
printf("Specify a port number\n"), exit(1); printf("Specify a port number\n"), exit(1);
sock = socket(PF_INET6, SOCK_DGRAM,0); sock = socket(PF_INET6, SOCK_DGRAM,0);
memset(&sin6, 0, sizeof(struct sockaddr_in6)); portno = atoi(argv[2]);
sin6.sin6_port = htons(0); server = gethostbyname2(argv[1],AF_INET6);
sin6.sin6_family = AF_INET6; memset((char *) &serv_addr, 0, sizeof(serv_addr));
sin6.sin6_addr = in6addr_any; 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(portno);
status = bind(sock, (struct sockaddr *)&sin6, sin6len);
if(-1 == status)
perror("bind"), exit(1);
memset(&sainfo, 0, sizeof(struct addrinfo));
memset(&sin6, 0, sin6len);
sainfo.ai_flags = 0;
sainfo.ai_family = PF_INET6;
sainfo.ai_socktype = SOCK_DGRAM;
sainfo.ai_protocol = IPPROTO_UDP;
status = getaddrinfo("ip6-localhost", argv[1], &sainfo, &psinfo);
switch (status)
{
case EAI_FAMILY: printf("family\n");
break;
case EAI_SOCKTYPE: printf("stype\n");
break;
case EAI_BADFLAGS: printf("flag\n");
break;
case EAI_NONAME: printf("noname\n");
break;
case EAI_SERVICE: printf("service\n");
break;
}
sprintf(buffer,"Ciao"); sprintf(buffer,"Ciao");
status = sendto(sock, buffer, strlen(buffer), 0, status = sendto(sock, buffer, strlen(buffer), 0, (const struct sockaddr *)&serv_addr, sizeof(serv_addr));
(struct sockaddr *)psinfo->ai_addr, sin6len);
printf("buffer : %s \t%d\n", buffer, status); printf("buffer : %s \t%d\n", buffer, status);
// free memory
freeaddrinfo(psinfo);
psinfo = NULL;
shutdown(sock, 2);
close(sock); close(sock);
return 0; return 0;
} }

29
tests/api_test/udpserver4.c
View File

@@ -11,7 +11,7 @@
#define MAXBUF 1024*1024 #define MAXBUF 1024*1024
void echo( int sd ) { void echo(int sock) {
char bufin[MAXBUF]; char bufin[MAXBUF];
struct sockaddr_in remote; struct sockaddr_in remote;
int n; int n;
@@ -19,10 +19,11 @@ void echo( int sd ) {
long count = 0; long count = 0;
while (1) { while (1) {
usleep(50); sleep(1);
//usleep(50);
count++; count++;
// read a datagram from the socket (put result in bufin) // read a datagram from the socket (put result in bufin)
n=recvfrom(sd,bufin,MAXBUF,0,(struct sockaddr *)&remote,&len); n=recvfrom(sock,bufin,MAXBUF,0,(struct sockaddr *)&remote,&len);
// print out the address of the sender // print out the address of the sender
printf("DGRAM from %s:%d\n", inet_ntoa(remote.sin_addr), ntohs(remote.sin_port)); printf("DGRAM from %s:%d\n", inet_ntoa(remote.sin_addr), ntohs(remote.sin_port));
@@ -31,7 +32,8 @@ void echo( int sd ) {
} else { } else {
printf("GOT %d BYTES (count = %ld)\n", n, count); printf("GOT %d BYTES (count = %ld)\n", n, count);
// Got something, just send it back // Got something, just send it back
// sendto(sd,bufin,n,0,(struct sockaddr *)&remote,len); // sendto(sock,bufin,n,0,(struct sockaddr *)&remote,len);
printf("RX = %s\n", bufin);
} }
} }
} }
@@ -42,13 +44,13 @@ int main(int argc, char *argv[]) {
printf("usage: udp_server <port>\n"); printf("usage: udp_server <port>\n");
return 0; return 0;
} }
int ld, port = atoi(argv[1]); int sock, port = atoi(argv[1]);
socklen_t len; socklen_t len;
struct sockaddr_in skaddr; struct sockaddr_in skaddr;
struct sockaddr_in skaddr2; struct sockaddr_in skaddr2;
// Create socket // Create socket
if ((ld = socket( PF_INET, SOCK_DGRAM, 0)) < 0) { if ((sock = socket( PF_INET, SOCK_DGRAM, 0)) < 0) {
printf("error creating socket\n"); printf("error creating socket\n");
return 0; return 0;
} }
@@ -57,17 +59,18 @@ int main(int argc, char *argv[]) {
skaddr.sin_addr.s_addr = htonl(INADDR_ANY); skaddr.sin_addr.s_addr = htonl(INADDR_ANY);
skaddr.sin_port = htons(port); skaddr.sin_port = htons(port);
// Bind to address // Bind to address
if (bind(ld, (struct sockaddr *) &skaddr, sizeof(skaddr))<0) { if (bind(sock, (struct sockaddr *) &skaddr, sizeof(skaddr))<0) {
printf("error binding\n"); printf("error binding\n");
return 0; return 0;
} }
// find out what port we were assigned // find out what port we were assigned
len = sizeof( skaddr2 ); len = sizeof( skaddr2 );
if (getsockname(ld, (struct sockaddr *) &skaddr2, &len)<0) { //if (getsockname(sock, (struct sockaddr *) &skaddr2, &len)<0) {
printf("error getsockname\n"); // printf("error getsockname\n");
return 0; // return 0;
} //}
// Display address:port to verify it was sent over RPC correctly // Display address:port to verify it was sent over RPC correctly
/*
port = ntohs(skaddr2.sin_port); port = ntohs(skaddr2.sin_port);
int ip = skaddr2.sin_addr.s_addr; int ip = skaddr2.sin_addr.s_addr;
unsigned char d[4]; unsigned char d[4];
@@ -76,8 +79,8 @@ int main(int argc, char *argv[]) {
d[2] = (ip >> 16) & 0xFF; d[2] = (ip >> 16) & 0xFF;
d[3] = (ip >> 24) & 0xFF; d[3] = (ip >> 24) & 0xFF;
printf("bound to address: %d.%d.%d.%d : %d\n", d[0],d[1],d[2],d[3], port); printf("bound to address: %d.%d.%d.%d : %d\n", d[0],d[1],d[2],d[3], port);
*/
// RX // RX
echo(ld); echo(sock);
return(0); return(0);
} }

27
tests/api_test/udpserver6.c
View File

@@ -9,37 +9,34 @@
#define MAXBUF 65536 #define MAXBUF 65536
int main() int main(int argc, char *argv[])
{ {
int sock; int sock;
int status; int n;
struct sockaddr_in6 sin6; struct sockaddr_in6 sin6;
socklen_t sin6len; socklen_t sin6len;
char buffer[MAXBUF]; char buffer[MAXBUF];
sock = socket(PF_INET6, SOCK_DGRAM,0); sock = socket(PF_INET6, SOCK_DGRAM,0);
sin6len = sizeof(struct sockaddr_in6); sin6len = sizeof(struct sockaddr_in6);
memset(&sin6, 0, sin6len); memset(&sin6, 0, sin6len);
/* just use the first address returned in the structure */ sin6.sin6_port = htons(atoi(argv[1]));
sin6.sin6_port = htons(0);
sin6.sin6_family = AF_INET6; sin6.sin6_family = AF_INET6;
sin6.sin6_addr = in6addr_any; sin6.sin6_addr = in6addr_any;
status = bind(sock, (struct sockaddr *)&sin6, sin6len); n = bind(sock, (struct sockaddr *)&sin6, sin6len);
if(-1 == status) if(-1 == n)
perror("bind"), exit(1); perror("bind"), exit(1);
status = getsockname(sock, (struct sockaddr *)&sin6, &sin6len); //n = getsockname(sock, (struct sockaddr *)&sin6, &sin6len);
//printf("%d\n", ntohs(sin6.sin6_port));
printf("%d\n", ntohs(sin6.sin6_port)); while (1) {
sleep(1);
status = recvfrom(sock, buffer, MAXBUF, 0, n = recvfrom(sock, buffer, MAXBUF, 0, (struct sockaddr *)&sin6, &sin6len);
(struct sockaddr *)&sin6, &sin6len); printf("n = %d, buffer : %s\n", n, buffer);
printf("buffer : %s\n", buffer); }
shutdown(sock, 2); shutdown(sock, 2);
close(sock); close(sock);

12
zerotierone/service/OneService.cpp
View File

@@ -907,8 +907,8 @@ public:
{ {
Mutex::Lock _l(_nets_m); Mutex::Lock _l(_nets_m);
for(std::map<uint64_t,NetworkState>::iterator n(_nets.begin());n!=_nets.end();++n) { for(std::map<uint64_t,NetworkState>::iterator n(_nets.begin());n!=_nets.end();++n) {
if (n->second.tap) //if (n->second.tap)
syncManagedStuff(n->second,false,true); // syncManagedStuff(n->second,false,true);
} }
} }
} }
@@ -1093,8 +1093,8 @@ public:
fclose(out); fclose(out);
} }
if (n->second.tap) //if (n->second.tap)
syncManagedStuff(n->second,true,true); // syncManagedStuff(n->second,true,true);
return true; return true;
} }
@@ -1216,7 +1216,7 @@ public:
for(std::list<ManagedRoute>::iterator mr(n.managedRoutes.begin());mr!=n.managedRoutes.end();++mr) { for(std::list<ManagedRoute>::iterator mr(n.managedRoutes.begin());mr!=n.managedRoutes.end();++mr) {
if ( (mr->target() == *target) && ( ((via->ss_family == target->ss_family)&&(mr->via() == *via)) || (tapdev == mr->device()) ) ) { if ( (mr->target() == *target) && ( ((via->ss_family == target->ss_family)&&(mr->via() == *via)) || (tapdev == mr->device()) ) ) {
haveRoute = true; haveRoute = true;
mr->sync(); //mr->sync();
break; break;
} }
} }
@@ -1515,7 +1515,7 @@ public:
case ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE: case ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE:
memcpy(&(n.config),nwc,sizeof(ZT_VirtualNetworkConfig)); memcpy(&(n.config),nwc,sizeof(ZT_VirtualNetworkConfig));
if (n.tap) { // sanity check if (n.tap) { // sanity check
syncManagedStuff(n,true,true); //syncManagedStuff(n,true,true);
} else { } else {
_nets.erase(nwid); _nets.erase(nwid);
return -999; // tap init failed return -999; // tap init failed