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

split stack driver sections

Browse Source
This commit is contained in:
Joseph Henry
2016-11-01 15:38:09 -07:00
parent af705f40fe
commit 564531042d
19 changed files with 2142 additions and 1937 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
build/README.md
View File

@@ -1,3 +0,0 @@
Build Directory
====
Where all of your target binaries will be copies along with their required network stack libraries

25
make-linux.mk
View File

@@ -26,6 +26,19 @@ LWIP_LIB = $(BUILD)/$(LWIP_LIB_NAME)
# #
LWIP_DIR = ext/lwip LWIP_DIR = ext/lwip
PICOTCP_DIR = ext/picotcp PICOTCP_DIR = ext/picotcp
#
LWIP_DRIVER_FILES = src/stack_drivers/lwip/lwip.cpp
PICO_DRIVER_FILES = src/stack_drivers/picotcp/picotcp.cpp
SDK_SERVICE_CPP_FILES:=src/tap.cpp \
src/proxy.cpp \
$(ZT1)/service/OneService.cpp \
$(ZT1)/one.cpp
SDK_SERVICE_C_FILES = src/rpc.c
SDK_INTERCEPT_C_FILES:=sockets.c \
intercept.c \
rpc.c
# Automagically pick clang or gcc, with preference for clang # Automagically pick clang or gcc, with preference for clang
# This is only done if we have not overridden these with an environment or CLI variable # This is only done if we have not overridden these with an environment or CLI variable
@@ -86,7 +99,10 @@ INCLUDES+= -Iext \
-I$(LWIP_DIR)/src/include/ipv6 \ -I$(LWIP_DIR)/src/include/ipv6 \
-I$(PICOTCP_DIR)/include \ -I$(PICOTCP_DIR)/include \
-I$(PICOTCP_DIR)/build/include \ -I$(PICOTCP_DIR)/build/include \
-Isrc/stack_drivers/lwip -Isrc/stack_drivers/lwip \
-Isrc/stack_drivers/picotcp \
-Isrc/stack_drivers/jip
# Stack selection / parameters # Stack selection / parameters
@@ -145,8 +161,6 @@ remove_only_intermediates:
-find . -type f \( -name '*.o' -o -name '*.so' \) -delete -find . -type f \( -name '*.o' -o -name '*.so' \) -delete
# --- EXTERNAL LIBRARIES --- # --- EXTERNAL LIBRARIES ---
lwip: lwip:
-make -f make-liblwip.mk $(LWIP_FLAGS) -make -f make-liblwip.mk $(LWIP_FLAGS)
@@ -175,15 +189,16 @@ one: $(OBJS) $(ZT1)/service/OneService.o $(ZT1)/one.o $(ZT1)/osdep/LinuxEthernet
# Build only the intercept library # Build only the intercept library
linux_intercept: linux_intercept:
# Use gcc not clang to build standalone intercept library since gcc is typically used for libc and we want to ensure maximal ABI compatibility # Use gcc not clang to build standalone intercept library since gcc is typically used for libc and we want to ensure maximal ABI compatibility
cd src ; gcc $(DEFS) $(INCLUDES) -g -O2 -Wall -std=c99 -fPIC -DVERBOSE -D_GNU_SOURCE -DSDK_INTERCEPT -nostdlib -nostdlib -shared -o ../$(INTERCEPT) sockets.c intercept.c rpc.c -ldl cd src ; gcc $(DEFS) $(INCLUDES) -g -O2 -Wall -std=c99 -fPIC -DVERBOSE -D_GNU_SOURCE -DSDK_INTERCEPT -nostdlib -nostdlib -shared -o ../$(INTERCEPT) $(SDK_INTERCEPT_C_FILES) -ldl
# Build only the SDK service # Build only the SDK service
ifeq ($(SDK_LWIP),1) ifeq ($(SDK_LWIP),1)
linux_sdk_service: lwip $(OBJS) linux_sdk_service: lwip $(OBJS)
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) -DSDK_SERVICE -DSDK -DZT_ONE_NO_ROOT_CHECK -o $(SDK_SERVICE) $(OBJS) $(LWIP_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl
else else
linux_sdk_service: pico $(OBJS) linux_sdk_service: pico $(OBJS)
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) -DSDK_SERVICE -DSDK -DZT_ONE_NO_ROOT_CHECK -o $(SDK_SERVICE) $(OBJS) $(PICO_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl
endif endif
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) -DSDK -DZT_ONE_NO_ROOT_CHECK -o $(SDK_SERVICE) $(OBJS) $(ZT1)/service/OneService.cpp src/tap.cpp src/proxy.cpp $(ZT1)/one.cpp src/rpc.c $(LDLIBS) -ldl
ln -sf $(SDK_SERVICE_NAME) $(BUILD)/zerotier-cli ln -sf $(SDK_SERVICE_NAME) $(BUILD)/zerotier-cli
ln -sf $(SDK_SERVICE_NAME) $(BUILD)/zerotier-idtool ln -sf $(SDK_SERVICE_NAME) $(BUILD)/zerotier-idtool

81
make-mac.mk
View File

@@ -24,7 +24,21 @@ ONE_CLI = $(BUILD)/$(ONE_CLI_NAME)
ONE_IDTOOL = $(BUILD)/$(ONE_IDTOOL_NAME) ONE_IDTOOL = $(BUILD)/$(ONE_IDTOOL_NAME)
LWIP_LIB = $(BUILD)/$(LWIP_LIB_NAME) LWIP_LIB = $(BUILD)/$(LWIP_LIB_NAME)
# #
LWIP_BASE_DIR = ext/lwip LWIP_DIR = ext/lwip
PICOTCP_DIR = ext/picotcp
#
LWIP_DRIVER_FILES = src/stack_drivers/lwip/lwip.cpp
PICO_DRIVER_FILES = src/stack_drivers/picotcp/picotcp.cpp
SDK_SERVICE_CPP_FILES:=src/tap.cpp \
src/proxy.cpp \
$(ZT1)/service/OneService.cpp \
$(ZT1)/one.cpp
SDK_SERVICE_C_FILES = src/rpc.c
SDK_INTERCEPT_C_FILES:=sockets.c \
intercept.c \
rpc.c
# Automagically pick clang or gcc, with preference for clang # Automagically pick clang or gcc, with preference for clang
# This is only done if we have not overridden these with an environment or CLI variable # This is only done if we have not overridden these with an environment or CLI variable
@@ -79,23 +93,51 @@ INCLUDES+= -Iext \
-I../$(ZT1)/node \ -I../$(ZT1)/node \
-I../$(ZT1)/service \ -I../$(ZT1)/service \
-I. \ -I. \
-Isrc -Isrc \
-Isrc/stack_drivers \
-I$(LWIP_DIR)/src/include \
-I$(LWIP_DIR)/src/include/ipv4 \
-I$(LWIP_DIR)/src/include/ipv6 \
-I$(PICOTCP_DIR)/include \
-I$(PICOTCP_DIR)/build/include \
-Isrc/stack_drivers/lwip \
-Isrc/stack_drivers/picotcp \
-Isrc/stack_drivers/jip
# lwIP # Stack selection / parameters
# lwIP debug
ifeq ($(SDK_LWIP_DEBUG),1) ifeq ($(SDK_LWIP_DEBUG),1)
LWIP_FLAGS+=SDK_LWIP_DEBUG=1 LWIP_FLAGS+=SDK_LWIP_DEBUG=1
endif endif
ifeq ($(LWIP_VERSION_2),1)
CXXFLAGS+=-DLWIP_VERSION_2 # lwIP
INCLUDES+=-I$(LWIP_2_DIR)/src/include ifeq ($(SDK_LWIP),1)
INCLUDES+=-I$(LWIP_2_DIR)/src/include/ipv4 STACK_FLAGS+=-DSDK_LWIP
INCLUDES+=-I$(LWIP_2_DIR)/src/include/ipv6 endif
else
CXXFLAGS+=-DLWIP_VERSION_1 # picoTCP
INCLUDES+=-I$(LWIP_1_DIR)/src/include ifeq ($(SDK_PICOTCP),1)
INCLUDES+=-I$(LWIP_1_DIR)/src/include/ipv4 STACK_FLAGS+=-DSDK_PICOTCP
INCLUDES+=-I$(LWIP_1_DIR)/src/include/ipv6 endif
# jip
ifeq ($(SDK_JIP),1)
STACK_FLAGS+=-DSDK_JIP
endif
# TCP protocol version
ifeq ($(SDK_IPV4),1)
LWIP_FLAGS+=SDK_IPV4=1
STACK_FLAGS+=-DSDK_IPV4
endif
ifeq ($(SDK_IPV6),1)
LWIP_FLAGS+=SDK_IPV6=1
STACK_FLAGS+=-DSDK_IPV6
endif endif
@@ -174,13 +216,18 @@ osx_shared_lib: $(OBJS)
osx_intercept: osx_intercept:
# Use gcc not clang to build standalone intercept library since gcc is typically used for libc and we want to ensure maximal ABI compatibility # Use gcc not clang to build standalone intercept library since gcc is typically used for libc and we want to ensure maximal ABI compatibility
cd src ; gcc $(DEFS) $(INCLUDES) -g -O2 -Wall -std=c99 -fPIC -DVERBOSE -D_GNU_SOURCE -DSDK_INTERCEPT -nostdlib -nostdlib -shared -o ../$(INTERCEPT) SDK_Sockets.c SDK_Intercept.c SDK_RPC.c -ldl cd src ; gcc $(DEFS) $(INCLUDES) -g -O2 -Wall -std=c99 -fPIC -DVERBOSE -D_GNU_SOURCE -DSDK_INTERCEPT -nostdlib -nostdlib -shared -o ../$(INTERCEPT) $(SDK_INTERCEPT_C_FILES) -ldl
# Build only the SDK service # Build only the SDK service
ifeq ($(SDK_LWIP),1)
osx_sdk_service: lwip $(OBJS) osx_sdk_service: lwip $(OBJS)
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(DEFS) $(INCLUDES) -DSDK -DZT_ONE_NO_ROOT_CHECK -o $(SDK_SERVICE) $(OBJS) $(ZT1)/service/OneService.cpp src/SDK_EthernetTap.cpp src/SDK_Proxy.cpp $(ZT1)/one.cpp -x c src/SDK_RPC.c $(LDLIBS) -ldl $(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) -DSDK_SERVICE -DSDK -DZT_ONE_NO_ROOT_CHECK -o $(SDK_SERVICE) $(OBJS) $(LWIP_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl
ln -sf $(SDK_SERVICE_NAME) zerotier-cli else
ln -sf $(SDK_SERVICE_NAME) zerotier-idtool osx_sdk_service: pico $(OBJS)
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) -DSDK_SERVICE -DSDK -DZT_ONE_NO_ROOT_CHECK -o $(SDK_SERVICE) $(OBJS) $(PICO_DRIVER_FILES) $(SDK_SERVICE_CPP_FILES) $(SDK_SERVICE_C_FILES) $(LDLIBS) -ldl
endif
ln -sf $(SDK_SERVICE_NAME) $(BUILD)/zerotier-cli
ln -sf $(SDK_SERVICE_NAME) $(BUILD)/zerotier-idtool
# Build both intercept library and SDK service (separate) # Build both intercept library and SDK service (separate)
osx_service_and_intercept: osx_intercept osx_sdk_service osx_service_and_intercept: osx_intercept osx_sdk_service

22
src/debug.h
View File

@@ -87,19 +87,19 @@ extern "C" {
//#if defined(SDK_DEBUG) //#if defined(SDK_DEBUG)
#if DEBUG_LEVEL >= MSG_ERROR #if DEBUG_LEVEL >= MSG_ERROR
#define DEBUG_ERROR(fmt, args...) fprintf(stderr, RED "ZT_ERROR: %20s:%4d:%25s: " fmt "\n" RESET, __FILENAME__, __LINE__, __FUNCTION__, ##args) #define DEBUG_ERROR(fmt, args...) fprintf(stderr, RED "ZT_ERROR: %14s:%4d:%25s: " fmt "\n" RESET, __FILENAME__, __LINE__, __FUNCTION__, ##args)
#else #else
#define DEBUG_ERROR(fmt, args...) #define DEBUG_ERROR(fmt, args...)
#endif #endif
#if DEBUG_LEVEL >= MSG_INFO #if DEBUG_LEVEL >= MSG_INFO
#if defined(__ANDROID__) #if defined(__ANDROID__)
#define DEBUG_INFO(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, "ZT_INFO : %20s:%4d:%20s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args)) #define DEBUG_INFO(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, "ZT_INFO : %14s:%4d:%20s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args))
#define DEBUG_BLANK(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, "ZT_INFO : %20s:%4d:" fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args)) #define DEBUG_BLANK(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, "ZT_INFO : %14s:%4d:" fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args))
#else #else
#define DEBUG_INFO(fmt, args...) fprintf(stderr, "ZT_INFO : %20s:%4d:%25s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args) #define DEBUG_INFO(fmt, args...) fprintf(stderr, "ZT_INFO : %14s:%4d:%25s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_ATTN(fmt, args...) fprintf(stderr, CYN "ZT_INFO : %20s:%4d:%25s: " fmt "\n" RESET, __FILENAME__, __LINE__, __FUNCTION__, ##args) #define DEBUG_ATTN(fmt, args...) fprintf(stderr, CYN "ZT_INFO : %14s:%4d:%25s: " fmt "\n" RESET, __FILENAME__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_STACK(fmt, args...) fprintf(stderr, YEL "ZT_STACK: %20s:%4d:%25s: " fmt "\n" RESET, __FILENAME__, __LINE__, __FUNCTION__, ##args) #define DEBUG_STACK(fmt, args...) fprintf(stderr, YEL "ZT_STACK: %14s:%4d:%25s: " fmt "\n" RESET, __FILENAME__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_BLANK(fmt, args...) fprintf(stderr, "ZT_INFO : %20s:%4d:" fmt "\n", __FILENAME__, __LINE__, ##args) #define DEBUG_BLANK(fmt, args...) fprintf(stderr, "ZT_INFO : %14s:%4d:" fmt "\n", __FILENAME__, __LINE__, ##args)
#endif #endif
#else #else
#define DEBUG_INFO(fmt, args...) #define DEBUG_INFO(fmt, args...)
@@ -107,18 +107,18 @@ extern "C" {
#endif #endif
#if DEBUG_LEVEL >= MSG_TRANSFER #if DEBUG_LEVEL >= MSG_TRANSFER
#if defined(__ANDROID__) #if defined(__ANDROID__)
#define DEBUG_TRANS(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, "ZT_TRANS : %20s:%4d:%25s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args)) #define DEBUG_TRANS(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, "ZT_TRANS : %14s:%4d:%25s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args))
#else #else
#define DEBUG_TRANS(fmt, args...) fprintf(stderr, GRN "ZT_TRANS: %20s:%4d:%25s: " fmt "\n" RESET, __FILENAME__, __LINE__, __FUNCTION__, ##args) #define DEBUG_TRANS(fmt, args...) fprintf(stderr, GRN "ZT_TRANS: %14s:%4d:%25s: " fmt "\n" RESET, __FILENAME__, __LINE__, __FUNCTION__, ##args)
#endif #endif
#else #else
#define DEBUG_TRANS(fmt, args...) #define DEBUG_TRANS(fmt, args...)
#endif #endif
#if DEBUG_LEVEL >= MSG_EXTRA #if DEBUG_LEVEL >= MSG_EXTRA
#if defined(__ANDROID__) #if defined(__ANDROID__)
#define DEBUG_EXTRA(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, "ZT_EXTRA : %20s:%4d:%25s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args)) #define DEBUG_EXTRA(fmt, args...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, "ZT_EXTRA : %14s:%4d:%25s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args))
#else #else
#define DEBUG_EXTRA(fmt, args...) fprintf(stderr, "ZT_EXTRA: %20s:%4d:%25s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args) #define DEBUG_EXTRA(fmt, args...) fprintf(stderr, "ZT_EXTRA: %14s:%4d:%25s: " fmt "\n", __FILENAME__, __LINE__, __FUNCTION__, ##args)
#endif #endif
#else #else
#define DEBUG_EXTRA(fmt, args...) #define DEBUG_EXTRA(fmt, args...)

4
src/rpc.c
View File

@@ -135,7 +135,7 @@ int rpc_join(char * sockname)
#else #else
if((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0){ if((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0){
#endif #endif
DEBUG_ERROR("error while creating RPC socket"); DEBUG_ERROR("error creating RPC socket");
return -1; return -1;
} }
while((conn_err != 0) /* && (attempts < SERVICE_CONNECT_ATTEMPTS) */){ while((conn_err != 0) /* && (attempts < SERVICE_CONNECT_ATTEMPTS) */){
@@ -144,7 +144,7 @@ int rpc_join(char * sockname)
#else #else
if((conn_err = connect(sock, (struct sockaddr*)&addr, sizeof(addr))) != 0) { if((conn_err = connect(sock, (struct sockaddr*)&addr, sizeof(addr))) != 0) {
#endif #endif
DEBUG_ERROR("error while connecting to RPC socket. Re-attempting..."); DEBUG_ERROR("error connecting to RPC socket. Re-attempting...");
usleep(100000); usleep(100000);
} }
else else

2
src/sdk.h
View File

@@ -158,13 +158,11 @@ ssize_t zts_recvmsg(RECVMSG_SIG);
JNIEXPORT jobject JNICALL Java_ZeroTier_ZTSDK_zt_1get_1ipv4_1address(JNIEnv *env, jobject thisObj, jstring nwid); JNIEXPORT jobject JNICALL Java_ZeroTier_ZTSDK_zt_1get_1ipv4_1address(JNIEnv *env, jobject thisObj, jstring nwid);
JNIEXPORT jobject JNICALL Java_ZeroTier_ZTSDK_zt_1get_1ipv6_1address(JNIEnv *env, jobject thisObj, jstring nwid); JNIEXPORT jobject JNICALL Java_ZeroTier_ZTSDK_zt_1get_1ipv6_1address(JNIEnv *env, jobject thisObj, jstring nwid);
JNIEXPORT jboolean JNICALL Java_ZeroTier_ZTSDK_zt_1is_1relayed(); JNIEXPORT jboolean JNICALL Java_ZeroTier_ZTSDK_zt_1is_1relayed();
// SOCKS5 PROXY SERVER CONTROLS // SOCKS5 PROXY SERVER CONTROLS
JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1start_1proxy_1server(JNIEnv *env, jobject thisObj, jstring nwid, jobject zaddr); JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1start_1proxy_1server(JNIEnv *env, jobject thisObj, jstring nwid, jobject zaddr);
JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1stop_1proxy_1server(JNIEnv *env, jobject thisObj, jstring nwid); JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1stop_1proxy_1server(JNIEnv *env, jobject thisObj, jstring nwid);
JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1get_1proxy_1server_1address(JNIEnv *env, jobject thisObj, jstring nwid, jobject zaddr); JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1get_1proxy_1server_1address(JNIEnv *env, jobject thisObj, jstring nwid, jobject zaddr);
JNIEXPORT jboolean JNICALL Java_ZeroTier_ZTSDK_zt_1proxy_1is_1running(JNIEnv *env, jobject thisObj, jstring nwid); JNIEXPORT jboolean JNICALL Java_ZeroTier_ZTSDK_zt_1proxy_1is_1running(JNIEnv *env, jobject thisObj, jstring nwid);
// SOCKET API // SOCKET API
JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1socket(JNIEnv *env, jobject thisObj, jint family, jint type, jint protocol); JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1socket(JNIEnv *env, jobject thisObj, jint family, jint type, jint protocol);
JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1connect(JNIEnv *env, jobject thisObj, jint fd, jstring addrstr, jint port); JNIEXPORT jint JNICALL Java_ZeroTier_ZTSDK_zt_1connect(JNIEnv *env, jobject thisObj, jint fd, jstring addrstr, jint port);

26
src/sdkutils.hpp
View File

@@ -25,6 +25,8 @@
* LLC. Start here: http://www.zerotier.com/ * LLC. Start here: http://www.zerotier.com/
*/ */
#ifndef _SDK_UTILS_HPP_
#define _SDK_UTILS_HPP_
#if defined(SDK_LWIP) && defined(SDK_IPV6) #if defined(SDK_LWIP) && defined(SDK_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)); \
@@ -32,9 +34,8 @@
(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
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];
uint16_t ip16; uint16_t ip16;
@@ -50,3 +51,24 @@
); );
} }
#endif #endif
#if defined(SDK_LWIP) && defined(SDK_IPV4)
#define ip4_addr1b(ipaddr) (((u8_t*)(ipaddr))[0])
#define ip4_addr2b(ipaddr) (((u8_t*)(ipaddr))[1])
#define ip4_addr3b(ipaddr) (((u8_t*)(ipaddr))[2])
#define ip4_addr4b(ipaddr) (((u8_t*)(ipaddr))[3])
inline ip_addr_t convert_ip(struct sockaddr_in * addr)
{
ip_addr_t conn_addr;
struct sockaddr_in *ipv4 = addr;
short a = ip4_addr1b(&(ipv4->sin_addr));
short b = ip4_addr2b(&(ipv4->sin_addr));
short c = ip4_addr3b(&(ipv4->sin_addr));
short d = ip4_addr4b(&(ipv4->sin_addr));
IP4_ADDR(&conn_addr, a,b,c,d);
return conn_addr;
}
#endif
#endif // _SDK_UTILS_HPP_

2
src/stack_drivers/README.md
View File

@@ -1,4 +1,4 @@
Stack Drivers Stack Drivers
==== ====
These files contain code to load and interface with network stacks. These files contain code to load, initialize, and interface network stacks to the ZeroTier ethernet tap service.

4
src/stack_drivers/jip/README.md Normal file
View File

@@ -0,0 +1,4 @@
jIP Network Stack Driver
====
This section only exists as minimal example of how a network stack would interact with the ZeroTier ethernet tap service. See the `lwIP` and `picoTCP` driver sections for full implementations of a stack driver.

52
src/stack_drivers/jip/jip.cpp Normal file
View File

@@ -0,0 +1,52 @@
/*
* 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/
*/
#if defined(SDK_JIP)
namespace ZeroTier {
void jip_init_interface(NetconEthernetTap *tap, const InetAddress &ip)
{
// initialize your stack here
}
void jip_loop(NetconEthernetTap *tap)
{
while(_run)
{
// Tick stack timers here
// Perhaps do some polling?
}
}
void jip_rx(NetconEthernetTap *tap, const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len)
{
// RX packets here
}
}
#endif // SDK_JIP

8
src/stack_drivers/jip.hpp → src/stack_drivers/jip/jip.hpp
View File

@@ -28,6 +28,8 @@
#ifndef SDK_JIPSTACK_H #ifndef SDK_JIPSTACK_H
#define SDK_JIPSTACK_H #define SDK_JIPSTACK_H
#if defined(SDK_JIP)
#include "Mutex.hpp" #include "Mutex.hpp"
#include "OSUtils.hpp" #include "OSUtils.hpp"
#include "debug.h" #include "debug.h"
@@ -41,6 +43,10 @@
namespace ZeroTier { namespace ZeroTier {
void jip_init_interface(NetconEthernetTap *tap, const InetAddress &ip);
void jip_loop(NetconEthernetTap *tap);
void jip_rx(NetconEthernetTap *tap, const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len);
/** /**
* Loads an instance of picoTCP stack library in a private memory arena * Loads an instance of picoTCP stack library in a private memory arena
* *
@@ -123,4 +129,6 @@ namespace ZeroTier {
} // namespace ZeroTier } // namespace ZeroTier
#endif // SDK_JIP
#endif #endif

2
src/stack_drivers/lwip/README.md Normal file
View File

@@ -0,0 +1,2 @@
lwIP Network Stack Driver
====

1135
src/stack_drivers/lwip/lwip.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

139
src/stack_drivers/lwip.hpp → src/stack_drivers/lwip/lwip.hpp
View File

@@ -39,7 +39,6 @@
#include "lwip/tcp.h" #include "lwip/tcp.h"
#include "lwip/priv/tcp_priv.h" #include "lwip/priv/tcp_priv.h"
#include "Mutex.hpp" #include "Mutex.hpp"
#include "OSUtils.hpp" #include "OSUtils.hpp"
#include "debug.h" #include "debug.h"
@@ -47,6 +46,143 @@
#include <stdio.h> #include <stdio.h>
#include <dlfcn.h> #include <dlfcn.h>
#include "tap.hpp"
namespace ZeroTier {
class NetconEthernetTap;
struct Connection;
void lwip_init_interface(NetconEthernetTap *tap, const InetAddress &ip);
void lwip_loop(NetconEthernetTap *tap);
void lwip_rx(NetconEthernetTap *tap, const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len);
Connection *lwip_handleSocket(NetconEthernetTap *tap, PhySocket *sock, void **uptr, struct socket_st* socket_rpc);
Connection * lwip_handleSocketProxy(NetconEthernetTap *tap, PhySocket *sock, int socket_type);
void lwip_handleConnect(NetconEthernetTap *tap, PhySocket *sock, PhySocket *rpcSock, Connection *conn, struct connect_st* connect_rpc);
int lwip_handleConnectProxy(NetconEthernetTap *tap, PhySocket *sock, struct sockaddr_in *rawAddr);
void lwip_handleBind(NetconEthernetTap *tap, PhySocket *sock, PhySocket *rpcSock, void **uptr, struct bind_st *bind_rpc);
void lwip_handleListen(NetconEthernetTap *tap, PhySocket *sock, PhySocket *rpcSock, void **uptr, struct listen_st *listen_rpc);
void lwip_handleRead(NetconEthernetTap *tap, PhySocket *sock, void **uptr, bool lwip_invoked);
void lwip_handleWrite(NetconEthernetTap *tap, Connection *conn);
void lwip_handleClose(NetconEthernetTap *tap, PhySocket *sock, Connection *conn);
err_t tapif_init(struct netif *netif);
err_t low_level_output(struct netif *netif, struct pbuf *p);
/*
* Callback from LWIP for when data is available to be read from the network.
*
* Data is in the form of a linked list of struct pbufs, it is then recombined and
* send to the client over the associated unix socket.
*
* @param associated service state object
* @param allocated PCB
* @param chain of pbufs
* @param error code
* @return ERR_OK if everything is ok, -1 otherwise
*
*/
err_t nc_recved(void *arg, struct tcp_pcb *PCB, struct pbuf *p, err_t err);
/*
* Callback from LWIP for when a connection has been accepted and the PCB has been
* put into an ACCEPT state.
*
* A socketpair is created, one end is kept and wrapped into a PhySocket object
* for use in the main ZT I/O loop, and one end is sent to the client. The client
* is then required to tell the service what new file descriptor it has allocated
* for this connection. After the mapping is complete, the accepted socket can be
* used.
*
* @param associated service state object
* @param newly allocated PCB
* @param error code
* @return ERR_OK if everything is ok, -1 otherwise
*
* i := should be implemented in intercept lib
* I := is implemented in intercept lib
* X := is implemented in service
* ? := required treatment Unknown
* - := Not needed
*
* [ ] EAGAIN or EWOULDBLOCK - The socket is marked nonblocking and no connections are present
* to be accepted. POSIX.1-2001 allows either error to be returned for
* this case, and does not require these constants to have the same value,
* so a portable application should check for both possibilities.
* [I] EBADF - The descriptor is invalid.
* [I] ECONNABORTED - A connection has been aborted.
* [i] EFAULT - The addr argument is not in a writable part of the user address space.
* [-] EINTR - The system call was interrupted by a signal that was caught before a valid connection arrived; see signal(7).
* [I] EINVAL - Socket is not listening for connections, or addrlen is invalid (e.g., is negative).
* [I] EINVAL - (accept4()) invalid value in flags.
* [I] EMFILE - The per-process limit of open file descriptors has been reached.
* [ ] ENFILE - The system limit on the total number of open files has been reached.
* [ ] ENOBUFS, ENOMEM - Not enough free memory. This often means that the memory allocation is
* limited by the socket buffer limits, not by the system memory.
* [I] ENOTSOCK - The descriptor references a file, not a socket.
* [I] EOPNOTSUPP - The referenced socket is not of type SOCK_STREAM.
* [ ] EPROTO - Protocol error.
*
*/
err_t nc_accept(void *arg, struct tcp_pcb *newPCB, err_t err);
err_t nc_recved_proxy(void *arg, struct tcp_pcb *PCB, struct pbuf *p, err_t err);
void nc_udp_recved(void * arg, struct udp_pcb * upcb, struct pbuf * p, ip_addr_t * addr, u16_t port);
/*
* Callback from LWIP when an internal error is associtated with the given (arg)
*
* Since the PCB related to this error might no longer exist, only its perviously
* associated (arg) is provided to us.
*
* @param associated service state object
* @param error code
*
*/
void nc_err(void *arg, err_t err);
/*
* Callback from LWIP to do whatever work we might need to do.
*
* @param associated service state object
* @param PCB we're polling on
* @return ERR_OK if everything is ok, -1 otherwise
*
*/
err_t nc_poll(void* arg, struct tcp_pcb *PCB);
/*
* Callback from LWIP to signal that 'len' bytes have successfully been sent.
* As a result, we should put our socket back into a notify-on-readability state
* since there is now room on the PCB buffer to write to.
*
* NOTE: This could be used to track the amount of data sent by a connection.
*
* @param associated service state object
* @param relevant PCB
* @param length of data sent
* @return ERR_OK if everything is ok, -1 otherwise
*
*/
err_t nc_sent(void *arg, struct tcp_pcb *PCB, u16_t len);
/*
* Callback from LWIP which sends a return value to the client to signal that
* a connection was established for this PCB
*
* @param associated service state object
* @param relevant PCB
* @param error code
* @return ERR_OK if everything is ok, -1 otherwise
*
*/
err_t nc_connected(void *arg, struct tcp_pcb *PCB, err_t err);
err_t nc_connected_proxy(void *arg, struct tcp_pcb *PCB, err_t err);
}
#ifdef D_GNU_SOURCE #ifdef D_GNU_SOURCE
#define _GNU_SOURCE #define _GNU_SOURCE
#endif #endif
@@ -336,7 +472,6 @@ namespace ZeroTier {
dlclose(_libref); dlclose(_libref);
} }
#if defined(SDK_IPV4) #if defined(SDK_IPV4)
inline struct netif * __netif_add(NETIF_ADD_SIG) throw() { Mutex::Lock _l(_lock); return _netif_add(netif,ipaddr,netmask,gw,state,init,input); } inline struct netif * __netif_add(NETIF_ADD_SIG) throw() { Mutex::Lock _l(_lock); return _netif_add(netif,ipaddr,netmask,gw,state,init,input); }
#endif #endif

2
src/stack_drivers/picotcp/README.md Normal file
View File

@@ -0,0 +1,2 @@
picoTCP Network Stack Driver
====

568
src/stack_drivers/picotcp/picotcp.cpp Normal file
View File

@@ -0,0 +1,568 @@
/*
* 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/
*/
#if defined(SDK_PICOTCP)
#include "tap.hpp"
#include "picotcp.hpp"
#include "pico_stack.h"
#include "pico_ipv4.h"
#include "pico_icmp4.h"
#include "pico_dev_tap.h"
#include "pico_protocol.h"
#include "pico_socket.h"
namespace ZeroTier {
// Reference to 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
// network stack provides a mechanism for storing a reference to the tap.
//
// In future releases this will be replaced with a new structure of static pointers that
// will make it easier to maintain multiple active tap interfaces
NetconEthernetTap *picotap;
struct pico_device picodev;
int pico_eth_send(struct pico_device *dev, void *buf, int len);
int pico_eth_poll(struct pico_device *dev, int loop_score);
// Initialize network stack's interfaces and assign addresses
void pico_init_interface(NetconEthernetTap *tap, const InetAddress &ip)
{
picoTCP_stack *stack = tap->picostack;
DEBUG_INFO();
if (std::find(picotap->_ips.begin(),picotap->_ips.end(),ip) == picotap->_ips.end()) {
picotap->_ips.push_back(ip);
std::sort(picotap->_ips.begin(),picotap->_ips.end());
#if defined(SDK_IPV4)
if(ip.isV4())
{
struct pico_ip4 ipaddr, netmask;
ipaddr.addr = *((u32_t *)ip.rawIpData());
netmask.addr = *((u32_t *)ip.netmask().rawIpData());
uint8_t mac[PICO_SIZE_ETH];
picotap->_mac.copyTo(mac, PICO_SIZE_ETH);
DEBUG_ATTN("mac = %s", picotap->_mac.toString().c_str());
picodev.send = pico_eth_send; // tx
picodev.poll = pico_eth_poll; // rx
picodev.mtu = picotap->_mtu;
if( 0 != stack->__pico_device_init(&(picodev), "p0", mac)) {
DEBUG_ERROR("device init failed");
return;
}
stack->__pico_ipv4_link_add(&(picodev), ipaddr, netmask);
// DEBUG_INFO("device initialized as ipv4_addr = %s", ipv4_str);
// picostack->__pico_icmp4_ping("10.8.8.1", 20, 1000, 10000, 64, cb_ping);
}
#elif defined(SDK_IPV6)
if(ip.isV6())
{
struct pico_ip6 ipaddr, netmask;
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);
stack->__pico_string_to_ipv6(ipv6_str, ipaddr.addr);
stack->__pico_string_to_ipv6(nm_str, netmask.addr);
stack->__pico_ipv6_link_add(&(picodev), ipaddr, netmask);
picodev.send = pico_eth_send; // tx
picodev.poll = pico_eth_poll; // rx
uint8_t mac[PICO_SIZE_ETH];
picotap->_mac.copyTo(mac, PICO_SIZE_ETH);
DEBUG_ATTN("mac = %s", picotap->_mac.toString().c_str());
if( 0 != stack->__pico_device_init(&(picodev), "p0", mac)) {
DEBUG_ERROR("device init failed");
return;
}
DEBUG_ATTN("device initialized as ipv6_addr = %s", ipv6_str);
}
#endif
}
}
// I/O thread loop
void pico_loop(NetconEthernetTap *tap)
{
DEBUG_INFO();
while(tap->_run)
{
tap->_phy.poll((unsigned long)std::min(500,1000));
usleep(1000);
tap->picostack->__pico_stack_tick();
}
}
// RX packets from network onto internal buffer
// Also notifies the tap service that data can be read, buffer will be emptied by pico_handleRead()
void pico_cb_tcp_read(NetconEthernetTap *tap, struct pico_socket *s)
{
// TODO: Verify
DEBUG_INFO();
Connection *conn = tap->getConnection(s);
if(conn) {
int r;
do {
//int avail = DEFAULT_TCP_RX_BUF_SZ - conn->rxsz;
//if(avail) {
r = tap->picostack->__pico_socket_read(s, conn->rxbuf + (conn->rxsz), ZT_MAX_MTU);
tap->_phy.setNotifyWritable(conn->sock, true);
DEBUG_INFO("read=%d", r);
if (r > 0) {
conn->rxsz += r;
}
//}
if (r < 0) {
exit(5);
}
}
while(r > 0);
return;
}
DEBUG_ERROR("invalid connection");
}
// TX packets from internal buffer to network
void pico_cb_tcp_write(NetconEthernetTap *tap, struct pico_socket *s)
{
Connection *conn = tap->getConnection(s);
if(!conn)
DEBUG_ERROR("invalid connection");
if(!conn->txsz)
return;
DEBUG_INFO("txsz=%d bytes ready to be written", conn->txsz);
// Only called from a locked context, no need to lock anything
if(conn->txsz > 0) {
int r = conn->txsz < ZT_MAX_MTU ? conn->txsz : ZT_MAX_MTU;
if((r = tap->picostack->__pico_socket_write(s, &conn->txbuf, r)) < 0) {
DEBUG_ERROR("unable to write to pico_socket=%p", (void*)s);
return;
}
int sz = (conn->txsz)-r;
if(sz)
memmove(&conn->txbuf, (conn->txbuf+r), sz);
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",
(float)conn->txsz / (float)max, (float)conn->rxsz / max, (void*)&conn->sock, r);
return;
}
}
// Main callback for TCP connections
void pico_cb_tcp(uint16_t ev, struct pico_socket *s)
{
Mutex::Lock _l(picotap->_tcpconns_m);
Connection *conn = picotap->getConnection(s);
if(!conn) {
DEBUG_ERROR("invalid connection");
}
if (ev & PICO_SOCK_EV_RD) {
pico_cb_tcp_read(picotap, s);
}
// Accept connection (analogous to lwip_nc_accept)
if (ev & PICO_SOCK_EV_CONN) {
DEBUG_INFO("connection established with server, sock=%p", (void*)(conn->picosock));
uint32_t peer;
uint16_t port;
struct pico_socket *client = picotap->picostack->__pico_socket_accept(s, &peer, &port);
if(!client) {
DEBUG_ERROR("there was an error accepting the connection, sock=%p", (void*)(conn->picosock));
}
ZT_PHY_SOCKFD_TYPE fds[2];
if(socketpair(PF_LOCAL, SOCK_STREAM, 0, fds) < 0) {
if(errno < 0) {
// FIXME: Return a value to the client
//picotap->sendReturnValue(conn, -1, errno);
DEBUG_ERROR("unable to create socketpair");
return;
}
}
Connection *newTcpConn = new Connection();
picotap->_Connections.push_back(newTcpConn);
newTcpConn->type = SOCK_STREAM;
newTcpConn->sock = picotap->_phy.wrapSocket(fds[0], newTcpConn);
newTcpConn->picosock = client;
int fd = picotap->_phy.getDescriptor(conn->sock);
if(sock_fd_write(fd, fds[1]) < 0) {
DEBUG_ERROR("error sending new fd to client application");
}
}
if (ev & PICO_SOCK_EV_FIN) {
DEBUG_INFO("socket closed. Exit normally.");
//picotap->__pico_timer_add(2000, compare_results, NULL);
}
if (ev & PICO_SOCK_EV_ERR) {
DEBUG_INFO("socket error received" /*, strerror(pico_err)*/);
//exit(1);
}
if (ev & PICO_SOCK_EV_CLOSE) {
DEBUG_INFO("socket received close from peer - Wrong case if not all client data sent!");
picotap->picostack->__pico_socket_close(s);
picotap->closeConnection(conn);
return;
}
if (ev & PICO_SOCK_EV_WR) {
pico_cb_tcp_write(picotap, s);
}
}
// Called when an incoming ping is received
/*
static void pico_cb_ping(struct pico_icmp4_stats *s)
{
DEBUG_INFO();
char host[30];
picotap->picostack->__pico_ipv4_to_string(host, s->dst.addr);
if (s->err == 0) {
printf("%lu bytes from %s: icmp_req=%lu ttl=%lu time=%lu ms\n", s->size,
host, s->seq, s->ttl, (long unsigned int)s->time);
} else {
printf("PING %lu to %s: Error %d\n", s->seq, host, s->err);
}
}
*/
// Sends data to the tap device (in our case, the ZeroTier service)
int pico_eth_send(struct pico_device *dev, void *buf, int len)
{
DEBUG_INFO("len=%d", len);
struct eth_hdr *ethhdr;
ethhdr = (struct eth_hdr *)buf;
MAC src_mac;
MAC dest_mac;
src_mac.setTo(ethhdr->src.addr, 6);
dest_mac.setTo(ethhdr->dest.addr, 6);
picotap->_handler(picotap->_arg,picotap->_nwid,src_mac,dest_mac,
Utils::ntoh((uint16_t)ethhdr->type),0, ((char*)buf) + sizeof(struct eth_hdr),len - sizeof(struct eth_hdr));
return len;
}
// Receives data from the tap device and encapsulates it into a ZeroTier ethernet frame and places it in a locked memory buffer
void pico_rx(NetconEthernetTap *tap, const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len)
{
// DEBUG_INFO();
// Since picoTCP only allows the reception of frames from within the polling function, we
// must enqueue each frame into a memory structure shared by both threads. This structure will
Mutex::Lock _l(tap->_pico_frame_rxbuf_m);
if(len > ((1024 * 1024) - tap->pico_frame_rxbuf_tot)) {
DEBUG_ERROR("dropping packet (len = %d) - not enough space left on RX frame buffer", len);
return;
}
//if(len != memcpy(pico_frame_rxbuf, data, len)) {
// DEBUG_ERROR("dropping packet (len = %d) - unable to copy contents of frame to RX frame buffer", len);
// return;
//}
// assemble new eth header
struct eth_hdr ethhdr;
from.copyTo(ethhdr.src.addr, 6);
to.copyTo(ethhdr.dest.addr, 6);
ethhdr.type = Utils::hton((uint16_t)etherType);
int newlen = len+sizeof(struct eth_hdr);
//
memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot, &newlen, sizeof(newlen)); // size of frame
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 += len + sizeof(len) + sizeof(ethhdr);
// DEBUG_INFO("RX frame buffer %3f full", (float)pico_frame_rxbuf_tot / (float)(1024 * 1024));
DEBUG_INFO("len=%d", len);
}
// Is called periodically by the stack, this removes data from the locked memory buffer and feeds it into the stack.
// A maximum of 'loop_score' frames can be processed in each call
int pico_eth_poll(struct pico_device *dev, int loop_score)
{
// DEBUG_EXTRA();
// OPTIMIZATION: The copy logic and/or buffer structure should be reworked for better performance after the BETA
// NetconEthernetTap *tap = (NetconEthernetTap*)netif->state;
Mutex::Lock _l(picotap->_pico_frame_rxbuf_m);
unsigned char frame[ZT_MAX_MTU];
uint32_t len;
while (picotap->pico_frame_rxbuf_tot > 0) {
memset(frame, 0, sizeof(frame));
len = 0;
memcpy(&len, picotap->pico_frame_rxbuf, sizeof(len)); // get frame len
memcpy(frame, picotap->pico_frame_rxbuf + sizeof(len), len); // get frame data
memmove(picotap->pico_frame_rxbuf, picotap->pico_frame_rxbuf + sizeof(len) + len, ZT_MAX_MTU-(sizeof(len) + len));
picotap->picostack->__pico_stack_recv(dev, (uint8_t*)frame, len);
picotap->pico_frame_rxbuf_tot-=(sizeof(len) + len);
// DEBUG_EXTRA("RX frame buffer %3f full", (float)(picotap->pico_frame_rxbuf_tot) / (float)(MAX_PICO_FRAME_RX_BUF_SZ));
loop_score--;
}
return loop_score;
}
// Creates a new pico_socket and Connection object to represent a new connection to be.
Connection *pico_handleSocket(PhySocket *sock, void **uptr, struct socket_st* socket_rpc)
{
DEBUG_INFO();
struct pico_socket * psock;
#if defined(SDK_IPV4)
psock = picotap->picostack->__pico_socket_open(PICO_PROTO_IPV4, PICO_PROTO_TCP, &pico_cb_tcp);
#elif defined(SDK_IPV6)
psock = picotap->picostack->__pico_socket_open(PICO_PROTO_IPV6, PICO_PROTO_TCP, &pico_cb_tcp);
#endif
if(psock) {
DEBUG_ATTN("psock = %p", (void*)psock);
Connection * newConn = new Connection();
*uptr = newConn;
newConn->type = socket_rpc->socket_type;
newConn->sock = sock;
newConn->local_addr = NULL;
newConn->peer_addr = NULL;
newConn->picosock = psock;
picotap->_Connections.push_back(newConn);
return newConn;
}
else {
DEBUG_ERROR("failed to create pico_socket");
}
return NULL;
}
// Writes data from the I/O buffer to the network stack
void pico_handleWrite(Connection *conn)
{
DEBUG_INFO();
if(!conn || !conn->picosock) {
DEBUG_ERROR(" invalid connection");
return;
}
int 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) {
DEBUG_ERROR("unable to write to pico_socket(%p)", (void*)&(conn->picosock));
return;
}
/*
if(pico_err == PICO_ERR_EINVAL)
DEBUG_ERROR("PICO_ERR_EINVAL - invalid argument");
if(pico_err == PICO_ERR_EIO)
DEBUG_ERROR("PICO_ERR_EIO - input/output error");
if(pico_err == PICO_ERR_ENOTCONN)
DEBUG_ERROR("PICO_ERR_ENOTCONN - the socket is not connected");
if(pico_err == PICO_ERR_ESHUTDOWN)
DEBUG_ERROR("PICO_ERR_ESHUTDOWN - cannot send after transport endpoint shutdown");
if(pico_err == PICO_ERR_EADDRNOTAVAIL)
DEBUG_ERROR("PICO_ERR_EADDRNOTAVAIL - address not available");
if(pico_err == PICO_ERR_EHOSTUNREACH)
DEBUG_ERROR("PICO_ERR_EHOSTUNREACH - host is unreachable");
if(pico_err == PICO_ERR_ENOMEM)
DEBUG_ERROR("PICO_ERR_ENOMEM - not enough space");
if(pico_err == PICO_ERR_EAGAIN)
DEBUG_ERROR("PICO_ERR_EAGAIN - resource temporarily unavailable");
*/
// adjust buffer
int sz = (conn->txsz)-r;
if(sz)
memmove(&conn->txbuf, (conn->txbuf+r), sz);
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",
(float)conn->txsz / (float)max, (float)conn->rxsz / max, (void*)&conn->sock, r);
}
// Instructs the stack to connect to a remote host
void pico_handleConnect(PhySocket *sock, PhySocket *rpcSock, Connection *conn, struct connect_st* connect_rpc)
{
DEBUG_INFO();
if(conn->picosock) {
struct sockaddr_in *addr = (struct sockaddr_in *) &connect_rpc->addr;
int ret;
// TODO: Rewrite this
#if defined(SDK_IPV4)
struct pico_ip4 zaddr;
struct sockaddr_in *in4 = (struct sockaddr_in*)&connect_rpc->addr;
char 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));
DEBUG_ATTN("addr=%s:%d", ipv4_str, addr->sin_port);
ret = picotap->picostack->__pico_socket_connect(conn->picosock, &zaddr, addr->sin_port);
#elif defined(SDK_IPV6) // "fd56:5799:d8f6:1238:8c99:9322:30ce:418a"
struct pico_ip6 zaddr;
struct sockaddr_in6 *in6 = (struct sockaddr_in6*)&connect_rpc->addr;
char 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);
DEBUG_ATTN("addr=%s:%d", ipv6_str, addr->sin_port);
ret = picotap->picostack->__pico_socket_connect(conn->picosock, &zaddr, addr->sin_port);
#endif
if(ret == PICO_ERR_EPROTONOSUPPORT) {
DEBUG_ERROR("PICO_ERR_EPROTONOSUPPORT");
}
if(ret == PICO_ERR_EINVAL) {
DEBUG_ERROR("PICO_ERR_EINVAL");
}
if(ret == PICO_ERR_EHOSTUNREACH) {
DEBUG_ERROR("PICO_ERR_EHOSTUNREACH");
}
picotap->sendReturnValue(picotap->_phy.getDescriptor(rpcSock), 0, ERR_OK);
}
}
// Instructs the stack to bind to a given address
void pico_handleBind(PhySocket *sock, PhySocket *rpcSock, void **uptr, struct bind_st *bind_rpc)
{
DEBUG_INFO();
Connection *conn = picotap->getConnection(sock);
if(!sock) {
DEBUG_ERROR("invalid connection");
return;
}
struct sockaddr_in *addr = (struct sockaddr_in *) &bind_rpc->addr;
int ret;
// TODO: Rewrite this
#if defined(SDK_IPV4)
struct pico_ip4 zaddr;
struct sockaddr_in *in4 = (struct sockaddr_in*)&bind_rpc->addr;
char 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));
DEBUG_ATTN("addr=%s", ipv4_str/*, ntohs((uint16_t*)&(addr->sin_port))*/);
ret = picotap->picostack->__pico_socket_bind(conn->picosock, &zaddr, (uint16_t*)&(addr->sin_port));
#elif defined(SDK_IPV6)
struct pico_ip6 zaddr;
struct sockaddr_in6 *in6 = (struct sockaddr_in6*)&bind_rpc->addr;
char 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);
DEBUG_ATTN("addr=%s", ipv6_str/*, ntohs((uint16_t*)&(addr->sin_port))*/);
ret = picotap->picostack->__pico_socket_bind(conn->picosock, &zaddr, (uint16_t*)&(addr->sin_port));
#endif
if(ret < 0) {
DEBUG_ERROR("unable to bind pico_socket(%p)", (void*)(conn->picosock));
if(ret == PICO_ERR_EINVAL) {
DEBUG_ERROR("PICO_ERR_EINVAL - invalid argument");
picotap->sendReturnValue(picotap->_phy.getDescriptor(rpcSock), -1, EINVAL);
}
if(ret == PICO_ERR_ENOMEM) {
DEBUG_ERROR("PICO_ERR_ENOMEM - not enough space");
picotap->sendReturnValue(picotap->_phy.getDescriptor(rpcSock), -1, ENOMEM);
}
if(ret == PICO_ERR_ENXIO) {
DEBUG_ERROR("PICO_ERR_ENXIO - no such device or address");
picotap->sendReturnValue(picotap->_phy.getDescriptor(rpcSock), -1, ENXIO);
}
}
picotap->sendReturnValue(picotap->_phy.getDescriptor(rpcSock), ERR_OK, ERR_OK); // success
}
// Puts a pico_socket into a listening state to receive incoming connection requests
void pico_handleListen(PhySocket *sock, PhySocket *rpcSock, void **uptr, struct listen_st *listen_rpc)
{
Connection *conn = picotap->getConnection(sock);
DEBUG_ATTN("conn = %p", (void*)conn);
if(!sock || !conn) {
DEBUG_ERROR("invalid connection");
return;
}
int ret, backlog = 1;
if((ret = picotap->picostack->__pico_socket_listen(conn->picosock, backlog)) < 0)
{
if(ret == PICO_ERR_EINVAL) {
DEBUG_ERROR("PICO_ERR_EINVAL - invalid argument");
picotap->sendReturnValue(picotap->_phy.getDescriptor(rpcSock), -1, EINVAL);
}
if(ret == PICO_ERR_EISCONN) {
DEBUG_ERROR("PICO_ERR_EISCONN - socket is connected");
picotap->sendReturnValue(picotap->_phy.getDescriptor(rpcSock), -1, EISCONN);
}
}
picotap->sendReturnValue(picotap->_phy.getDescriptor(rpcSock), ERR_OK, ERR_OK); // success
}
// Feeds data into the client socket from the I/O buffer associated with the connection
void pico_handleRead(PhySocket *sock,void **uptr,bool lwip_invoked)
{
// DEBUG_INFO();
Connection *conn = picotap->getConnection(sock);
if(conn && conn->rxsz) {
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);
// extract address and payload size info
if(conn->type==SOCK_DGRAM) {
int payload_sz, addr_sz_offset = sizeof(struct sockaddr_storage);
memcpy(&payload_sz, conn->rxbuf + addr_sz_offset, sizeof(int));
struct sockaddr_storage addr;
memcpy(&addr, conn->rxbuf, addr_sz_offset);
// adjust buffer
if(conn->rxsz-n > 0) // If more remains on buffer
memcpy(conn->rxbuf, conn->rxbuf+ZT_MAX_MTU, conn->rxsz - ZT_MAX_MTU);
conn->rxsz -= ZT_MAX_MTU;
}
if(conn->type==SOCK_STREAM) {
//int payload_sz, addr_sz_offset = sizeof(struct sockaddr_storage);
//memcpy(&payload_sz, conn->rxbuf + addr_sz_offset, sizeof(int));
//struct sockaddr_storage addr;
//memcpy(&addr, conn->rxbuf, addr_sz_offset);
// adjust buffer
if(conn->rxsz-n > 0) // If more remains on buffer
memcpy(conn->rxbuf, conn->rxbuf+n, conn->rxsz - n);
conn->rxsz -= n;
DEBUG_INFO("rxsz=%d", conn->rxsz);
}
if(n) {
//DEBUG_INFO("wrote %d bytes to client application", n);
if(conn->type==SOCK_STREAM) { // Only acknolwedge receipt of TCP packets
DEBUG_TRANS("[TCP RX] <--- :: {TX: %.3f%%, RX: %.3f%%, sock=%p} :: %ld bytes",
(float)conn->txsz / max, (float)conn->rxsz / max, (void*)conn->sock, n);
}
picotap->_phy.setNotifyWritable(conn->sock, true);
}
if(!n || !(conn->rxsz)) {
picotap->_phy.setNotifyWritable(conn->sock, false);
}
}
}
// Closes a pico_socket
/*
static void pico_handleClose(Connection *conn)
{
DEBUG_INFO();
int ret;
if(conn && conn->picosock) {
if((ret = picotap->picostack->__pico_socket_close(conn->picosock)) < 0) {
DEBUG_ERROR("error closing pico_socket(%p)", (void*)(conn->picosock));
// sendReturnValue()
}
return;
}
DEBUG_ERROR("invalid connection or pico_socket");
}
*/
}
#endif // SDK_PICOTCP

21
src/stack_drivers/picotcp.hpp → src/stack_drivers/picotcp/picotcp.hpp
View File

@@ -80,6 +80,27 @@
namespace ZeroTier { namespace ZeroTier {
class NetconEthernetTap;
struct Connection;
// Driver function prototypes
int pico_eth_send(struct pico_device *dev, void *buf, int len);
int pico_eth_poll(struct pico_device *dev, int loop_score);
void pico_init_interface(NetconEthernetTap *tap, const InetAddress &ip);
void pico_loop(NetconEthernetTap *tap);
void pico_cb_tcp_read(NetconEthernetTap *tap, struct pico_socket *s);
void pico_cb_tcp_write(NetconEthernetTap *tap, struct pico_socket *s);
void pico_cb_tcp(uint16_t ev, struct pico_socket *s);
int pico_eth_send(struct pico_device *dev, void *buf, int len);
void pico_rx(NetconEthernetTap *tap, const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len);
int pico_eth_poll(struct pico_device *dev, int loop_score);
Connection *pico_handleSocket(PhySocket *sock, void **uptr, struct socket_st* socket_rpc);
void pico_handleWrite(Connection *conn);
void pico_handleConnect(PhySocket *sock, PhySocket *rpcSock, Connection *conn, struct connect_st* connect_rpc);
void pico_handleBind(PhySocket *sock, PhySocket *rpcSock, void **uptr, struct bind_st *bind_rpc);
void pico_handleListen(PhySocket *sock, PhySocket *rpcSock, void **uptr, struct listen_st *listen_rpc);
void pico_handleRead(PhySocket *sock,void **uptr,bool lwip_invoked);
/** /**
* Loads an instance of picoTCP stack library in a private memory arena * Loads an instance of picoTCP stack library in a private memory arena
* *

1810
src/tap.cpp
View File

File diff suppressed because it is too large Load Diff

167
src/tap.hpp
View File

@@ -56,11 +56,6 @@
#include "pico_protocol.h" #include "pico_protocol.h"
#endif #endif
#define ip4_addr1b(ipaddr) (((u8_t*)(ipaddr))[0])
#define ip4_addr2b(ipaddr) (((u8_t*)(ipaddr))[1])
#define ip4_addr3b(ipaddr) (((u8_t*)(ipaddr))[2])
#define ip4_addr4b(ipaddr) (((u8_t*)(ipaddr))[3])
// lwIP structs // lwIP structs
struct tcp_pcb; struct tcp_pcb;
struct udp_pcb; struct udp_pcb;
@@ -75,6 +70,9 @@ struct accept_st;
namespace ZeroTier { namespace ZeroTier {
extern struct pico_device picodev;
extern NetconEthernetTap *picotap;
class NetconEthernetTap; class NetconEthernetTap;
class LWIPStack; class LWIPStack;
@@ -142,7 +140,8 @@ namespace ZeroTier {
void setFriendlyName(const char *friendlyName); void setFriendlyName(const char *friendlyName);
void scanMulticastGroups(std::vector<MulticastGroup> &added,std::vector<MulticastGroup> &removed); void scanMulticastGroups(std::vector<MulticastGroup> &added,std::vector<MulticastGroup> &removed);
// SIP- int sendReturnValue(int fd, int retval, int _errno);
void unloadRPC(void *data, pid_t &pid, pid_t &tid, char (timestamp[RPC_TIMESTAMP_SZ]), char (CANARY[sizeof(uint64_t)]), char &cmd, void* &payload);
void threadMain() void threadMain()
throw(); throw();
@@ -166,19 +165,13 @@ namespace ZeroTier {
std::string _homePath; std::string _homePath;
// lwIP // lwIP
void lwIP_loop();
void lwIP_rx(const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len);
void lwIP_init_interface(const InetAddress &ip);
#if defined(SDK_LWIP) #if defined(SDK_LWIP)
lwIP_stack *lwipstack; lwIP_stack *lwipstack;
#endif #endif
// jip // jip
void jip_loop(); #if defined(SDK_JIP)
void jip_rx(const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len);
void jip_init_interface(const InetAddress &ip);
jip_stack *jipstack; jip_stack *jipstack;
#endif
// picoTCP // picoTCP
#if defined(SDK_PICOTCP) #if defined(SDK_PICOTCP)
unsigned char pico_frame_rxbuf[MAX_PICO_FRAME_RX_BUF_SZ]; unsigned char pico_frame_rxbuf[MAX_PICO_FRAME_RX_BUF_SZ];
@@ -187,124 +180,6 @@ namespace ZeroTier {
picoTCP_stack *picostack; picoTCP_stack *picostack;
#endif #endif
// LWIP callbacks
// NOTE: these are called from within LWIP, meaning that lwipstack->_lock is ALREADY
// locked in this case!
/*
* Callback from LWIP for when a connection has been accepted and the PCB has been
* put into an ACCEPT state.
*
* A socketpair is created, one end is kept and wrapped into a PhySocket object
* for use in the main ZT I/O loop, and one end is sent to the client. The client
* is then required to tell the service what new file descriptor it has allocated
* for this connection. After the mapping is complete, the accepted socket can be
* used.
*
* @param associated service state object
* @param newly allocated PCB
* @param error code
* @return ERR_OK if everything is ok, -1 otherwise
*
* i := should be implemented in intercept lib
* I := is implemented in intercept lib
* X := is implemented in service
* ? := required treatment Unknown
* - := Not needed
*
* [ ] EAGAIN or EWOULDBLOCK - The socket is marked nonblocking and no connections are present
* to be accepted. POSIX.1-2001 allows either error to be returned for
* this case, and does not require these constants to have the same value,
* so a portable application should check for both possibilities.
* [I] EBADF - The descriptor is invalid.
* [I] ECONNABORTED - A connection has been aborted.
* [i] EFAULT - The addr argument is not in a writable part of the user address space.
* [-] EINTR - The system call was interrupted by a signal that was caught before a valid connection arrived; see signal(7).
* [I] EINVAL - Socket is not listening for connections, or addrlen is invalid (e.g., is negative).
* [I] EINVAL - (accept4()) invalid value in flags.
* [I] EMFILE - The per-process limit of open file descriptors has been reached.
* [ ] ENFILE - The system limit on the total number of open files has been reached.
* [ ] ENOBUFS, ENOMEM - Not enough free memory. This often means that the memory allocation is
* limited by the socket buffer limits, not by the system memory.
* [I] ENOTSOCK - The descriptor references a file, not a socket.
* [I] EOPNOTSUPP - The referenced socket is not of type SOCK_STREAM.
* [ ] EPROTO - Protocol error.
*
*/
static err_t nc_accept(void *arg, struct tcp_pcb *newPCB, err_t err);
/*
* Callback from LWIP for when data is available to be read from the network.
*
* Data is in the form of a linked list of struct pbufs, it is then recombined and
* send to the client over the associated unix socket.
*
* @param associated service state object
* @param allocated PCB
* @param chain of pbufs
* @param error code
* @return ERR_OK if everything is ok, -1 otherwise
*
*/
static err_t nc_recved(void *arg, struct tcp_pcb *PCB, struct pbuf *p, err_t err);
static err_t nc_recved_proxy(void *arg, struct tcp_pcb *PCB, struct pbuf *p, err_t err);
static void nc_udp_recved(void * arg, struct udp_pcb * upcb, struct pbuf * p, ip_addr_t * addr, u16_t port);
/*
* Callback from LWIP when an internal error is associtated with the given (arg)
*
* Since the PCB related to this error might no longer exist, only its perviously
* associated (arg) is provided to us.
*
* @param associated service state object
* @param error code
*
*/
static void nc_err(void *arg, err_t err);
/*
* Callback from LWIP to do whatever work we might need to do.
*
* @param associated service state object
* @param PCB we're polling on
* @return ERR_OK if everything is ok, -1 otherwise
*
*/
static err_t nc_poll(void* arg, struct tcp_pcb *PCB);
/*
* Callback from LWIP to signal that 'len' bytes have successfully been sent.
* As a result, we should put our socket back into a notify-on-readability state
* since there is now room on the PCB buffer to write to.
*
* NOTE: This could be used to track the amount of data sent by a connection.
*
* @param associated service state object
* @param relevant PCB
* @param length of data sent
* @return ERR_OK if everything is ok, -1 otherwise
*
*/
static err_t nc_sent(void *arg, struct tcp_pcb *PCB, u16_t len);
/*
* Callback from LWIP which sends a return value to the client to signal that
* a connection was established for this PCB
*
* @param associated service state object
* @param relevant PCB
* @param error code
* @return ERR_OK if everything is ok, -1 otherwise
*
*/
static err_t nc_connected(void *arg, struct tcp_pcb *PCB, err_t err);
static err_t nc_connected_proxy(void *arg, struct tcp_pcb *PCB, err_t err);
//static void nc_close(struct tcp_pcb *PCB);
//static err_t nc_send(struct tcp_pcb *PCB);
/* /*
* Handles an RPC to bind an LWIP PCB to a given address and port * Handles an RPC to bind an LWIP PCB to a given address and port
* *
@@ -443,18 +318,6 @@ namespace ZeroTier {
*/ */
void handleWrite(Connection *conn); void handleWrite(Connection *conn);
/*
* Sends a return value to the intercepted application
*/
int sendReturnValue(PhySocket *sock, int retval, int _errno);
int sendReturnValue(int fd, int retval, int _errno);
/*
* Unpacks the buffer from an RPC command
*/
void unloadRPC(void *data, pid_t &pid, pid_t &tid,
char (timestamp[RPC_TIMESTAMP_SZ]), char (magic[sizeof(uint64_t)]), char &cmd, void* &payload);
// Unused -- no UDP or TCP from this thread/Phy<> // Unused -- no UDP or TCP from this thread/Phy<>
void phyOnDatagram(PhySocket *sock,void **uptr,const struct sockaddr *local_address, const struct sockaddr *from,void *data,unsigned long len); void phyOnDatagram(PhySocket *sock,void **uptr,const struct sockaddr *local_address, const struct sockaddr *from,void *data,unsigned long len);
void phyOnTcpConnect(PhySocket *sock,void **uptr,bool success); void phyOnTcpConnect(PhySocket *sock,void **uptr,bool success);
@@ -496,22 +359,6 @@ namespace ZeroTier {
*/ */
void closeConnection(PhySocket *sock); void closeConnection(PhySocket *sock);
#if defined(SDK_IPV4)
ip_addr_t convert_ip(struct sockaddr_in * addr)
{
ip_addr_t conn_addr;
struct sockaddr_in *ipv4 = addr;
short a = ip4_addr1b(&(ipv4->sin_addr));
short b = ip4_addr2b(&(ipv4->sin_addr));
short c = ip4_addr3b(&(ipv4->sin_addr));
short d = ip4_addr4b(&(ipv4->sin_addr));
IP4_ADDR(&conn_addr, a,b,c,d);
return conn_addr;
}
#endif
Phy<NetconEthernetTap *> _phy; Phy<NetconEthernetTap *> _phy;
PhySocket *_unixListenSocket; PhySocket *_unixListenSocket;