Add portability and consistency fixes for C API, remove cruft, slight internal restructuring1.3.3

1 files changed, 401 insertions, 173 deletions

diff --git a/src/Sockets.cpp b/src/Sockets.cpp
index 9adc0c2..7844c51 100644
--- a/src/Sockets.cpp
+++ b/src/Sockets.cpp
@@ -17,42 +17,41 @@
  * ZeroTier Socket API
  */
 
-#include <string.h>
-
 #include "lwip/sockets.h"
 #include "lwip/def.h"
+#include "lwip/inet.h"
+#include "lwip/stats.h"
 
-#include "ZeroTierConstants.h"
-#include "Options.h"
-#include "Debug.hpp"
+#include "ZeroTierSockets.h"
+#include "Events.hpp"
 
 #ifdef SDK_JNI
 	#include <jni.h>
 #endif
 
-namespace ZeroTier {
+extern int zts_errno;
 
-//////////////////////////////////////////////////////////////////////////////
-// ZeroTier Socket API                                                      //
-//////////////////////////////////////////////////////////////////////////////
+namespace ZeroTier {
 
-extern bool _run_service;
-extern bool _run_lwip_tcpip;
+extern uint8_t _serviceStateFlags;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #ifdef SDK_JNI
-void ss2zta(JNIEnv *env, struct sockaddr_storage *ss, jobject addr);
-void zta2ss(JNIEnv *env, struct sockaddr_storage *ss, jobject addr);
-void ztfdset2fdset(JNIEnv *env, int nfds, jobject src_ztfd_set, fd_set *dest_fd_set);
-void fdset2ztfdset(JNIEnv *env, int nfds, fd_set *src_fd_set, jobject dest_ztfd_set);
+void ss2zta(JNIEnv *env, struct zts_sockaddr_storage *ss, jobject addr);
+void zta2ss(JNIEnv *env, struct zts_sockaddr_storage *ss, jobject addr);
+void ztfdset2fdset(JNIEnv *env, int nfds, jobject src_ztfd_set, zts_fd_set *dest_fd_set);
+void fdset2ztfdset(JNIEnv *env, int nfds, zts_fd_set *src_fd_set, jobject dest_ztfd_set);
 #endif
 
-int zts_socket(int socket_family, int socket_type, int protocol)
+int zts_socket(const int socket_family, const int socket_type, const int protocol)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_socket(socket_family, socket_type, protocol);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_socket(socket_family, socket_type, protocol);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_socket(
@@ -63,53 +62,62 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_socket(
 }
 #endif
 
-int zts_connect(int fd, const struct sockaddr *addr, socklen_t addrlen)
+int zts_connect(int fd, const struct zts_sockaddr *addr, zts_socklen_t addrlen)
 {
 	if (!addr) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
+	}
+	if (addrlen > (int)sizeof(struct zts_sockaddr_storage) || addrlen < (int)sizeof(struct zts_sockaddr_in)) {
+		return ZTS_ERR_ARG;
 	}
-	if (addrlen > (int)sizeof(struct sockaddr_storage) || addrlen < (int)sizeof(struct sockaddr_in)) {
-		return ZTS_ERR_INVALID_ARG;
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_connect(fd, addr, addrlen);
+	return lwip_connect(fd, (sockaddr*)addr, addrlen);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_connect(
 	JNIEnv *env, jobject thisObj, jint fd, jobject addr)
 {
-	struct sockaddr_storage ss;
+	struct zts_sockaddr_storage ss;
 	zta2ss(env, &ss, addr);
-	socklen_t addrlen = ss.ss_family == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
-	int retval = zts_connect(fd, (struct sockaddr *)&ss, addrlen);
+	socklen_t addrlen = ss.ss_family == ZTS_AF_INET ? sizeof(struct zts_sockaddr_in) : sizeof(struct zts_sockaddr_in6);
+	int retval = zts_connect(fd, (struct zts_sockaddr *)&ss, addrlen);
 	return retval > -1 ? retval : -(zts_errno);
 }
 #endif
 
-int zts_bind(int fd, const struct sockaddr *addr, socklen_t addrlen)
+int zts_bind(int fd, const struct zts_sockaddr *addr, zts_socklen_t addrlen)
 {
 	if (!addr) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
 	}
-	if (addrlen > (int)sizeof(struct sockaddr_storage) || addrlen < (int)sizeof(struct sockaddr_in)) {
-		return ZTS_ERR_INVALID_ARG;
+	if (addrlen > (int)sizeof(struct zts_sockaddr_storage) || addrlen < (int)sizeof(struct zts_sockaddr_in)) {
+		return ZTS_ERR_ARG;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_bind(fd, addr, addrlen);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_bind(fd, (sockaddr*)addr, addrlen);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_bind(
 	JNIEnv *env, jobject thisObj, jint fd, jobject addr)
 {
-	struct sockaddr_storage ss;
+	struct zts_sockaddr_storage ss;
 	zta2ss(env, &ss, addr);
-	socklen_t addrlen = ss.ss_family == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
-	int retval = zts_bind(fd, (struct sockaddr*)&ss, addrlen);
+	zts_socklen_t addrlen = ss.ss_family == ZTS_AF_INET ? sizeof(struct zts_sockaddr_in) : sizeof(struct zts_sockaddr_in6);
+	int retval = zts_bind(fd, (struct zts_sockaddr*)&ss, addrlen);
 	return retval > -1 ? retval : -(zts_errno);
 }
 #endif
 
 int zts_listen(int fd, int backlog)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_listen(fd, backlog);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_listen(fd, backlog);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_listen(
@@ -120,26 +128,32 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_listen(
 }
 #endif
 
-int zts_accept(int fd, struct sockaddr *addr, socklen_t *addrlen)
+int zts_accept(int fd, struct zts_sockaddr *addr, zts_socklen_t *addrlen)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_accept(fd, addr, addrlen);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_accept(fd, (sockaddr*)addr, (socklen_t*)addrlen);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_accept(
 	JNIEnv *env, jobject thisObj, jint fd, jobject addr, jint port)
 {
-	struct sockaddr_storage ss;
-	socklen_t addrlen = sizeof(struct sockaddr_storage);
-	int retval = zts_accept(fd, (struct sockaddr *)&ss, &addrlen);
+	struct zts_sockaddr_storage ss;
+	zts_socklen_t addrlen = sizeof(struct zts_sockaddr_storage);
+	int retval = zts_accept(fd, (zts_sockaddr*)&ss, &addrlen);
 	ss2zta(env, &ss, addr);
 	return retval > -1 ? retval : -(zts_errno);
 }
 #endif
 
 #if defined(__linux__)
-int zts_accept4(int fd, struct sockaddr *addr, socklen_t *addrlen, int flags)
+int zts_accept4(int fd, struct zts_sockaddr *addr, zts_socklen_t *addrlen, int flags)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_INVALID_OP : ZTS_ERR_INVALID_OP;
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return ZTS_ERR_SERVICE; // TODO
 }
 #endif
 #ifdef SDK_JNI
@@ -147,18 +161,21 @@ int zts_accept4(int fd, struct sockaddr *addr, socklen_t *addrlen, int flags)
  JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_accept4(
 	JNIEnv *env, jobject thisObj, jint fd, jobject addr, jint port, jint flags)
  {
-	struct sockaddr_storage ss;
-	socklen_t addrlen = sizeof(struct sockaddr_storage);
-	int retval = zts_accept4(fd, (struct sockaddr *)&ss, &addrlen, flags);
+	struct zts_sockaddr_storage ss;
+	zts_socklen_t addrlen = sizeof(struct zts_sockaddr_storage);
+	int retval = zts_accept4(fd, (struct zts_sockaddr *)&ss, &addrlen, flags);
 	ss2zta(env, &ss, addr);
 	return retval > -1 ? retval : -(zts_errno);
 }
 #endif
 #endif
 
-int zts_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
+int zts_setsockopt(int fd, int level, int optname, const void *optval,zts_socklen_t optlen)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_setsockopt(fd, level, optname, optval, optlen);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_setsockopt(fd, level, optname, optval, optlen);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_setsockopt(
@@ -166,7 +183,7 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_setsockopt(
 {
 	jclass c = env->GetObjectClass(optval);
 	if (!c) {
-		return ZTS_ERR_INVALID_OP;
+		return ZTS_ERR_SERVICE;
 	}
 	int optval_int = -1;
 
@@ -206,9 +223,12 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_setsockopt(
 }
 #endif
 
-int zts_getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlen)
+int zts_getsockopt(int fd, int level, int optname, void *optval, zts_socklen_t *optlen)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_getsockopt(fd, level, optname, optval, optlen);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_getsockopt(fd, level, optname, optval, (socklen_t*)optlen);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_getsockopt(
@@ -216,15 +236,15 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_getsockopt(
 {
 	jclass c = env->GetObjectClass(optval);
 	if (!c) {
-		return ZTS_ERR_INVALID_OP;
+		return ZTS_ERR_SERVICE;
 	}
 	int optval_int = 0;
-	socklen_t optlen; // Intentionally not used
+	zts_socklen_t optlen; // Intentionally not used
 
 	int retval;
 
 	if (optname == SO_RCVTIMEO) {
-		struct timeval tv;
+		struct zts_timeval tv;
 		optlen = sizeof(tv);
 		retval = zts_getsockopt(fd, level, optname, &tv, &optlen);
 		// Convert seconds and microseconds back to milliseconds
@@ -261,91 +281,61 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_getsockopt(
 }
 #endif
 
-int zts_getsockname(int fd, struct sockaddr *addr, socklen_t *addrlen)
+int zts_getsockname(int fd, struct zts_sockaddr *addr, zts_socklen_t *addrlen)
 {
 	if (!addr) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
+	}
+	if (*addrlen > (int)sizeof(struct zts_sockaddr_storage) || *addrlen < (int)sizeof(struct zts_sockaddr_in)) {
+		return ZTS_ERR_ARG;
 	}
-	if (*addrlen > (int)sizeof(struct sockaddr_storage) || *addrlen < (int)sizeof(struct sockaddr_in)) {
-		return ZTS_ERR_INVALID_ARG;
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_getsockname(fd, addr, addrlen);
+	return lwip_getsockname(fd, (sockaddr*)addr, (socklen_t*)addrlen);
 }
 #ifdef SDK_JNI
 JNIEXPORT jboolean JNICALL Java_com_zerotier_libzt_ZeroTier_getsockname(JNIEnv *env, jobject thisObj,
 	jint fd, jobject addr)
 {
-	struct sockaddr_storage ss;
-	socklen_t addrlen = sizeof(struct sockaddr_storage);
-	int retval =zts_getsockname(fd, (struct sockaddr *)&ss, &addrlen);
+	struct zts_sockaddr_storage ss;
+	zts_socklen_t addrlen = sizeof(struct zts_sockaddr_storage);
+	int retval = zts_getsockname(fd, (struct zts_sockaddr *)&ss, &addrlen);
 	ss2zta(env, &ss, addr);	 
 	return retval > -1 ? retval : -(zts_errno);
 }
 #endif
 
-int zts_getpeername(int fd, struct sockaddr *addr, socklen_t *addrlen)
+int zts_getpeername(int fd, struct zts_sockaddr *addr, zts_socklen_t *addrlen)
 {
 	if (!addr) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
 	}
-	if (*addrlen > (int)sizeof(struct sockaddr_storage) || *addrlen < (int)sizeof(struct sockaddr_in)) {
-		return ZTS_ERR_INVALID_ARG;
+	if (*addrlen > (int)sizeof(struct zts_sockaddr_storage) || *addrlen < (int)sizeof(struct zts_sockaddr_in)) {
+		return ZTS_ERR_ARG;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_getpeername(fd, addr, addrlen);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_getpeername(fd, (sockaddr*)addr, (socklen_t*)addrlen);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_getpeername(JNIEnv *env, jobject thisObj,
 	jint fd, jobject addr)
 {
-	struct sockaddr_storage ss;
-	int retval = zts_getpeername(fd, (struct sockaddr *)&ss, (socklen_t *)sizeof(struct sockaddr_storage));
+	struct zts_sockaddr_storage ss;
+	int retval = zts_getpeername(fd, (struct zts_sockaddr *)&ss, (zts_socklen_t*)sizeof(struct zts_sockaddr_storage));
 	ss2zta(env, &ss, addr);	 
 	return retval > -1 ? retval : -(zts_errno);
 }
 #endif
 
-int zts_gethostname(char *name, size_t len)
-{
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_INVALID_OP : ZTS_ERR_INVALID_OP; // TODO
-}
-#ifdef SDK_JNI
-#endif
-
-int zts_sethostname(const char *name, size_t len)
-{
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_INVALID_OP : ZTS_ERR_INVALID_OP; // TODO
-}
-#ifdef SDK_JNI
-#endif
-
-/*
-struct hostent *zts_gethostbyname(const char *name)
-{
-	return (struct hostent *)((!_run_service || !_run_lwip_tcpip) ? NULL : NULL);
-	// TODO: Test thread safety
-	char buf[256];
-	int buflen = 256;
-	int h_err = 0;
-	struct hostent hret;
-	struct hostent **result = NULL;
-	int err = 0;
-	if ((err = lwip_gethostbyname_r(name, &hret, buf, buflen, result, &h_err)) != 0) {
-		DEBUG_ERROR("err = %d", err);
-		DEBUG_ERROR("h_err = %d", h_err);
-		errno = h_err;
-		return NULL; // failure
-	}
-	return *result;
-	
-	return lwip_gethostbyname(name);
-}
-#ifdef SDK_JNI
-#endif
-*/
-
 int zts_close(int fd)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_close(fd);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_close(fd);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_close(
@@ -355,22 +345,25 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_close(
 }
 #endif
 
-int zts_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
-	struct timeval *timeout)
+int zts_select(int nfds, zts_fd_set *readfds, zts_fd_set *writefds, zts_fd_set *exceptfds,
+	struct zts_timeval *timeout)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_select(nfds, readfds, writefds, exceptfds, timeout);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_select(nfds, (fd_set*)readfds, (fd_set*)writefds, (fd_set*)exceptfds, (timeval*)timeout);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_select(JNIEnv *env, jobject thisObj,
 	jint nfds, jobject readfds, jobject writefds, jobject exceptfds, jint timeout_sec, jint timeout_usec)
 {
-	struct timeval _timeout;
+	struct zts_timeval _timeout;
 	_timeout.tv_sec  = timeout_sec;
 	_timeout.tv_usec = timeout_usec;
-	fd_set _readfds, _writefds, _exceptfds;   		
-	fd_set *r = NULL;
-	fd_set *w = NULL;
-	fd_set *e = NULL;
+	zts_fd_set _readfds, _writefds, _exceptfds;
+	zts_fd_set *r = NULL;
+	zts_fd_set *w = NULL;
+	zts_fd_set *e = NULL;
 	if (readfds) {
 		r = &_readfds;
 		ztfdset2fdset(env, nfds, readfds, &_readfds);
@@ -411,7 +404,10 @@ int zts_fcntl(int fd, int cmd, int flags)
 		translated_flags = 1;
 	}
 #endif
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_fcntl(fd, cmd, translated_flags);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_fcntl(fd, cmd, translated_flags);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_fcntl(
@@ -422,12 +418,24 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_fcntl(
 }
 #endif
 
+// TODO: JNI version
+int zts_poll(struct zts_pollfd *fds, nfds_t nfds, int timeout)
+{
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_poll((pollfd*)fds, nfds, timeout);
+}
+
 int zts_ioctl(int fd, unsigned long request, void *argp)
 {
 	if (!argp) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_ioctl(fd, request, argp);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_ioctl(fd, request, argp);
 }
 #ifdef SDK_JNI
 JNIEXPORT int JNICALL Java_com_zerotier_libzt_ZeroTier_ioctl(
@@ -435,13 +443,12 @@ JNIEXPORT int JNICALL Java_com_zerotier_libzt_ZeroTier_ioctl(
 {
 	int retval = ZTS_ERR_OK;
 	if (request == FIONREAD) {
-		// DEBUG_ERROR("FIONREAD");
 		int bytesRemaining = 0;
 		retval = zts_ioctl(fd, request, &bytesRemaining);	
 		// set value in general object
 		jclass c = env->GetObjectClass(argp);
 		if (!c) {
-			return ZTS_ERR_INVALID_ARG;
+			return ZTS_ERR_ARG;
 		}
 		jfieldID fid = env->GetFieldID(c, "integer", "I");
 		env->SetIntField(argp, fid, bytesRemaining);
@@ -449,7 +456,6 @@ JNIEXPORT int JNICALL Java_com_zerotier_libzt_ZeroTier_ioctl(
 	if (request == FIONBIO) {
 		// TODO: double check
 		int meaninglessVariable = 0;
-		// DEBUG_ERROR("FIONBIO");
 		retval = zts_ioctl(fd, request, &meaninglessVariable);		
 	}
 	return retval > -1 ? retval : -(zts_errno);
@@ -459,9 +465,12 @@ JNIEXPORT int JNICALL Java_com_zerotier_libzt_ZeroTier_ioctl(
 ssize_t zts_send(int fd, const void *buf, size_t len, int flags)
 {
 	if (!buf || len <= 0) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
+	}
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_send(fd, buf, len, flags);
+	return lwip_send(fd, buf, len, flags);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_send(
@@ -475,25 +484,28 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_send(
 #endif
 
 ssize_t zts_sendto(int fd, const void *buf, size_t len, int flags, 
-	const struct sockaddr *addr, socklen_t addrlen)
+	const struct zts_sockaddr *addr,zts_socklen_t addrlen)
 {
 	if (!addr || !buf || len <= 0) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
+	}
+	if (addrlen > (int)sizeof(struct zts_sockaddr_storage) || addrlen < (int)sizeof(struct zts_sockaddr_in)) {
+		return ZTS_ERR_ARG;
 	}
-	if (addrlen > (int)sizeof(struct sockaddr_storage) || addrlen < (int)sizeof(struct sockaddr_in)) {
-		return ZTS_ERR_INVALID_ARG;
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_sendto(fd, buf, len, flags, addr, addrlen);
+	return lwip_sendto(fd, buf, len, flags, (sockaddr*)addr, addrlen);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_sendto(
 	JNIEnv *env, jobject thisObj, jint fd, jbyteArray buf, jint flags, jobject addr)
 {
 	void *data = env->GetPrimitiveArrayCritical(buf, NULL);
-	struct sockaddr_storage ss;
+	struct zts_sockaddr_storage ss;
 	zta2ss(env, &ss, addr);
-	socklen_t addrlen = ss.ss_family == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
-	int retval = zts_sendto(fd, data, env->GetArrayLength(buf), flags, (struct sockaddr *)&ss, addrlen);
+	zts_socklen_t addrlen = ss.ss_family == ZTS_AF_INET ? sizeof(struct zts_sockaddr_in) : sizeof(struct zts_sockaddr_in6);
+	int retval = zts_sendto(fd, data, env->GetArrayLength(buf), flags, (struct zts_sockaddr *)&ss, addrlen);
 	env->ReleasePrimitiveArrayCritical(buf, data, 0);	 
 	return retval > -1 ? retval : -(zts_errno);
 }
@@ -501,7 +513,10 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_sendto(
 
 ssize_t zts_sendmsg(int fd, const struct msghdr *msg, int flags)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_sendmsg(fd, msg, flags);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_sendmsg(fd, msg, flags);
 }
 #ifdef SDK_JNI
 #endif
@@ -509,9 +524,12 @@ ssize_t zts_sendmsg(int fd, const struct msghdr *msg, int flags)
 ssize_t zts_recv(int fd, void *buf, size_t len, int flags)
 {
 	if (!buf) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
+	}
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_recv(fd, buf, len, flags);
+	return lwip_recv(fd, buf, len, flags);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_recv(JNIEnv *env, jobject thisObj,
@@ -525,49 +543,64 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_recv(JNIEnv *env, jobjec
 #endif
 
 ssize_t zts_recvfrom(int fd, void *buf, size_t len, int flags, 
-	struct sockaddr *addr, socklen_t *addrlen)
+	struct zts_sockaddr *addr, zts_socklen_t *addrlen)
 {
 	if (!buf) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
+	}
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_recvfrom(fd, buf, len, flags, addr, addrlen);
+	return lwip_recvfrom(fd, buf, len, flags, (sockaddr*)addr, (socklen_t*)addrlen);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_recvfrom(
 	JNIEnv *env, jobject thisObj, jint fd, jbyteArray buf, jint flags, jobject addr)
 {
-	socklen_t addrlen = sizeof(struct sockaddr_storage);
-	struct sockaddr_storage ss;
+	zts_socklen_t addrlen = sizeof(struct zts_sockaddr_storage);
+	struct zts_sockaddr_storage ss;
 	void *data = env->GetPrimitiveArrayCritical(buf, NULL);
-	int retval = zts_recvfrom(fd, data, env->GetArrayLength(buf), flags, (struct sockaddr *)&ss, &addrlen);
+	int retval = zts_recvfrom(fd, data, env->GetArrayLength(buf), flags, (struct zts_sockaddr *)&ss, &addrlen);
 	env->ReleasePrimitiveArrayCritical(buf, data, 0);
 	ss2zta(env, &ss, addr);	 
 	return retval > -1 ? retval : -(zts_errno);
 }
 #endif
 
+// TODO: JNI version
 ssize_t zts_recvmsg(int fd, struct msghdr *msg, int flags)
 {
-	// Not currently implemented by stack
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : ZTS_ERR_GENERAL;
+	if (!msg) {
+		return ZTS_ERR_ARG;
+	}
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_recvmsg(fd, msg, flags);
 }
 #ifdef SDK_JNI
 #endif
 
-int zts_read(int fd, void *buf, size_t len)
+ssize_t zts_read(int fd, void *buf, size_t len)
 {
 	if (!buf) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
+	}
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_read(fd, buf, len);
+	return lwip_read(fd, buf, len);
 }
-int zts_read_offset(int fd, void *buf, size_t offset, size_t len)
+ssize_t zts_read_offset(int fd, void *buf, size_t offset, size_t len)
 {
 	if (!buf) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
+	}
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
 	}
 	char *cbuf = (char*)buf;
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_read(fd, &(cbuf[offset]), len);
+	return lwip_read(fd, &(cbuf[offset]), len);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_read(JNIEnv *env, jobject thisObj,
@@ -596,12 +629,24 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_read_1length(JNIEnv *env
 }
 #endif
 
-int zts_write(int fd, const void *buf, size_t len)
+// TODO: JNI version
+ssize_t zts_readv(int s, const struct zts_iovec *iov, int iovcnt)
+{
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_readv(s, (iovec*)iov, iovcnt);
+}
+
+ssize_t zts_write(int fd, const void *buf, size_t len)
 {
 	if (!buf || len <= 0) {
-		return ZTS_ERR_INVALID_ARG;
+		return ZTS_ERR_ARG;
 	}
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_write(fd, buf, len);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_write(fd, buf, len);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_write__IB(JNIEnv *env, jobject thisObj,
@@ -628,9 +673,21 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_write_1byte(JNIEnv *env,
 }
 #endif
 
+// TODO: JNI version
+ssize_t zts_writev(int fd, const struct zts_iovec *iov, int iovcnt)
+{
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_writev(fd, (iovec*)iov, iovcnt);
+}
+
 int zts_shutdown(int fd, int how)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_shutdown(fd, how);
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return lwip_shutdown(fd, how);
 }
 #ifdef SDK_JNI
 JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_shutdown(
@@ -640,42 +697,213 @@ JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_shutdown(
 }
 #endif
 
-int zts_add_dns_nameserver(struct sockaddr *addr)
+int zts_add_dns_nameserver(struct zts_sockaddr *addr)
+{
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return ZTS_ERR_SERVICE; // TODO
+}
+#ifdef SDK_JNI
+#endif
+
+int zts_del_dns_nameserver(struct zts_sockaddr *addr)
+{
+	if (!(_serviceStateFlags & ZTS_STATE_NET_SERVICE_RUNNING)) {
+		return ZTS_ERR_SERVICE;
+	}
+	return ZTS_ERR_SERVICE; // TODO
+}
+#ifdef SDK_JNI
+#endif
+
+uint16_t zts_htons(uint16_t n)
+{
+	return lwip_htons(n);
+}
+
+uint32_t zts_htonl(uint32_t n)
+{
+	return lwip_htonl(n);
+}
+
+uint16_t zts_ntohs(uint16_t n)
+{
+	return lwip_htons(n);
+}
+
+uint32_t zts_ntohl(uint32_t n)
+{
+	return lwip_htonl(n);
+}
+
+const char *zts_inet_ntop(int af, const void *src, char *dst,zts_socklen_t size)
+{
+	return lwip_inet_ntop(af,src,dst,size);
+}
+
+int zts_inet_pton(int af, const char *src, void *dst)
+{
+	return lwip_inet_pton(af,src,dst);
+}
+
+uint32_t zts_inet_addr(const char *cp)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : -1; // TODO
+	return ipaddr_addr(cp);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Statistics                                                               //
+//////////////////////////////////////////////////////////////////////////////
+
+extern struct stats_ lwip_stats;
+
+int zts_get_all_stats(struct zts_stats *statsDest)
+{
+#if LWIP_STATS
+	if (!statsDest) {
+		return ZTS_ERR_ARG;
+	}
+	memset(statsDest, 0, sizeof(struct zts_stats));
+	// Copy lwIP stats
+	memcpy(&(statsDest->link), &(lwip_stats.link), sizeof(struct stats_proto));
+	memcpy(&(statsDest->etharp), &(lwip_stats.etharp), sizeof(struct stats_proto));
+	memcpy(&(statsDest->ip_frag), &(lwip_stats.ip_frag), sizeof(struct stats_proto));
+	memcpy(&(statsDest->ip), &(lwip_stats.ip), sizeof(struct stats_proto));
+	memcpy(&(statsDest->icmp), &(lwip_stats.icmp), sizeof(struct stats_proto));
+	//memcpy(&(statsDest->igmp), &(lwip_stats.igmp), sizeof(struct stats_igmp));
+	memcpy(&(statsDest->udp), &(lwip_stats.udp), sizeof(struct stats_proto));
+	memcpy(&(statsDest->tcp), &(lwip_stats.tcp), sizeof(struct stats_proto));
+	// mem omitted
+	// memp omitted
+	memcpy(&(statsDest->sys), &(lwip_stats.sys), sizeof(struct stats_sys));
+	memcpy(&(statsDest->ip6), &(lwip_stats.ip6), sizeof(struct stats_proto));
+	memcpy(&(statsDest->icmp6), &(lwip_stats.icmp6), sizeof(struct stats_proto));
+	memcpy(&(statsDest->ip6_frag), &(lwip_stats.ip6_frag), sizeof(struct stats_proto));
+	memcpy(&(statsDest->mld6), &(lwip_stats.mld6), sizeof(struct stats_igmp));
+	memcpy(&(statsDest->nd6), &(lwip_stats.nd6), sizeof(struct stats_proto));
+	memcpy(&(statsDest->ip_frag), &(lwip_stats.ip_frag), sizeof(struct stats_proto));
+	// mib2 omitted
+	// Copy ZT stats
+	// ...
+	return ZTS_ERR_OK;
+#else
+	return ZTS_ERR_NO_RESULT;
+#endif
 }
 #ifdef SDK_JNI
+	// No implementation for JNI
 #endif
 
-int zts_del_dns_nameserver(struct sockaddr *addr)
+int zts_get_protocol_stats(int protocolType, void *protoStatsDest)
 {
-	return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : -1; // TODO
+#if LWIP_STATS
+	if (!protoStatsDest) {
+		return ZTS_ERR_ARG;
+	}
+	memset(protoStatsDest, 0, sizeof(struct stats_proto));
+	switch (protocolType)
+	{
+		case ZTS_STATS_PROTOCOL_LINK:
+			memcpy(protoStatsDest, &(lwip_stats.link), sizeof(struct stats_proto));
+			break;
+		case ZTS_STATS_PROTOCOL_ETHARP:
+			memcpy(protoStatsDest, &(lwip_stats.etharp), sizeof(struct stats_proto));
+			break;
+		case ZTS_STATS_PROTOCOL_IP:
+			memcpy(protoStatsDest, &(lwip_stats.ip), sizeof(struct stats_proto));
+			break;
+		case ZTS_STATS_PROTOCOL_UDP:
+			memcpy(protoStatsDest, &(lwip_stats.udp), sizeof(struct stats_proto));
+			break;
+		case ZTS_STATS_PROTOCOL_TCP:
+			memcpy(protoStatsDest, &(lwip_stats.tcp), sizeof(struct stats_proto));
+			break;
+		case ZTS_STATS_PROTOCOL_ICMP:
+			memcpy(protoStatsDest, &(lwip_stats.icmp), sizeof(struct stats_proto));
+			break;
+		case ZTS_STATS_PROTOCOL_IP_FRAG:
+			memcpy(protoStatsDest, &(lwip_stats.ip_frag), sizeof(struct stats_proto));
+			break;
+		case ZTS_STATS_PROTOCOL_IP6:
+			memcpy(protoStatsDest, &(lwip_stats.ip6), sizeof(struct stats_proto));
+			break;
+		case ZTS_STATS_PROTOCOL_ICMP6:
+			memcpy(protoStatsDest, &(lwip_stats.icmp6), sizeof(struct stats_proto));
+			break;
+		case ZTS_STATS_PROTOCOL_IP6_FRAG:
+			memcpy(protoStatsDest, &(lwip_stats.ip6_frag), sizeof(struct stats_proto));
+			break;
+		default:
+			return ZTS_ERR_ARG;
+	}
+	return ZTS_ERR_OK;
+#else
+	return ZTS_ERR_NO_RESULT;
+#endif
 }
 #ifdef SDK_JNI
+JNIEXPORT jint JNICALL Java_com_zerotier_libzt_ZeroTier_get_1protocol_1stats(
+	JNIEnv *env, jobject thisObj, jint protocolType, jobject protoStatsObj)
+{
+	struct stats_proto stats;
+	int retval = zts_get_protocol_stats(protocolType, &stats);
+	// Copy stats into Java object
+	jclass c = env->GetObjectClass(protoStatsObj);
+	if (!c) {
+		return ZTS_ERR_ARG;
+	}
+	jfieldID fid;
+	fid = env->GetFieldID(c, "xmit", "I");
+	env->SetIntField(protoStatsObj, fid, stats.xmit);
+	fid = env->GetFieldID(c, "recv", "I");
+	env->SetIntField(protoStatsObj, fid, stats.recv);
+	fid = env->GetFieldID(c, "fw", "I");
+	env->SetIntField(protoStatsObj, fid, stats.fw);
+	fid = env->GetFieldID(c, "drop", "I");
+	env->SetIntField(protoStatsObj, fid, stats.drop);
+	fid = env->GetFieldID(c, "chkerr", "I");
+	env->SetIntField(protoStatsObj, fid, stats.chkerr);
+	fid = env->GetFieldID(c, "lenerr", "I");
+	env->SetIntField(protoStatsObj, fid, stats.lenerr);
+	fid = env->GetFieldID(c, "memerr", "I");
+	env->SetIntField(protoStatsObj, fid, stats.memerr);
+	fid = env->GetFieldID(c, "rterr", "I");
+	env->SetIntField(protoStatsObj, fid, stats.rterr);
+	fid = env->GetFieldID(c, "proterr", "I");
+	env->SetIntField(protoStatsObj, fid, stats.proterr);
+	fid = env->GetFieldID(c, "opterr", "I");
+	env->SetIntField(protoStatsObj, fid, stats.opterr);
+	fid = env->GetFieldID(c, "err", "I");
+	env->SetIntField(protoStatsObj, fid, stats.err);
+	fid = env->GetFieldID(c, "cachehit", "I");
+	env->SetIntField(protoStatsObj, fid, stats.cachehit);
+	return retval;
+}
 #endif
 
 #ifdef SDK_JNI
-void ztfdset2fdset(JNIEnv *env, int nfds, jobject src_ztfd_set, fd_set *dest_fd_set)
+void ztfdset2fdset(JNIEnv *env, int nfds, jobject src_ztfd_set, zts_fd_set *dest_fd_set)
 {
 	jclass c = env->GetObjectClass(src_ztfd_set);
 	if (!c) {
 		return;
 	}
-	FD_ZERO(dest_fd_set);
+	ZTS_FD_ZERO(dest_fd_set);
 	jfieldID fid = env->GetFieldID(c, "fds_bits", "[B");
 	jobject fdData = env->GetObjectField (src_ztfd_set, fid);
 	jbyteArray * arr = reinterpret_cast<jbyteArray*>(&fdData);
 	char *data = (char*)env->GetByteArrayElements(*arr, NULL);
 	for (int i=0; i<nfds; i++) {
 		if (data[i] == 0x01)  {
-			FD_SET(i, dest_fd_set);
+			ZTS_FD_SET(i, dest_fd_set);
 		}
 	}
 	env->ReleaseByteArrayElements(*arr, (jbyte*)data, 0);
 	return;
 }
 
-void fdset2ztfdset(JNIEnv *env, int nfds, fd_set *src_fd_set, jobject dest_ztfd_set)
+void fdset2ztfdset(JNIEnv *env, int nfds, zts_fd_set *src_fd_set, jobject dest_ztfd_set)
 {
 	jclass c = env->GetObjectClass(dest_ztfd_set);
 	if (!c) {
@@ -686,7 +914,7 @@ void fdset2ztfdset(JNIEnv *env, int nfds, fd_set *src_fd_set, jobject dest_ztfd_
 	jbyteArray * arr = reinterpret_cast<jbyteArray*>(&fdData);
 	char *data = (char*)env->GetByteArrayElements(*arr, NULL);
 	for (int i=0; i<nfds; i++) {
-		if (FD_ISSET(i, src_fd_set)) {
+		if (ZTS_FD_ISSET(i, src_fd_set)) {
 			data[i] = 0x01;
 		}
 	}
@@ -698,15 +926,15 @@ void fdset2ztfdset(JNIEnv *env, int nfds, fd_set *src_fd_set, jobject dest_ztfd_
 // Helpers (for moving data across the JNI barrier)                         //
 //////////////////////////////////////////////////////////////////////////////
 
-void ss2zta(JNIEnv *env, struct sockaddr_storage *ss, jobject addr)
+void ss2zta(JNIEnv *env, struct zts_sockaddr_storage *ss, jobject addr)
 {
 	jclass c = env->GetObjectClass(addr);
 	if (!c) {
 		return;
 	}
-	if(ss->ss_family == AF_INET)
+	if(ss->ss_family == ZTS_AF_INET)
 	{
-		struct sockaddr_in *in4 = (struct sockaddr_in*)ss;
+		struct zts_sockaddr_in *in4 = (struct zts_sockaddr_in*)ss;
 		jfieldID fid = env->GetFieldID(c, "_port", "I");
 		env->SetIntField(addr, fid, lwip_ntohs(in4->sin_port));
 		fid = env->GetFieldID(c,"_family", "I");
@@ -720,9 +948,9 @@ void ss2zta(JNIEnv *env, struct sockaddr_storage *ss, jobject addr)
 
 		return;
 	}
-	if(ss->ss_family == AF_INET6)
+	if(ss->ss_family == ZTS_AF_INET6)
 	{
-		struct sockaddr_in6 *in6 = (struct sockaddr_in6*)ss;
+		struct zts_sockaddr_in6 *in6 = (struct zts_sockaddr_in6*)ss;
 		jfieldID fid = env->GetFieldID(c, "_port", "I");
 		env->SetIntField(addr, fid, lwip_ntohs(in6->sin6_port));
 		fid = env->GetFieldID(c,"_family", "I");
@@ -737,7 +965,7 @@ void ss2zta(JNIEnv *env, struct sockaddr_storage *ss, jobject addr)
 	}
 }
 
-void zta2ss(JNIEnv *env, struct sockaddr_storage *ss, jobject addr)
+void zta2ss(JNIEnv *env, struct zts_sockaddr_storage *ss, jobject addr)
 {
 	jclass c = env->GetObjectClass(addr);
 	if (!c) {
@@ -745,12 +973,12 @@ void zta2ss(JNIEnv *env, struct sockaddr_storage *ss, jobject addr)
 	}
 	jfieldID fid = env->GetFieldID(c, "_family", "I");
 	int family = env->GetIntField(addr, fid);
-	if (family == AF_INET)
+	if (family == ZTS_AF_INET)
 	{
-		struct sockaddr_in *in4 = (struct sockaddr_in*)ss;
+		struct zts_sockaddr_in *in4 = (struct zts_sockaddr_in*)ss;
 		fid = env->GetFieldID(c, "_port", "I");
 		in4->sin_port = lwip_htons(env->GetIntField(addr, fid));
-		in4->sin_family = AF_INET;
+		in4->sin_family = ZTS_AF_INET;
 		fid = env->GetFieldID(c, "_ip4", "[B");
 		jobject ipData = env->GetObjectField (addr, fid);
 		jbyteArray * arr = reinterpret_cast<jbyteArray*>(&ipData);
@@ -759,13 +987,13 @@ void zta2ss(JNIEnv *env, struct sockaddr_storage *ss, jobject addr)
 		env->ReleaseByteArrayElements(*arr, (jbyte*)data, 0);
 		return;
 	}
-	if (family == AF_INET6)
+	if (family == ZTS_AF_INET6)
 	{
-		struct sockaddr_in6 *in6 = (struct sockaddr_in6*)ss;
+		struct zts_sockaddr_in6 *in6 = (struct zts_sockaddr_in6*)ss;
 		jfieldID fid = env->GetFieldID(c, "_port", "I");
 		in6->sin6_port = lwip_htons(env->GetIntField(addr, fid));
 		fid = env->GetFieldID(c,"_family", "I");
-		in6->sin6_family = AF_INET6;
+		in6->sin6_family = ZTS_AF_INET6;
 		fid = env->GetFieldID(c, "_ip6", "[B");
 		jobject ipData = env->GetObjectField (addr, fid);
 		jbyteArray * arr = reinterpret_cast<jbyteArray*>(&ipData);