Merge branch 'dev' into netbsd-support

15 files changed, 975 insertions, 366 deletions

diff --git a/java/jni/Android.mk b/java/jni/Android.mk
index c563879c..8cda2474 100644
--- a/java/jni/Android.mk
+++ b/java/jni/Android.mk
@@ -3,22 +3,28 @@ LOCAL_PATH := $(call my-dir)
 include $(CLEAR_VARS)
 
 LOCAL_MODULE := ZeroTierOneJNI
-LOCAL_C_INCLUDES := $(ZT1)/include
-LOCAL_C_INCLUDES += $(ZT1)/node
-LOCAL_LDLIBS := -llog
+LOCAL_C_INCLUDES := \
+    $(ZT1)/include \
+    $(ZT1)/node \
+    $(ZT1)/osdep \
+    $(ZT1)/ext/miniupnpc \
+    $(ZT1)/ext/libnatpmp
+
+LOCAL_LDLIBS := -llog -latomic
 # LOCAL_CFLAGS := -g
 
+LOCAL_CFLAGS := -DZT_USE_MINIUPNPC
+
 # ZeroTierOne SDK source files
 LOCAL_SRC_FILES := \
-	$(ZT1)/ext/lz4/lz4.c \
-	$(ZT1)/ext/json-parser/json.c \
-	$(ZT1)/ext/http-parser/http_parser.c \
-	$(ZT1)/node/C25519.cpp \
+    $(ZT1)/node/C25519.cpp \
+	$(ZT1)/node/Capability.cpp \
 	$(ZT1)/node/CertificateOfMembership.cpp \
-	$(ZT1)/node/DeferredPackets.cpp \
+	$(ZT1)/node/CertificateOfOwnership.cpp \
 	$(ZT1)/node/Identity.cpp \
 	$(ZT1)/node/IncomingPacket.cpp \
 	$(ZT1)/node/InetAddress.cpp \
+	$(ZT1)/node/Membership.cpp \
 	$(ZT1)/node/Multicaster.cpp \
 	$(ZT1)/node/Network.cpp \
 	$(ZT1)/node/NetworkConfig.cpp \
@@ -28,14 +34,35 @@ LOCAL_SRC_FILES := \
 	$(ZT1)/node/Path.cpp \
 	$(ZT1)/node/Peer.cpp \
 	$(ZT1)/node/Poly1305.cpp \
+	$(ZT1)/node/Revocation.cpp \
 	$(ZT1)/node/Salsa20.cpp \
 	$(ZT1)/node/SelfAwareness.cpp \
 	$(ZT1)/node/SHA512.cpp \
 	$(ZT1)/node/Switch.cpp \
+	$(ZT1)/node/Tag.cpp \
 	$(ZT1)/node/Topology.cpp \
+	$(ZT1)/node/Trace.cpp \
 	$(ZT1)/node/Utils.cpp \
-	$(ZT1)/osdep/Http.cpp \
-	$(ZT1)/osdep/OSUtils.cpp
+	$(ZT1)/osdep/OSUtils.cpp \
+	$(ZT1)/osdep/PortMapper.cpp
+
+# libminiupnpc and libnatpmp files
+LOCAL_SRC_FILES += \
+	$(ZT1)/ext/miniupnpc/connecthostport.c \
+	$(ZT1)/ext/miniupnpc/igd_desc_parse.c \
+	$(ZT1)/ext/miniupnpc/minisoap.c \
+	$(ZT1)/ext/miniupnpc/minissdpc.c \
+	$(ZT1)/ext/miniupnpc/miniupnpc.c \
+	$(ZT1)/ext/miniupnpc/miniwget.c \
+	$(ZT1)/ext/miniupnpc/minixml.c \
+	$(ZT1)/ext/miniupnpc/portlistingparse.c \
+	$(ZT1)/ext/miniupnpc/receivedata.c \
+	$(ZT1)/ext/miniupnpc/upnpcommands.c \
+	$(ZT1)/ext/miniupnpc/upnpdev.c \
+	$(ZT1)/ext/miniupnpc/upnperrors.c \
+	$(ZT1)/ext/miniupnpc/upnpreplyparse.c \
+	$(ZT1)/ext/libnatpmp/natpmp.c \
+	$(ZT1)/ext/libnatpmp/getgateway.c
 
 # JNI Files
 LOCAL_SRC_FILES += \
diff --git a/java/jni/Application.mk b/java/jni/Application.mk
index 6950c0e6..f5a87ac7 100644
--- a/java/jni/Application.mk
+++ b/java/jni/Application.mk
@@ -1,5 +1,5 @@
 # NDK_TOOLCHAIN_VERSION := clang3.5
-APP_STL := gnustl_static
-APP_CPPFLAGS := -O3 -fPIC -fPIE -Wall -fstack-protector -fexceptions -fno-strict-aliasing -Wno-deprecated-register -DZT_NO_TYPE_PUNNING=1
+APP_STL := c++_static
+APP_CPPFLAGS := -Wall -fstack-protector -fexceptions -fno-strict-aliasing -Wno-deprecated-register -DZT_NO_TYPE_PUNNING=1
 APP_PLATFORM := android-14
 APP_ABI := all
diff --git a/java/jni/ZT_jniutils.cpp b/java/jni/ZT_jniutils.cpp
index 512bf839..c52a2066 100644
--- a/java/jni/ZT_jniutils.cpp
+++ b/java/jni/ZT_jniutils.cpp
@@ -1,3 +1,21 @@
+/*
+ * ZeroTier One - Network Virtualization Everywhere
+ * Copyright (C) 2011-2016  ZeroTier, Inc.  https://www.zerotier.com/
+ *
+ * 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/>.
+ */
+
 #include "ZT_jniutils.h"
 #include "ZT_jnilookup.h"
 #include <string>
@@ -12,7 +30,7 @@ extern "C" {
 jobject createResultObject(JNIEnv *env, ZT_ResultCode code)
 {
     jclass resultClass = NULL;
-    
+
     jobject resultObject = NULL;
 
     resultClass = lookup.findClass("com/zerotier/sdk/ResultCode");
@@ -49,14 +67,14 @@ jobject createResultObject(JNIEnv *env, ZT_ResultCode code)
     }
 
     jfieldID enumField = lookup.findStaticField(resultClass, fieldName.c_str(), "Lcom/zerotier/sdk/ResultCode;");
-    if(env->ExceptionCheck() || enumField == NULL) 
+    if(env->ExceptionCheck() || enumField == NULL)
     {
         LOGE("Error on FindStaticField");
         return NULL;
     }
 
     resultObject = env->GetStaticObjectField(resultClass, enumField);
-    if(env->ExceptionCheck() || resultObject == NULL) 
+    if(env->ExceptionCheck() || resultObject == NULL)
     {
         LOGE("Error on GetStaticObjectField");
     }
@@ -136,6 +154,11 @@ jobject createEvent(JNIEnv *env, ZT_Event event)
     case ZT_EVENT_TRACE:
         fieldName = "EVENT_TRACE";
         break;
+    case ZT_EVENT_USER_MESSAGE:
+        break;
+    case ZT_EVENT_REMOTE_TRACE:
+    default:
+        break;
     }
 
     jfieldID enumField = lookup.findStaticField(eventClass, fieldName.c_str(), "Lcom/zerotier/sdk/Event;");
@@ -162,11 +185,11 @@ jobject createPeerRole(JNIEnv *env, ZT_PeerRole role)
     case ZT_PEER_ROLE_LEAF:
         fieldName = "PEER_ROLE_LEAF";
         break;
-    case ZT_PEER_ROLE_RELAY:
-        fieldName = "PEER_ROLE_RELAY";
+    case ZT_PEER_ROLE_MOON:
+        fieldName = "PEER_ROLE_MOON";
         break;
-    case ZT_PEER_ROLE_ROOT:
-        fieldName = "PEER_ROLE_ROOTS";
+    case ZT_PEER_ROLE_PLANET:
+        fieldName = "PEER_ROLE_PLANET";
         break;
     }
 
@@ -313,11 +336,20 @@ jobject newInetSocketAddress(JNIEnv *env, const sockaddr_storage &addr)
         return NULL;
     }
 
-    jobject inetAddressObject = newInetAddress(env, addr);
+    jobject inetAddressObject = NULL;
 
-    if(env->ExceptionCheck() || inetAddressObject == NULL)
+    if(addr.ss_family != 0)
+    {
+        inetAddressObject = newInetAddress(env, addr);
+
+        if(env->ExceptionCheck() || inetAddressObject == NULL)
+        {
+            LOGE("Error creating new inet address");
+            return NULL;
+        }
+    }
+    else
     {
-        LOGE("Error creating new inet address");
         return NULL;
     }
 
@@ -350,10 +382,9 @@ jobject newInetSocketAddress(JNIEnv *env, const sockaddr_storage &addr)
         break;
         default:
         {
-            LOGE("ERROR:  addr.ss_family is not set or unknown");
             break;
         }
-    };
+    }
 
 
     jobject inetSocketAddressObject = env->NewObject(inetSocketAddressClass, inetSocketAddress_constructor, inetAddressObject, port);
@@ -371,7 +402,6 @@ jobject newPeerPhysicalPath(JNIEnv *env, const ZT_PeerPhysicalPath &ppp)
     jfieldID addressField = NULL;
     jfieldID lastSendField = NULL;
     jfieldID lastReceiveField = NULL;
-    jfieldID activeField = NULL;
     jfieldID preferredField = NULL;
 
     jmethodID ppp_constructor = NULL;
@@ -404,13 +434,6 @@ jobject newPeerPhysicalPath(JNIEnv *env, const ZT_PeerPhysicalPath &ppp)
         return NULL;
     }
 
-    activeField = lookup.findField(pppClass, "active", "Z");
-    if(env->ExceptionCheck() || activeField == NULL)
-    {
-        LOGE("Error finding active field");
-        return NULL;
-    }
-
     preferredField = lookup.findField(pppClass, "preferred", "Z");
     if(env->ExceptionCheck() || preferredField == NULL)
     {
@@ -441,7 +464,6 @@ jobject newPeerPhysicalPath(JNIEnv *env, const ZT_PeerPhysicalPath &ppp)
     env->SetObjectField(pppObject, addressField, addressObject);
     env->SetLongField(pppObject, lastSendField, ppp.lastSend);
     env->SetLongField(pppObject, lastReceiveField, ppp.lastReceive);
-    env->SetBooleanField(pppObject, activeField, ppp.active);
     env->SetBooleanField(pppObject, preferredField, ppp.preferred);
 
     if(env->ExceptionCheck()) {
@@ -451,15 +473,13 @@ jobject newPeerPhysicalPath(JNIEnv *env, const ZT_PeerPhysicalPath &ppp)
     return pppObject;
 }
 
-jobject newPeer(JNIEnv *env, const ZT_Peer &peer) 
+jobject newPeer(JNIEnv *env, const ZT_Peer &peer)
 {
     LOGV("newPeer called");
 
     jclass peerClass = NULL;
 
     jfieldID addressField = NULL;
-    jfieldID lastUnicastFrameField = NULL;
-    jfieldID lastMulticastFrameField = NULL;
     jfieldID versionMajorField = NULL;
     jfieldID versionMinorField = NULL;
     jfieldID versionRevField = NULL;
@@ -483,20 +503,6 @@ jobject newPeer(JNIEnv *env, const ZT_Peer &peer)
         return NULL;
     }
 
-    lastUnicastFrameField = lookup.findField(peerClass, "lastUnicastFrame", "J");
-    if(env->ExceptionCheck() || lastUnicastFrameField == NULL)
-    {
-        LOGE("Error finding lastUnicastFrame field of Peer object");
-        return NULL;
-    }
-
-    lastMulticastFrameField = lookup.findField(peerClass, "lastMulticastFrame", "J");
-    if(env->ExceptionCheck() || lastMulticastFrameField == NULL)
-    {
-        LOGE("Error finding lastMulticastFrame field of Peer object");
-        return NULL;
-    }
-
     versionMajorField = lookup.findField(peerClass, "versionMajor", "I");
     if(env->ExceptionCheck() || versionMajorField == NULL)
     {
@@ -554,8 +560,6 @@ jobject newPeer(JNIEnv *env, const ZT_Peer &peer)
     }
 
     env->SetLongField(peerObject, addressField, (jlong)peer.address);
-    env->SetLongField(peerObject, lastUnicastFrameField, (jlong)peer.lastUnicastFrame);
-    env->SetLongField(peerObject, lastMulticastFrameField, (jlong)peer.lastMulticastFrame);
     env->SetIntField(peerObject, versionMajorField, peer.versionMajor);
     env->SetIntField(peerObject, versionMinorField, peer.versionMinor);
     env->SetIntField(peerObject, versionRevField, peer.versionRev);
@@ -571,7 +575,7 @@ jobject newPeer(JNIEnv *env, const ZT_Peer &peer)
 
     jobjectArray arrayObject = env->NewObjectArray(
         peer.pathCount, peerPhysicalPathClass, NULL);
-    if(env->ExceptionCheck() || arrayObject == NULL) 
+    if(env->ExceptionCheck() || arrayObject == NULL)
     {
         LOGE("Error creating PeerPhysicalPath[] array");
         return NULL;
@@ -609,6 +613,7 @@ jobject newNetworkConfig(JNIEnv *env, const ZT_VirtualNetworkConfig &vnetConfig)
     jfieldID portErrorField = NULL;
     jfieldID netconfRevisionField = NULL;
     jfieldID assignedAddressesField = NULL;
+    jfieldID routesField = NULL;
 
     vnetConfigClass = lookup.findClass("com/zerotier/sdk/VirtualNetworkConfig");
     if(vnetConfigClass == NULL)
@@ -709,13 +714,22 @@ jobject newNetworkConfig(JNIEnv *env, const ZT_VirtualNetworkConfig &vnetConfig)
         return NULL;
     }
 
-    assignedAddressesField = lookup.findField(vnetConfigClass, "assignedAddresses", "[Ljava/net/InetSocketAddress;");
+    assignedAddressesField = lookup.findField(vnetConfigClass, "assignedAddresses",
+        "[Ljava/net/InetSocketAddress;");
     if(env->ExceptionCheck() || assignedAddressesField == NULL)
     {
         LOGE("Error getting assignedAddresses field");
         return NULL;
     }
 
+    routesField = lookup.findField(vnetConfigClass, "routes",
+        "[Lcom/zerotier/sdk/VirtualNetworkRoute;");
+    if(env->ExceptionCheck() || routesField == NULL)
+    {
+        LOGE("Error getting routes field");
+        return NULL;
+    }
+
     env->SetLongField(vnetConfigObj, nwidField, vnetConfig.nwid);
     env->SetLongField(vnetConfigObj, macField, vnetConfig.mac);
     jstring nameStr = env->NewStringUTF(vnetConfig.name);
@@ -773,6 +787,34 @@ jobject newNetworkConfig(JNIEnv *env, const ZT_VirtualNetworkConfig &vnetConfig)
 
     env->SetObjectField(vnetConfigObj, assignedAddressesField, assignedAddrArrayObj);
 
+    jclass virtualNetworkRouteClass = lookup.findClass("com/zerotier/sdk/VirtualNetworkRoute");
+    if(env->ExceptionCheck() || virtualNetworkRouteClass == NULL)
+    {
+        LOGE("Error finding VirtualNetworkRoute class");
+        return NULL;
+    }
+
+    jobjectArray routesArrayObj = env->NewObjectArray(
+        vnetConfig.routeCount, virtualNetworkRouteClass, NULL);
+    if(env->ExceptionCheck() || routesArrayObj == NULL)
+    {
+        LOGE("Error creating VirtualNetworkRoute[] array");
+        return NULL;
+    }
+
+    for(unsigned int i = 0; i < vnetConfig.routeCount; ++i)
+    {
+        jobject routeObj = newVirtualNetworkRoute(env, vnetConfig.routes[i]);
+        env->SetObjectArrayElement(routesArrayObj, i, routeObj);
+        if(env->ExceptionCheck())
+        {
+            LOGE("Error assigning VirtualNetworkRoute to array");
+            return NULL;
+        }
+    }
+
+    env->SetObjectField(vnetConfigObj, routesField, routesArrayObj);
+
     return vnetConfigObj;
 }
 
@@ -831,6 +873,72 @@ jobject newVersion(JNIEnv *env, int major, int minor, int rev)
     return versionObj;
 }
 
+jobject newVirtualNetworkRoute(JNIEnv *env, const ZT_VirtualNetworkRoute &route)
+{
+    jclass virtualNetworkRouteClass = NULL;
+    jmethodID routeConstructor = NULL;
+
+    virtualNetworkRouteClass = lookup.findClass("com/zerotier/sdk/VirtualNetworkRoute");
+    if(env->ExceptionCheck() || virtualNetworkRouteClass == NULL)
+    {
+        return NULL;
+    }
+
+    routeConstructor = lookup.findMethod(virtualNetworkRouteClass, "<init>", "()V");
+    if(env->ExceptionCheck() || routeConstructor == NULL)
+    {
+        return NULL;
+    }
+
+    jobject routeObj = env->NewObject(virtualNetworkRouteClass, routeConstructor);
+    if(env->ExceptionCheck() || routeObj == NULL)
+    {
+        return NULL;
+    }
+
+    jfieldID targetField = NULL;
+    jfieldID viaField = NULL;
+    jfieldID flagsField = NULL;
+    jfieldID metricField = NULL;
+
+    targetField = lookup.findField(virtualNetworkRouteClass, "target",
+        "Ljava/net/InetSocketAddress;");
+    if(env->ExceptionCheck() || targetField == NULL)
+    {
+        return NULL;
+    }
+
+    viaField = lookup.findField(virtualNetworkRouteClass, "via",
+        "Ljava/net/InetSocketAddress;");
+    if(env->ExceptionCheck() || targetField == NULL)
+    {
+        return NULL;
+    }
+
+    flagsField = lookup.findField(virtualNetworkRouteClass, "flags", "I");
+    if(env->ExceptionCheck() || flagsField == NULL)
+    {
+        return NULL;
+    }
+
+    metricField = lookup.findField(virtualNetworkRouteClass, "metric", "I");
+    if(env->ExceptionCheck() || metricField == NULL)
+    {
+        return NULL;
+    }
+
+    jobject targetObj = newInetSocketAddress(env, route.target);
+    jobject viaObj = newInetSocketAddress(env, route.via);
+
+    env->SetObjectField(routeObj, targetField, targetObj);
+    env->SetObjectField(routeObj, viaField, viaObj);
+    env->SetIntField(routeObj, flagsField, (jint)route.flags);
+    env->SetIntField(routeObj, metricField, (jint)route.metric);
+
+    return routeObj;
+}
+
 #ifdef __cplusplus
 }
-#endif
\ No newline at end of file
+#endif
+
diff --git a/java/jni/ZT_jniutils.h b/java/jni/ZT_jniutils.h
index 34dfc471..56b63179 100644
--- a/java/jni/ZT_jniutils.h
+++ b/java/jni/ZT_jniutils.h
@@ -1,3 +1,21 @@
+/*
+ * ZeroTier One - Network Virtualization Everywhere
+ * Copyright (C) 2011-2016  ZeroTier, Inc.  https://www.zerotier.com/
+ *
+ * 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/>.
+ */
+ 
 #ifndef ZT_jniutils_h_
 #define ZT_jniutils_h_
 #include <stdio.h>
@@ -10,17 +28,31 @@ extern "C" {
 
 #define LOG_TAG "ZeroTierOneJNI"
 
-#if __ANDROID__
+#if defined(__ANDROID__)
+
 #include <android/log.h>
-#define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
-#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__))
-#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
-#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))
+
+    #if !defined(NDEBUG)
+        #define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
+        #define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
+    #else
+        #define LOGV(...)
+        #define LOGD(...)
+    #endif
+
+    #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__))
+    #define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))
 #else
-#define LOGV(...) fprintf(stdout, __VA_ARGS__)
-#define LOGI(...) fprintf(stdout, __VA_ARGS__)
-#define LOGD(...) fprintf(stdout, __VA_ARGS__)
-#define LOGE(...) fprintf(stdout, __VA_ARGS__)
+    #if !defined(NDEBUG)
+        #define LOGV(...) fprintf(stdout, __VA_ARGS__)
+        #define LOGD(...) fprintf(stdout, __VA_ARGS__)
+    #else
+        #define LOGV(...)
+        #define LOGD(...)
+    #endif
+
+    #define LOGI(...) fprintf(stdout, __VA_ARGS__)
+    #define LOGE(...) fprintf(stdout, __VA_ARGS__)
 #endif
 
 jobject createResultObject(JNIEnv *env, ZT_ResultCode code);
@@ -42,6 +74,8 @@ jobject newNetworkConfig(JNIEnv *env, const ZT_VirtualNetworkConfig &config);
 
 jobject newVersion(JNIEnv *env, int major, int minor, int rev);
 
+jobject newVirtualNetworkRoute(JNIEnv *env, const ZT_VirtualNetworkRoute &route);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/java/jni/com_zerotierone_sdk_Node.cpp b/java/jni/com_zerotierone_sdk_Node.cpp
index 4d9a2102..9a36e99b 100644
--- a/java/jni/com_zerotierone_sdk_Node.cpp
+++ b/java/jni/com_zerotierone_sdk_Node.cpp
@@ -32,6 +32,8 @@
 #include <ZeroTierOne.h>
 #include "Mutex.hpp"
 
+#include "PortMapper.hpp"
+
 #include <map>
 #include <string>
 #include <assert.h>
@@ -56,7 +58,13 @@ namespace {
             , eventListener(NULL)
             , frameListener(NULL)
             , configListener(NULL)
-        {}
+            , pathChecker(NULL)
+            , callbacks(NULL)
+            , portMapper(NULL)
+        {
+            callbacks = (ZT_Node_Callbacks*)malloc(sizeof(ZT_Node_Callbacks));
+            memset(callbacks, 0, sizeof(ZT_Node_Callbacks));
+        }
 
         ~JniRef()
         {
@@ -69,9 +77,16 @@ namespace {
             env->DeleteGlobalRef(eventListener);
             env->DeleteGlobalRef(frameListener);
             env->DeleteGlobalRef(configListener);
+            env->DeleteGlobalRef(pathChecker);
+
+            free(callbacks);
+            callbacks = NULL;
+
+            delete portMapper;
+            portMapper = NULL;
         }
 
-        uint64_t id;
+        int64_t id;
 
         JavaVM *jvm;
 
@@ -83,12 +98,18 @@ namespace {
         jobject eventListener;
         jobject frameListener;
         jobject configListener;
+        jobject pathChecker;
+
+        ZT_Node_Callbacks *callbacks;
+
+        ZeroTier::PortMapper *portMapper;
     };
 
 
     int VirtualNetworkConfigFunctionCallback(
         ZT_Node *node,
         void *userData,
+        void *threadData,
         uint64_t nwid,
         void **,
         enum ZT_VirtualNetworkConfigOperation operation,
@@ -99,6 +120,11 @@ namespace {
         JNIEnv *env = NULL;
         ref->jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
 
+        if (ref->configListener == NULL) {
+            LOGE("configListener is NULL");
+            return -1;
+        }
+
         jclass configListenerClass = env->GetObjectClass(ref->configListener);
         if(configListenerClass == NULL)
         {
@@ -130,13 +156,14 @@ namespace {
         }
 
         return env->CallIntMethod(
-            ref->configListener, 
-            configListenerCallbackMethod, 
+            ref->configListener,
+            configListenerCallbackMethod,
             (jlong)nwid, operationObject, networkConfigObject);
     }
 
     void VirtualNetworkFrameFunctionCallback(ZT_Node *node,
         void *userData,
+        void *threadData,
         uint64_t nwid,
         void**,
         uint64_t sourceMac,
@@ -147,13 +174,19 @@ namespace {
         unsigned int frameLength)
     {
         LOGV("VirtualNetworkFrameFunctionCallback");
+#ifndef NDEBUG
         unsigned char* local = (unsigned char*)frameData;
         LOGV("Type Bytes: 0x%02x%02x", local[12], local[13]);
+#endif
         JniRef *ref = (JniRef*)userData;
         assert(ref->node == node);
         JNIEnv *env = NULL;
         ref->jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
 
+        if (ref->frameListener == NULL) {
+            LOGE("frameListener is NULL");
+            return;
+        }
 
         jclass frameListenerClass = env->GetObjectClass(ref->frameListener);
         if(env->ExceptionCheck() || frameListenerClass == NULL)
@@ -194,109 +227,232 @@ namespace {
 
     void EventCallback(ZT_Node *node,
         void *userData,
-        enum ZT_Event event, 
-        const void *data)
-    {
+        void *threadData,
+        enum ZT_Event event,
+        const void *data) {
         LOGV("EventCallback");
-        JniRef *ref = (JniRef*)userData;
-        if(ref->node != node && event != ZT_EVENT_UP)
-        {
+        JniRef *ref = (JniRef *) userData;
+        if (ref->node != node && event != ZT_EVENT_UP) {
             LOGE("Nodes not equal. ref->node %p, node %p. Event: %d", ref->node, node, event);
             return;
         }
         JNIEnv *env = NULL;
-        ref->jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
+        ref->jvm->GetEnv((void **) &env, JNI_VERSION_1_6);
 
+        if (ref->eventListener == NULL) {
+            LOGE("eventListener is NULL");
+            return;
+        }
 
         jclass eventListenerClass = env->GetObjectClass(ref->eventListener);
-        if(eventListenerClass == NULL)
-        {
+        if (eventListenerClass == NULL) {
             LOGE("Couldn't class for EventListener instance");
             return;
         }
 
         jmethodID onEventMethod = lookup.findMethod(eventListenerClass,
-            "onEvent", "(Lcom/zerotier/sdk/Event;)V");
-        if(onEventMethod == NULL)
-        {
+                                                    "onEvent", "(Lcom/zerotier/sdk/Event;)V");
+        if (onEventMethod == NULL) {
             LOGE("Couldn't find onEvent method");
             return;
         }
 
         jmethodID onTraceMethod = lookup.findMethod(eventListenerClass,
-            "onTrace", "(Ljava/lang/String;)V");
-        if(onTraceMethod == NULL)
-        {
+                                                    "onTrace", "(Ljava/lang/String;)V");
+        if (onTraceMethod == NULL) {
             LOGE("Couldn't find onTrace method");
             return;
         }
 
         jobject eventObject = createEvent(env, event);
-        if(eventObject == NULL)
-        {
+        if (eventObject == NULL) {
             return;
         }
 
-        switch(event)
-        {
-        case ZT_EVENT_UP:
-        {
-            LOGD("Event Up");
-            env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
-            break;
+        switch (event) {
+            case ZT_EVENT_UP: {
+                LOGD("Event Up");
+                env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
+                break;
+            }
+            case ZT_EVENT_OFFLINE: {
+                LOGD("Event Offline");
+                env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
+                break;
+            }
+            case ZT_EVENT_ONLINE: {
+                LOGD("Event Online");
+                env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
+                break;
+            }
+            case ZT_EVENT_DOWN: {
+                LOGD("Event Down");
+                env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
+                break;
+            }
+            case ZT_EVENT_FATAL_ERROR_IDENTITY_COLLISION: {
+                LOGV("Identity Collision");
+                // call onEvent()
+                env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
+            }
+                break;
+            case ZT_EVENT_TRACE: {
+                LOGV("Trace Event");
+                // call onTrace()
+                if (data != NULL) {
+                    const char *message = (const char *) data;
+                    jstring messageStr = env->NewStringUTF(message);
+                    env->CallVoidMethod(ref->eventListener, onTraceMethod, messageStr);
+                }
+            }
+                break;
+            case ZT_EVENT_USER_MESSAGE:
+            case ZT_EVENT_REMOTE_TRACE:
+            default:
+                break;
         }
-        case ZT_EVENT_OFFLINE:
-        {
-            LOGD("Event Offline");
-            env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
-            break;
+    }
+
+    void StatePutFunction(
+            ZT_Node *node,
+            void *userData,
+            void *threadData,
+            enum ZT_StateObjectType type,
+            const uint64_t id[2],
+            const void *buffer,
+            int bufferLength) {
+        char p[4096] = {0};
+        bool secure = false;
+        switch (type) {
+            case ZT_STATE_OBJECT_IDENTITY_PUBLIC:
+                snprintf(p, sizeof(p), "identity.public");
+                break;
+            case ZT_STATE_OBJECT_IDENTITY_SECRET:
+                snprintf(p, sizeof(p), "identity.secret");
+                secure = true;
+                break;
+            case ZT_STATE_OBJECT_PLANET:
+                snprintf(p, sizeof(p), "planet");
+                break;
+            case ZT_STATE_OBJECT_MOON:
+                snprintf(p, sizeof(p), "moons.d/%.16llx.moon", (unsigned long long)id[0]);
+                break;
+            case ZT_STATE_OBJECT_NETWORK_CONFIG:
+                snprintf(p, sizeof(p), "networks.d/%.16llx.conf", (unsigned long long)id[0]);
+                break;
+            case ZT_STATE_OBJECT_PEER:
+                snprintf(p, sizeof(p), "peers.d/%.10llx", (unsigned long long)id[0]);
+                break;
+            default:
+                return;
         }
-        case ZT_EVENT_ONLINE:
-        {
-            LOGD("Event Online");
-            env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
-            break;
+
+        if (strlen(p) < 1) {
+            return;
         }
-        case ZT_EVENT_DOWN:
+
+        JniRef *ref = (JniRef*)userData;
+        JNIEnv *env = NULL;
+        ref->jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
+
+        if (ref->dataStorePutListener == NULL) {
+            LOGE("dataStorePutListener is NULL");
+            return;
+        }
+
+        jclass dataStorePutClass = env->GetObjectClass(ref->dataStorePutListener);
+        if (dataStorePutClass == NULL)
         {
-            LOGD("Event Down");
-            env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
-            break;
+            LOGE("Couldn't find class for DataStorePutListener instance");
+            return;
         }
-        case ZT_EVENT_FATAL_ERROR_IDENTITY_COLLISION:
+
+        jmethodID dataStorePutCallbackMethod = lookup.findMethod(
+                dataStorePutClass,
+                "onDataStorePut",
+                "(Ljava/lang/String;[BZ)I");
+        if(dataStorePutCallbackMethod == NULL)
         {
-            LOGV("Identity Collision");
-            // call onEvent()
-            env->CallVoidMethod(ref->eventListener, onEventMethod, eventObject);
+            LOGE("Couldn't find onDataStorePut method");
+            return;
         }
-        break;
-        case ZT_EVENT_TRACE:
+
+        jmethodID deleteMethod = lookup.findMethod(dataStorePutClass,
+                                                   "onDelete", "(Ljava/lang/String;)I");
+        if(deleteMethod == NULL)
         {
-            LOGV("Trace Event");
-            // call onTrace()
-            if(data != NULL)
+            LOGE("Couldn't find onDelete method");
+            return;
+        }
+
+        jstring nameStr = env->NewStringUTF(p);
+
+        if (bufferLength >= 0) {
+            LOGD("JNI: Write file: %s", p);
+            // set operation
+            jbyteArray bufferObj = env->NewByteArray(bufferLength);
+            if(env->ExceptionCheck() || bufferObj == NULL)
             {
-                const char* message = (const char*)data;
-                jstring messageStr = env->NewStringUTF(message);
-                env->CallVoidMethod(ref->eventListener, onTraceMethod, messageStr);
+                LOGE("Error creating byte array buffer!");
+                return;
             }
-        }
-        break;
+
+            env->SetByteArrayRegion(bufferObj, 0, bufferLength, (jbyte*)buffer);
+
+            env->CallIntMethod(ref->dataStorePutListener,
+                               dataStorePutCallbackMethod,
+                               nameStr, bufferObj, secure);
+        } else {
+            LOGD("JNI: Delete file: %s", p);
+            env->CallIntMethod(ref->dataStorePutListener, deleteMethod, nameStr);
         }
     }
 
-    long DataStoreGetFunction(ZT_Node *node,
-        void *userData,
-        const char *objectName,
-        void *buffer,
-        unsigned long bufferSize,
-        unsigned long bufferIndex,
-        unsigned long *out_objectSize)
-    {
+    int StateGetFunction(
+            ZT_Node *node,
+            void *userData,
+            void *threadData,
+            ZT_StateObjectType type,
+            const uint64_t id[2],
+            void *buffer,
+            unsigned int bufferLength) {
+        char p[4096] = {0};
+        switch (type) {
+            case ZT_STATE_OBJECT_IDENTITY_PUBLIC:
+                snprintf(p, sizeof(p), "identity.public");
+                break;
+            case ZT_STATE_OBJECT_IDENTITY_SECRET:
+                snprintf(p, sizeof(p), "identity.secret");
+                break;
+            case ZT_STATE_OBJECT_PLANET:
+                snprintf(p, sizeof(p), "planet");
+                break;
+            case ZT_STATE_OBJECT_MOON:
+                snprintf(p, sizeof(p), "moons.d/%.16llx.moon", (unsigned long long)id[0]);
+                break;
+            case ZT_STATE_OBJECT_NETWORK_CONFIG:
+                snprintf(p, sizeof(p), "networks.d/%.16llx.conf", (unsigned long long)id[0]);
+                break;
+            case ZT_STATE_OBJECT_PEER:
+                snprintf(p, sizeof(p), "peers.d/%.10llx", (unsigned long long)id[0]);
+                break;
+            default:
+                return -1;
+        }
+
+        if (strlen(p) < 1) {
+            return -1;
+        }
+
         JniRef *ref = (JniRef*)userData;
         JNIEnv *env = NULL;
         ref->jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
 
+        if (ref->dataStoreGetListener == NULL) {
+            LOGE("dataStoreGetListener is NULL");
+            return -2;
+        }
+
         jclass dataStoreGetClass = env->GetObjectClass(ref->dataStoreGetListener);
         if(dataStoreGetClass == NULL)
         {
@@ -305,176 +461,254 @@ namespace {
         }
 
         jmethodID dataStoreGetCallbackMethod = lookup.findMethod(
-            dataStoreGetClass,
-            "onDataStoreGet",
-            "(Ljava/lang/String;[BJ[J)J");
+                dataStoreGetClass,
+                "onDataStoreGet",
+                "(Ljava/lang/String;[B)J");
         if(dataStoreGetCallbackMethod == NULL)
         {
             LOGE("Couldn't find onDataStoreGet method");
             return -2;
         }
 
-        jstring nameStr = env->NewStringUTF(objectName);
+        jstring nameStr = env->NewStringUTF(p);
         if(nameStr == NULL)
         {
             LOGE("Error creating name string object");
             return -2; // out of memory
         }
 
-        jbyteArray bufferObj = env->NewByteArray(bufferSize);
+        jbyteArray bufferObj = env->NewByteArray(bufferLength);
         if(bufferObj == NULL)
         {
-            LOGE("Error creating byte[] buffer of size: %lu", bufferSize);
+            LOGE("Error creating byte[] buffer of size: %u", bufferLength);
             return -2;
         }
 
-        jlongArray objectSizeObj = env->NewLongArray(1);
-        if(objectSizeObj == NULL)
-        {
-            LOGE("Error creating long[1] array for actual object size");
-            return -2; // couldn't create long[1] array
-        }
+        LOGV("Calling onDataStoreGet(%s, %p)", p, buffer);
 
-        LOGV("Calling onDataStoreGet(%s, %p, %lu, %p)",
-            objectName, buffer, bufferIndex, objectSizeObj);
+        int retval = (int)env->CallLongMethod(
+                ref->dataStoreGetListener,
+                dataStoreGetCallbackMethod,
+                nameStr,
+                bufferObj);
 
-        long retval = (long)env->CallLongMethod(
-            ref->dataStoreGetListener, dataStoreGetCallbackMethod, 
-            nameStr, bufferObj, (jlong)bufferIndex, objectSizeObj);
+        LOGV("onDataStoreGet returned %d", retval);
 
         if(retval > 0)
         {
             void *data = env->GetPrimitiveArrayCritical(bufferObj, NULL);
             memcpy(buffer, data, retval);
             env->ReleasePrimitiveArrayCritical(bufferObj, data, 0);
-
-            jlong *objSize = (jlong*)env->GetPrimitiveArrayCritical(objectSizeObj, NULL);
-            *out_objectSize = (unsigned long)objSize[0];
-            env->ReleasePrimitiveArrayCritical(objectSizeObj, objSize, 0);
         }
 
-        LOGV("Out Object Size: %lu", *out_objectSize);
-
         return retval;
     }
 
-    int DataStorePutFunction(ZT_Node *node,
+    int WirePacketSendFunction(ZT_Node *node,
         void *userData,
-        const char *objectName,
+        void *threadData,
+        int64_t localSocket,
+        const struct sockaddr_storage *remoteAddress,
         const void *buffer,
-        unsigned long bufferSize,
-        int secure)
+        unsigned int bufferSize,
+        unsigned int ttl)
     {
+        LOGV("WirePacketSendFunction(%lld, %p, %p, %d)", (long long)localSocket, remoteAddress, buffer, bufferSize);
         JniRef *ref = (JniRef*)userData;
+        assert(ref->node == node);
+
         JNIEnv *env = NULL;
         ref->jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
 
+        if (ref->packetSender == NULL) {
+            LOGE("packetSender is NULL");
+            return -1;
+        }
 
-        jclass dataStorePutClass = env->GetObjectClass(ref->dataStorePutListener);
-        if(dataStorePutClass == NULL)
+        jclass packetSenderClass = env->GetObjectClass(ref->packetSender);
+        if(packetSenderClass == NULL)
         {
-            LOGE("Couldn't find class for DataStorePutListener instance");
+            LOGE("Couldn't find class for PacketSender instance");
             return -1;
         }
 
-        jmethodID dataStorePutCallbackMethod = lookup.findMethod(
-            dataStorePutClass,
-            "onDataStorePut",
-            "(Ljava/lang/String;[BZ)I");
-        if(dataStorePutCallbackMethod == NULL)
+        jmethodID packetSenderCallbackMethod = lookup.findMethod(packetSenderClass,
+            "onSendPacketRequested", "(JLjava/net/InetSocketAddress;[BI)I");
+        if(packetSenderCallbackMethod == NULL)
         {
-            LOGE("Couldn't find onDataStorePut method");
+            LOGE("Couldn't find onSendPacketRequested method");
             return -2;
         }
 
-        jmethodID deleteMethod = lookup.findMethod(dataStorePutClass,
-            "onDelete", "(Ljava/lang/String;)I");
-        if(deleteMethod == NULL)
-        {
-            LOGE("Couldn't find onDelete method");
-            return -3;
+        jobject remoteAddressObj = newInetSocketAddress(env, *remoteAddress);
+        jbyteArray bufferObj = env->NewByteArray(bufferSize);
+        env->SetByteArrayRegion(bufferObj, 0, bufferSize, (jbyte*)buffer);
+        int retval = env->CallIntMethod(ref->packetSender, packetSenderCallbackMethod, localSocket, remoteAddressObj, bufferObj);
+
+        LOGV("JNI Packet Sender returned: %d", retval);
+        return retval;
+    }
+
+    int PathCheckFunction(ZT_Node *node,
+        void *userPtr,
+        void *threadPtr,
+        uint64_t address,
+        int64_t localSocket,
+        const struct sockaddr_storage *remoteAddress)
+    {
+        JniRef *ref = (JniRef*)userPtr;
+        assert(ref->node == node);
+
+        if(ref->pathChecker == NULL) {
+            return true;
         }
 
-        jstring nameStr = env->NewStringUTF(objectName);
+        JNIEnv *env = NULL;
+        ref->jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
 
-        if(buffer == NULL)
+        jclass pathCheckerClass = env->GetObjectClass(ref->pathChecker);
+        if(pathCheckerClass == NULL)
         {
-            LOGD("JNI: Delete file: %s", objectName);
-            // delete operation
-            return env->CallIntMethod(
-                ref->dataStorePutListener, deleteMethod, nameStr);
+            LOGE("Couldn't find class for PathChecker instance");
+            return true;
         }
-        else
+
+        jmethodID pathCheckCallbackMethod = lookup.findMethod(pathCheckerClass,
+            "onPathCheck", "(JJLjava/net/InetSocketAddress;)Z");
+        if(pathCheckCallbackMethod == NULL)
         {
-            LOGD("JNI: Write file: %s", objectName);
-            // set operation
-            jbyteArray bufferObj = env->NewByteArray(bufferSize);
-            if(env->ExceptionCheck() || bufferObj == NULL)
-            {
-                LOGE("Error creating byte array buffer!");
-                return -4;
-            }
+            LOGE("Couldn't find onPathCheck method implementation");
+            return true;
+        }
 
-            env->SetByteArrayRegion(bufferObj, 0, bufferSize, (jbyte*)buffer);
-            bool bsecure = secure != 0;
+        struct sockaddr_storage nullAddress = {0};
+        jobject remoteAddressObj = NULL;
 
-            return env->CallIntMethod(ref->dataStorePutListener,
-                dataStorePutCallbackMethod,
-                nameStr, bufferObj, bsecure);
+        if(memcmp(remoteAddress, &nullAddress, sizeof(sockaddr_storage)) != 0)
+        {
+            remoteAddressObj = newInetSocketAddress(env, *remoteAddress);
         }
+
+        return env->CallBooleanMethod(ref->pathChecker, pathCheckCallbackMethod, address, localSocket, remoteAddressObj);
     }
 
-    int WirePacketSendFunction(ZT_Node *node,
-        void *userData,
-        const struct sockaddr_storage *localAddress,
-        const struct sockaddr_storage *remoteAddress,
-        const void *buffer,
-        unsigned int bufferSize,
-        unsigned int ttl)
+    int PathLookupFunction(ZT_Node *node,
+        void *userPtr,
+        void *threadPtr,
+        uint64_t address,
+        int ss_family,
+        struct sockaddr_storage *result)
     {
-        LOGV("WirePacketSendFunction(%p, %p, %p, %d)", localAddress, remoteAddress, buffer, bufferSize);
-        JniRef *ref = (JniRef*)userData;
+        JniRef *ref = (JniRef*)userPtr;
         assert(ref->node == node);
 
+        if(ref->pathChecker == NULL) {
+            return false;
+        }
+
         JNIEnv *env = NULL;
         ref->jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
 
+        jclass pathCheckerClass = env->GetObjectClass(ref->pathChecker);
+        if(pathCheckerClass == NULL)
+        {
+            LOGE("Couldn't find class for PathChecker instance");
+            return false;
+        }
+
+        jmethodID pathLookupMethod = lookup.findMethod(pathCheckerClass,
+            "onPathLookup", "(JI)Ljava/net/InetSocketAddress;");
+        if(pathLookupMethod == NULL) {
+            return false;
+        }
 
-        jclass packetSenderClass = env->GetObjectClass(ref->packetSender);
-        if(packetSenderClass == NULL)
+        jobject sockAddressObject = env->CallObjectMethod(ref->pathChecker, pathLookupMethod, address, ss_family);
+        if(sockAddressObject == NULL)
         {
-            LOGE("Couldn't find class for PacketSender instance");
-            return -1;
+            LOGE("Unable to call onPathLookup implementation");
+            return false;
         }
 
-        jmethodID packetSenderCallbackMethod = lookup.findMethod(packetSenderClass,
-            "onSendPacketRequested", "(Ljava/net/InetSocketAddress;Ljava/net/InetSocketAddress;[BI)I");
-        if(packetSenderCallbackMethod == NULL)
+        jclass inetSockAddressClass = env->GetObjectClass(sockAddressObject);
+        if(inetSockAddressClass == NULL)
         {
-            LOGE("Couldn't find onSendPacketRequested method");
-            return -2;
+            LOGE("Unable to find InetSocketAddress class");
+            return false;
+        }
+
+        jmethodID getAddressMethod = lookup.findMethod(inetSockAddressClass, "getAddress", "()Ljava/net/InetAddress;");
+        if(getAddressMethod == NULL)
+        {
+            LOGE("Unable to find InetSocketAddress.getAddress() method");
+            return false;
+        }
+
+        jmethodID getPortMethod = lookup.findMethod(inetSockAddressClass, "getPort", "()I");
+        if(getPortMethod == NULL)
+        {
+            LOGE("Unable to find InetSocketAddress.getPort() method");
+            return false;
         }
+
+        jint port = env->CallIntMethod(sockAddressObject, getPortMethod);
+        jobject addressObject = env->CallObjectMethod(sockAddressObject, getAddressMethod);
         
-        jobject localAddressObj = NULL;
-        if(memcmp(localAddress, &ZT_SOCKADDR_NULL, sizeof(sockaddr_storage)) != 0)
+        jclass inetAddressClass = lookup.findClass("java/net/InetAddress");
+        if(inetAddressClass == NULL)
         {
-            localAddressObj = newInetSocketAddress(env, *localAddress);
+            LOGE("Unable to find InetAddress class");
+            return false;
         }
 
-        jobject remoteAddressObj = newInetSocketAddress(env, *remoteAddress);
-        jbyteArray bufferObj = env->NewByteArray(bufferSize);
-        env->SetByteArrayRegion(bufferObj, 0, bufferSize, (jbyte*)buffer);
-        int retval = env->CallIntMethod(ref->packetSender, packetSenderCallbackMethod, localAddressObj, remoteAddressObj, bufferObj);
+        getAddressMethod = lookup.findMethod(inetAddressClass, "getAddress", "()[B");
+        if(getAddressMethod == NULL)
+        {
+            LOGE("Unable to find InetAddress.getAddress() method");
+            return false;
+        }
 
-        LOGV("JNI Packet Sender returned: %d", retval);
-        return retval;
+        jbyteArray addressBytes = (jbyteArray)env->CallObjectMethod(addressObject, getAddressMethod);
+        if(addressBytes == NULL)
+        {
+            LOGE("Unable to call InetAddress.getBytes()");
+            return false;
+        }
+
+        int addressSize = env->GetArrayLength(addressBytes);
+        if(addressSize == 4)
+        {
+            // IPV4
+            sockaddr_in *addr = (sockaddr_in*)result;
+            addr->sin_family = AF_INET;
+            addr->sin_port = htons(port);
+            
+            void *data = env->GetPrimitiveArrayCritical(addressBytes, NULL);
+            memcpy(&addr->sin_addr, data, 4);
+            env->ReleasePrimitiveArrayCritical(addressBytes, data, 0);
+        }
+        else if (addressSize == 16)
+        {
+            // IPV6
+            sockaddr_in6 *addr = (sockaddr_in6*)result;
+            addr->sin6_family = AF_INET6;
+            addr->sin6_port = htons(port);
+            void *data = env->GetPrimitiveArrayCritical(addressBytes, NULL);
+            memcpy(&addr->sin6_addr, data, 16);
+            env->ReleasePrimitiveArrayCritical(addressBytes, data, 0);
+        }
+        else
+        {
+            return false;
+        }
+
+        return true;
     }
 
-    typedef std::map<uint64_t, JniRef*> NodeMap;
+    typedef std::map<int64_t, JniRef*> NodeMap;
     static NodeMap nodeMap;
     ZeroTier::Mutex nodeMapMutex;
 
-    ZT_Node* findNode(uint64_t nodeId)
+    ZT_Node* findNode(int64_t nodeId)
     {
         ZeroTier::Mutex::Lock lock(nodeMapMutex);
         NodeMap::iterator found = nodeMap.find(nodeId);
@@ -487,7 +721,7 @@ namespace {
     }
 }
 
-JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) 
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
 {
     lookup.setJavaVM(vm);
     return JNI_VERSION_1_6;
@@ -512,7 +746,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_node_1init(
 
     ZT_Node *node;
     JniRef *ref = new JniRef;
-    ref->id = (uint64_t)now;
+    ref->id = (int64_t)now;
     env->GetJavaVM(&ref->jvm);
 
     jclass cls = env->GetObjectClass(obj);
@@ -602,17 +836,35 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_node_1init(
     }
     ref->eventListener = env->NewGlobalRef(tmp);
 
+    fid = lookup.findField(
+        cls, "pathChecker", "Lcom/zerotier/sdk/PathChecker;");
+    if(fid == NULL)
+    {
+        LOGE("no path checker?");
+        return NULL;
+    }
+
+    tmp = env->GetObjectField(obj, fid);
+    if(tmp != NULL)
+    {
+        ref->pathChecker = env->NewGlobalRef(tmp);
+    }
+
+    ref->callbacks->stateGetFunction = &StateGetFunction;
+    ref->callbacks->statePutFunction = &StatePutFunction;
+    ref->callbacks->wirePacketSendFunction = &WirePacketSendFunction;
+    ref->callbacks->virtualNetworkFrameFunction = &VirtualNetworkFrameFunctionCallback;
+    ref->callbacks->virtualNetworkConfigFunction = &VirtualNetworkConfigFunctionCallback;
+    ref->callbacks->eventCallback = &EventCallback;
+    ref->callbacks->pathCheckFunction = &PathCheckFunction;
+    ref->callbacks->pathLookupFunction = &PathLookupFunction;
+
     ZT_ResultCode rc = ZT_Node_new(
         &node,
         ref,
-        (uint64_t)now,
-        &DataStoreGetFunction,
-        &DataStorePutFunction,
-        &WirePacketSendFunction,
-        &VirtualNetworkFrameFunctionCallback,
-        &VirtualNetworkConfigFunctionCallback,
         NULL,
-        &EventCallback);
+        ref->callbacks,
+        (int64_t)now);
 
     if(rc != ZT_RESULT_OK)
     {
@@ -628,10 +880,16 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_node_1init(
         return resultObject;
     }
 
+    uint64_t nodeId = ZT_Node_address(node);
+    if (nodeId != 0) {
+        char uniqueName[64];
+        snprintf(uniqueName, sizeof(uniqueName), "ZeroTier Android/%.10llx@%u", (unsigned long long)nodeId, 9993);
+        ref->portMapper = new ZeroTier::PortMapper(9993, uniqueName);
+    }
+
     ZeroTier::Mutex::Lock lock(nodeMapMutex);
     ref->node = node;
     nodeMap.insert(std::make_pair(ref->id, ref));
-    
 
     return resultObject;
 }
@@ -645,11 +903,11 @@ JNIEXPORT void JNICALL Java_com_zerotier_sdk_Node_node_1delete(
     JNIEnv *env, jobject obj, jlong id)
 {
     LOGV("Destroying ZT_Node struct");
-    uint64_t nodeId = (uint64_t)id;
+    int64_t nodeId = (int64_t)id;
 
     NodeMap::iterator found;
     {
-        ZeroTier::Mutex::Lock lock(nodeMapMutex);  
+        ZeroTier::Mutex::Lock lock(nodeMapMutex);
         found = nodeMap.find(nodeId);
     }
 
@@ -675,9 +933,9 @@ JNIEXPORT void JNICALL Java_com_zerotier_sdk_Node_node_1delete(
  * Signature: (JJJJJII[B[J)Lcom/zerotier/sdk/ResultCode;
  */
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processVirtualNetworkFrame(
-    JNIEnv *env, jobject obj, 
-    jlong id, 
-    jlong in_now, 
+    JNIEnv *env, jobject obj,
+    jlong id,
+    jlong in_now,
     jlong in_nwid,
     jlong in_sourceMac,
     jlong in_destMac,
@@ -686,8 +944,8 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processVirtualNetworkFrame(
     jbyteArray in_frameData,
     jlongArray out_nextBackgroundTaskDeadline)
 {
-    uint64_t nodeId = (uint64_t) id;
-    
+    int64_t nodeId = (int64_t) id;
+
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -702,7 +960,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processVirtualNetworkFrame(
         return createResultObject(env, ZT_RESULT_FATAL_ERROR_INTERNAL);
     }
 
-    uint64_t now = (uint64_t)in_now;
+    int64_t now = (int64_t)in_now;
     uint64_t nwid = (uint64_t)in_nwid;
     uint64_t sourceMac = (uint64_t)in_sourceMac;
     uint64_t destMac = (uint64_t)in_destMac;
@@ -715,10 +973,11 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processVirtualNetworkFrame(
     memcpy(localData, frameData, frameLength);
     env->ReleasePrimitiveArrayCritical(in_frameData, frameData, 0);
 
-    uint64_t nextBackgroundTaskDeadline = 0;
+    int64_t nextBackgroundTaskDeadline = 0;
 
     ZT_ResultCode rc = ZT_Node_processVirtualNetworkFrame(
         node,
+        NULL,
         now,
         nwid,
         sourceMac,
@@ -739,18 +998,18 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processVirtualNetworkFrame(
 /*
  * Class:     com_zerotier_sdk_Node
  * Method:    processWirePacket
- * Signature: (JJLjava/net/InetSocketAddress;I[B[J)Lcom/zerotier/sdk/ResultCode;
+ * Signature: (JJJLjava/net/InetSocketAddress;I[B[J)Lcom/zerotier/sdk/ResultCode;
  */
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket(
-    JNIEnv *env, jobject obj, 
+    JNIEnv *env, jobject obj,
     jlong id,
-    jlong in_now, 
-    jobject in_localAddress,
+    jlong in_now,
+    jlong in_localSocket,
     jobject in_remoteAddress,
     jbyteArray in_packetData,
     jlongArray out_nextBackgroundTaskDeadline)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -759,14 +1018,14 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket(
         return createResultObject(env, ZT_RESULT_FATAL_ERROR_INTERNAL);
     }
 
-    unsigned int nbtd_len = env->GetArrayLength(out_nextBackgroundTaskDeadline);
+    unsigned int nbtd_len = (unsigned int)env->GetArrayLength(out_nextBackgroundTaskDeadline);
     if(nbtd_len < 1)
     {
         LOGE("nbtd_len < 1");
         return createResultObject(env, ZT_RESULT_FATAL_ERROR_INTERNAL);
     }
 
-    uint64_t now = (uint64_t)in_now;
+    int64_t now = (int64_t)in_now;
 
     // get the java.net.InetSocketAddress class and getAddress() method
     jclass inetAddressClass = lookup.findClass("java/net/InetAddress");
@@ -794,12 +1053,6 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket(
     jmethodID inetSockGetAddressMethod = lookup.findMethod(
         InetSocketAddressClass, "getAddress", "()Ljava/net/InetAddress;");
 
-    jobject localAddrObj = NULL;
-    if(in_localAddress != NULL)
-    {
-        localAddrObj = env->CallObjectMethod(in_localAddress, inetSockGetAddressMethod);
-    }
-
     jobject remoteAddrObject = env->CallObjectMethod(in_remoteAddress, inetSockGetAddressMethod);
 
     if(remoteAddrObject == NULL)
@@ -810,7 +1063,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket(
     jmethodID inetSock_getPort = lookup.findMethod(
         InetSocketAddressClass, "getPort", "()I");
 
-    if(env->ExceptionCheck() || inetSock_getPort == NULL) 
+    if(env->ExceptionCheck() || inetSock_getPort == NULL)
     {
         LOGE("Couldn't find getPort method on InetSocketAddress");
         return createResultObject(env, ZT_RESULT_FATAL_ERROR_INTERNAL);
@@ -834,48 +1087,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket(
     }
 
     unsigned int addrSize = env->GetArrayLength(remoteAddressArray);
-    
-
-    sockaddr_storage localAddress = {};
-    
-    if(localAddrObj == NULL)
-    {
-        localAddress = ZT_SOCKADDR_NULL;
-    }
-    else
-    {
-        int localPort = env->CallIntMethod(in_localAddress, inetSock_getPort);
-        jbyteArray localAddressArray = (jbyteArray)env->CallObjectMethod(localAddrObj, getAddressMethod);
-        if(localAddressArray != NULL)
-        {
 
-            unsigned int localAddrSize = env->GetArrayLength(localAddressArray);
-            jbyte *addr = (jbyte*)env->GetPrimitiveArrayCritical(localAddressArray, NULL);
-
-            if(localAddrSize == 16)
-            {
-                sockaddr_in6 ipv6 = {};
-                ipv6.sin6_family = AF_INET6;
-                ipv6.sin6_port = htons(localPort);
-                memcpy(ipv6.sin6_addr.s6_addr, addr, 16);
-                memcpy(&localAddress, &ipv6, sizeof(sockaddr_in6));
-            }
-            else if(localAddrSize)
-            {
-                // IPV4 address
-                sockaddr_in ipv4 = {};
-                ipv4.sin_family = AF_INET;
-                ipv4.sin_port = htons(localPort);
-                memcpy(&ipv4.sin_addr, addr, 4);
-                memcpy(&localAddress, &ipv4, sizeof(sockaddr_in));
-            }
-            else
-            {
-                localAddress = ZT_SOCKADDR_NULL;
-            }
-            env->ReleasePrimitiveArrayCritical(localAddressArray, addr, 0);
-        }
-    }
 
     // get the address bytes
     jbyte *addr = (jbyte*)env->GetPrimitiveArrayCritical(remoteAddressArray, NULL);
@@ -908,7 +1120,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket(
     }
     env->ReleasePrimitiveArrayCritical(remoteAddressArray, addr, 0);
 
-    unsigned int packetLength = env->GetArrayLength(in_packetData);
+    unsigned int packetLength = (unsigned int)env->GetArrayLength(in_packetData);
     if(packetLength == 0)
     {
         LOGE("Empty packet?!?");
@@ -919,17 +1131,18 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket(
     memcpy(localData, packetData, packetLength);
     env->ReleasePrimitiveArrayCritical(in_packetData, packetData, 0);
 
-    uint64_t nextBackgroundTaskDeadline = 0;
+    int64_t nextBackgroundTaskDeadline = 0;
 
     ZT_ResultCode rc = ZT_Node_processWirePacket(
         node,
+        NULL,
         now,
-        &localAddress,
+        in_localSocket,
         &remoteAddress,
         localData,
         packetLength,
         &nextBackgroundTaskDeadline);
-    if(rc != ZT_RESULT_OK) 
+    if(rc != ZT_RESULT_OK)
     {
         LOGE("ZT_Node_processWirePacket returned: %d", rc);
     }
@@ -949,12 +1162,12 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket(
  * Signature: (JJ[J)Lcom/zerotier/sdk/ResultCode;
  */
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processBackgroundTasks(
-    JNIEnv *env, jobject obj, 
+    JNIEnv *env, jobject obj,
     jlong id,
     jlong in_now,
     jlongArray out_nextBackgroundTaskDeadline)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -968,10 +1181,10 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processBackgroundTasks(
         return createResultObject(env, ZT_RESULT_FATAL_ERROR_INTERNAL);
     }
 
-    uint64_t now = (uint64_t)in_now;
-    uint64_t nextBackgroundTaskDeadline = 0;
+    int64_t now = (int64_t)in_now;
+    int64_t nextBackgroundTaskDeadline = 0;
 
-    ZT_ResultCode rc = ZT_Node_processBackgroundTasks(node, now, &nextBackgroundTaskDeadline);
+    ZT_ResultCode rc = ZT_Node_processBackgroundTasks(node, NULL, now, &nextBackgroundTaskDeadline);
 
     jlong *outDeadline = (jlong*)env->GetPrimitiveArrayCritical(out_nextBackgroundTaskDeadline, NULL);
     outDeadline[0] = (jlong)nextBackgroundTaskDeadline;
@@ -988,7 +1201,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processBackgroundTasks(
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_join(
     JNIEnv *env, jobject obj, jlong id, jlong in_nwid)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -998,7 +1211,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_join(
 
     uint64_t nwid = (uint64_t)in_nwid;
 
-    ZT_ResultCode rc = ZT_Node_join(node, nwid, NULL);
+    ZT_ResultCode rc = ZT_Node_join(node, nwid, NULL, NULL);
 
     return createResultObject(env, rc);
 }
@@ -1011,7 +1224,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_join(
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_leave(
     JNIEnv *env, jobject obj, jlong id, jlong in_nwid)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -1021,8 +1234,8 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_leave(
 
     uint64_t nwid = (uint64_t)in_nwid;
 
-    ZT_ResultCode rc = ZT_Node_leave(node, nwid, NULL);
-    
+    ZT_ResultCode rc = ZT_Node_leave(node, nwid, NULL, NULL);
+
     return createResultObject(env, rc);
 }
 
@@ -1032,13 +1245,13 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_leave(
  * Signature: (JJJJ)Lcom/zerotier/sdk/ResultCode;
  */
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_multicastSubscribe(
-    JNIEnv *env, jobject obj, 
-    jlong id, 
+    JNIEnv *env, jobject obj,
+    jlong id,
     jlong in_nwid,
     jlong in_multicastGroup,
     jlong in_multicastAdi)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -1051,7 +1264,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_multicastSubscribe(
     unsigned long multicastAdi = (unsigned long)in_multicastAdi;
 
     ZT_ResultCode rc = ZT_Node_multicastSubscribe(
-        node, nwid, multicastGroup, multicastAdi);
+        node, NULL, nwid, multicastGroup, multicastAdi);
 
     return createResultObject(env, rc);
 }
@@ -1062,13 +1275,13 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_multicastSubscribe(
  * Signature: (JJJJ)Lcom/zerotier/sdk/ResultCode;
  */
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_multicastUnsubscribe(
-    JNIEnv *env, jobject obj, 
-    jlong id, 
+    JNIEnv *env, jobject obj,
+    jlong id,
     jlong in_nwid,
     jlong in_multicastGroup,
     jlong in_multicastAdi)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -1087,6 +1300,54 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_multicastUnsubscribe(
 }
 
 /*
+ * Class:   com_zerotier_sdk_Node
+ * Method:  orbit
+ * Signature: (JJJ)Lcom/zerotier/sdk/ResultCode;
+ */
+JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_orbit(
+    JNIEnv *env, jobject obj,
+    jlong id,
+    jlong in_moonWorldId,
+    jlong in_moonSeed)
+{
+    int64_t nodeId = (int64_t)id;
+    ZT_Node *node = findNode(nodeId);
+    if(node == NULL)
+    {
+        return createResultObject(env, ZT_RESULT_FATAL_ERROR_INTERNAL);
+    }
+
+    uint64_t moonWorldId = (uint64_t)in_moonWorldId;
+    uint64_t moonSeed = (uint64_t)in_moonSeed;
+
+    ZT_ResultCode rc = ZT_Node_orbit(node, NULL, moonWorldId, moonSeed);
+    return createResultObject(env, rc);
+}
+
+/*
+ * Class:   com_zerotier_sdk_Node
+ * Method:  deorbit
+ * Signature: (JJ)L/com/zerotier/sdk/ResultCode;
+ */
+JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_deorbit(
+    JNIEnv *env, jobject obj,
+    jlong id,
+    jlong in_moonWorldId)
+{
+    int64_t nodeId = (int64_t)id;
+    ZT_Node *node = findNode(nodeId);
+    if(node == NULL)
+    {
+        return createResultObject(env, ZT_RESULT_FATAL_ERROR_INTERNAL);
+    }
+
+    uint64_t moonWorldId = (uint64_t)in_moonWorldId;
+
+    ZT_ResultCode rc = ZT_Node_deorbit(node, NULL, moonWorldId);
+    return createResultObject(env, rc);
+}
+
+/*
  * Class:     com_zerotier_sdk_Node
  * Method:    address
  * Signature: (J)J
@@ -1094,7 +1355,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_multicastUnsubscribe(
 JNIEXPORT jlong JNICALL Java_com_zerotier_sdk_Node_address(
     JNIEnv *env , jobject obj, jlong id)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -1114,7 +1375,7 @@ JNIEXPORT jlong JNICALL Java_com_zerotier_sdk_Node_address(
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_status
    (JNIEnv *env, jobject obj, jlong id)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -1131,7 +1392,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_status
     {
         return NULL;
     }
-    
+
     nodeStatusConstructor = lookup.findMethod(
         nodeStatusClass, "<init>", "()V");
     if(nodeStatusConstructor == NULL)
@@ -1206,7 +1467,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_status
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_networkConfig(
     JNIEnv *env, jobject obj, jlong id, jlong nwid)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -1215,7 +1476,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_networkConfig(
     }
 
     ZT_VirtualNetworkConfig *vnetConfig = ZT_Node_networkConfig(node, nwid);
-    
+
     jobject vnetConfigObject = newNetworkConfig(env, *vnetConfig);
 
     ZT_Node_freeQueryResult(node, vnetConfig);
@@ -1248,7 +1509,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_version(
 JNIEXPORT jobjectArray JNICALL Java_com_zerotier_sdk_Node_peers(
     JNIEnv *env, jobject obj, jlong id)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
@@ -1257,7 +1518,7 @@ JNIEXPORT jobjectArray JNICALL Java_com_zerotier_sdk_Node_peers(
     }
 
     ZT_PeerList *peerList = ZT_Node_peers(node);
-    
+
     if(peerList == NULL)
     {
         LOGE("ZT_Node_peers returned NULL");
@@ -1296,7 +1557,7 @@ JNIEXPORT jobjectArray JNICALL Java_com_zerotier_sdk_Node_peers(
     {
         jobject peerObj = newPeer(env, peerList->peers[i]);
         env->SetObjectArrayElement(peerArrayObj, i, peerObj);
-        if(env->ExceptionCheck()) 
+        if(env->ExceptionCheck())
         {
             LOGE("Error assigning Peer object to array");
             break;
@@ -1317,7 +1578,7 @@ JNIEXPORT jobjectArray JNICALL Java_com_zerotier_sdk_Node_peers(
 JNIEXPORT jobjectArray JNICALL Java_com_zerotier_sdk_Node_networks(
     JNIEnv *env, jobject obj, jlong id)
 {
-    uint64_t nodeId = (uint64_t) id;
+    int64_t nodeId = (int64_t) id;
     ZT_Node *node = findNode(nodeId);
     if(node == NULL)
     {
diff --git a/java/jni/com_zerotierone_sdk_Node.h b/java/jni/com_zerotierone_sdk_Node.h
index 7c1011ab..8487d8af 100644
--- a/java/jni/com_zerotierone_sdk_Node.h
+++ b/java/jni/com_zerotierone_sdk_Node.h
@@ -37,7 +37,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processVirtualNetworkFrame
  * Signature: (JJLjava/net/InetSockAddress;Ljava/net/InetSockAddress;[B[J)Lcom/zerotier/sdk/ResultCode;
  */
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket
-  (JNIEnv *, jobject, jlong, jlong, jobject, jobject, jbyteArray, jlongArray);
+  (JNIEnv *, jobject, jlong, jlong, jlong, jobject, jbyteArray, jlongArray);
 
 /*
  * Class:     com_zerotier_sdk_Node
diff --git a/java/src/com/zerotier/sdk/DataStoreGetListener.java b/java/src/com/zerotier/sdk/DataStoreGetListener.java
index b525be63..317511e0 100644
--- a/java/src/com/zerotier/sdk/DataStoreGetListener.java
+++ b/java/src/com/zerotier/sdk/DataStoreGetListener.java
@@ -46,13 +46,9 @@ public interface DataStoreGetListener {
      *
      * @param name Name of the object in the data store
      * @param out_buffer buffer to put the object in
-     * @param bufferIndex index in the object to start reading
-     * @param out_objectSize long[1] to be set to the actual size of the object if it exists.
-     * @return the actual number of bytes read.
+     * @return size of the object
      */
     public long onDataStoreGet(
             String name,
-            byte[] out_buffer,
-            long bufferIndex,
-            long[] out_objectSize);
+            byte[] out_buffer);
 }
diff --git a/java/src/com/zerotier/sdk/Node.java b/java/src/com/zerotier/sdk/Node.java
index 4bc6e184..ef6ac9d2 100644
--- a/java/src/com/zerotier/sdk/Node.java
+++ b/java/src/com/zerotier/sdk/Node.java
@@ -74,6 +74,7 @@ public class Node {
     private final EventListener eventListener;
     private final VirtualNetworkFrameListener frameListener;
     private final VirtualNetworkConfigListener configListener;
+    private final PathChecker pathChecker;
     
     /**
      * Create a new ZeroTier One node
@@ -88,6 +89,7 @@ public class Node {
      * @param eventListener User written instance of the {@link EventListener} interface to receive status updates and non-fatal error notices.  This instance must be unique per Node object.
      * @param frameListener 
      * @param configListener User written instance of the {@link VirtualNetworkConfigListener} interface to be called when virtual LANs are created, deleted, or their config parameters change.  This instance must be unique per Node object.
+     * @param pathChecker User written instance of the {@link PathChecker} interface. Not required and can be null.
      */
 	public Node(long now,
                 DataStoreGetListener getListener,
@@ -95,7 +97,8 @@ public class Node {
                 PacketSender sender,
                 EventListener eventListener,
                 VirtualNetworkFrameListener frameListener,
-                VirtualNetworkConfigListener configListener) throws NodeException
+                VirtualNetworkConfigListener configListener,
+                PathChecker pathChecker) throws NodeException
 	{
         this.nodeId = now;
 
@@ -105,6 +108,7 @@ public class Node {
         this.eventListener = eventListener;
         this.frameListener = frameListener;
         this.configListener = configListener;
+        this.pathChecker = pathChecker;
 
         ResultCode rc = node_init(now);
         if(rc != ResultCode.RESULT_OK)
@@ -169,12 +173,12 @@ public class Node {
      */
     public ResultCode processWirePacket(
         long now,
-        InetSocketAddress localAddress,
+        long localSocket,
         InetSocketAddress remoteAddress,
         byte[] packetData,
         long[] nextBackgroundTaskDeadline) {
         return processWirePacket(
-            nodeId, now, localAddress, remoteAddress, packetData, 
+            nodeId, now, localSocket, remoteAddress, packetData,
             nextBackgroundTaskDeadline);
     }
 
@@ -319,6 +323,34 @@ public class Node {
     }
 
     /**
+     * Add or update a moon
+     *
+     * Moons are persisted in the data store in moons.d/, so this can persist
+     * across invocations if the contents of moon.d are scanned and orbit is
+     * called for each on startup.
+     *
+     * @param moonWorldId Moon's world ID
+     * @param moonSeed If non-zero, the ZeroTier address of any member of the moon to query for moon definition
+     * @return Error if moon was invalid or failed to be added
+     */
+    public ResultCode orbit(
+            long moonWorldId,
+            long moonSeed) {
+        return orbit(nodeId, moonWorldId, moonSeed);
+    }
+
+    /**
+     * Remove a moon (does nothing if not present)
+     *
+     * @param moonWorldId World ID of moon to remove
+     * @return Error if anything bad happened
+     */
+    public ResultCode deorbit(
+            long moonWorldId) {
+        return deorbit(nodeId, moonWorldId);
+    }
+
+    /**
      * Get this node's 40-bit ZeroTier address
      *
      * @return ZeroTier address (least significant 40 bits of 64-bit int)
@@ -394,7 +426,7 @@ public class Node {
     private native ResultCode processWirePacket(
         long nodeId,
         long now,
-        InetSocketAddress localAddress,
+        long localSocket,
         InetSocketAddress remoteAddress,
         byte[] packetData,
         long[] nextBackgroundTaskDeadline);
@@ -420,6 +452,15 @@ public class Node {
         long multicastGroup,
         long multicastAdi);
 
+    private native ResultCode orbit(
+            long nodeId,
+            long moonWorldId,
+            long moonSeed);
+
+    private native ResultCode deorbit(
+            long nodeId,
+            long moonWorldId);
+
     private native long address(long nodeId);
 
     private native NodeStatus status(long nodeId);
diff --git a/java/src/com/zerotier/sdk/PacketSender.java b/java/src/com/zerotier/sdk/PacketSender.java
index 22893ec7..06ec01bc 100644
--- a/java/src/com/zerotier/sdk/PacketSender.java
+++ b/java/src/com/zerotier/sdk/PacketSender.java
@@ -37,13 +37,13 @@ public interface PacketSender {
      * on failure. Note that success does not (of course) guarantee packet
      * delivery. It only means that the packet appears to have been sent.</p>
      *
-     * @param localAddr {@link InetSocketAddress} to send from.  Set to null if not specified.
+     * @param localSocket socket file descriptor to send from.  Set to -1 if not specified.
      * @param remoteAddr {@link InetSocketAddress} to send to
      * @param packetData data to send
      * @return 0 on success, any error code on failure.
      */
     public int onSendPacketRequested(
-            InetSocketAddress localAddr,
+            long localSocket,
             InetSocketAddress remoteAddr,
             byte[] packetData,
             int ttl);
diff --git a/java/src/com/zerotier/sdk/PathChecker.java b/java/src/com/zerotier/sdk/PathChecker.java
new file mode 100644
index 00000000..6bf31df2
--- /dev/null
+++ b/java/src/com/zerotier/sdk/PathChecker.java
@@ -0,0 +1,45 @@
+/*
+ * ZeroTier One - Network Virtualization Everywhere
+ * Copyright (C) 2011-2017  ZeroTier, Inc.  https://www.zerotier.com/
+ */
+
+package com.zerotier.sdk;
+
+import java.net.InetSocketAddress;
+
+public interface PathChecker {
+    /**
+     * Callback to check whether a path should be used for ZeroTier traffic
+     *
+     * This function must return true if the path should be used.
+     *
+     * If no path check function is specified, ZeroTier will still exclude paths
+     * that overlap with ZeroTier-assigned and managed IP address blocks. But the
+     * use of a path check function is recommended to ensure that recursion does
+     * not occur in cases where addresses are assigned by the OS or managed by
+     * an out of band mechanism like DHCP. The path check function should examine
+     * all configured ZeroTier interfaces and check to ensure that the supplied
+     * addresses will not result in ZeroTier traffic being sent over a ZeroTier
+     * interface (recursion).
+     *
+     * Obviously this is not required in configurations where this can't happen,
+     * such as network containers or embedded.
+     *
+     * @param ztAddress ZeroTier address or 0 for none/any
+     * @param localSocket Local interface socket.  -1 if unspecified
+     * @param remoteAddress remote address
+     */
+    boolean onPathCheck(long ztAddress, long localSocket, InetSocketAddress remoteAddress);
+
+    /**
+     * Function to get physical addresses for ZeroTier peers
+     *
+     * If provided this function will be occasionally called to get physical
+     * addresses that might be tried to reach a ZeroTier address.
+     *
+     * @param ztAddress ZeroTier address (least significant 40 bits)
+     * @param ss_family desired address family or -1 for any
+     * @return address and port of ztAddress or null
+     */
+    InetSocketAddress onPathLookup(long ztAddress, int ss_family);
+}
diff --git a/java/src/com/zerotier/sdk/Peer.java b/java/src/com/zerotier/sdk/Peer.java
index fb2d1065..eb3d7130 100644
--- a/java/src/com/zerotier/sdk/Peer.java
+++ b/java/src/com/zerotier/sdk/Peer.java
@@ -34,8 +34,6 @@ import java.util.ArrayList;
  */
 public final class Peer {
     private long address;
-    private long lastUnicastFrame;
-    private long lastMulticastFrame;
     private int versionMajor;
     private int versionMinor;
     private int versionRev;
@@ -53,20 +51,6 @@ public final class Peer {
     }
 
     /**
-     * Time we last received a unicast frame from this peer
-     */
-    public final long lastUnicastFrame() {
-        return lastUnicastFrame;
-    }
-
-    /**
-     * Time we last received a multicast rame from this peer
-     */
-    public final long lastMulticastFrame() {
-        return lastMulticastFrame;
-    }
-
-    /**
      * Remote major version or -1 if not known
      */
     public final int versionMajor() {
diff --git a/java/src/com/zerotier/sdk/PeerPhysicalPath.java b/java/src/com/zerotier/sdk/PeerPhysicalPath.java
index d64ea56b..3f9a8612 100644
--- a/java/src/com/zerotier/sdk/PeerPhysicalPath.java
+++ b/java/src/com/zerotier/sdk/PeerPhysicalPath.java
@@ -37,7 +37,6 @@ public final class PeerPhysicalPath {
     private long lastSend;
     private long lastReceive;
     private boolean fixed;
-    private boolean active;
     private boolean preferred;
 
     private PeerPhysicalPath() {}
@@ -71,13 +70,6 @@ public final class PeerPhysicalPath {
     }
 
     /**
-     * Is path active?
-     */
-    public final boolean isActive() {
-        return active;
-    }
-
-    /**
      * Is path preferred?
      */
     public final boolean isPreferred() {
diff --git a/java/src/com/zerotier/sdk/PeerRole.java b/java/src/com/zerotier/sdk/PeerRole.java
index d7d55f05..fce183d9 100644
--- a/java/src/com/zerotier/sdk/PeerRole.java
+++ b/java/src/com/zerotier/sdk/PeerRole.java
@@ -34,12 +34,12 @@ public enum PeerRole {
     PEER_ROLE_LEAF,
 
     /**
-     * relay node
+     * moon root
      */
-    PEER_ROLE_RELAY,
+    PEER_ROLE_MOON,
 
     /**
-     * root server
+     * planetary root
      */
-    PEER_ROLE_ROOT
+    PEER_ROLE_PLANET
 }
\ No newline at end of file
diff --git a/java/src/com/zerotier/sdk/VirtualNetworkConfig.java b/java/src/com/zerotier/sdk/VirtualNetworkConfig.java
index fbcbd3a4..64512dad 100644
--- a/java/src/com/zerotier/sdk/VirtualNetworkConfig.java
+++ b/java/src/com/zerotier/sdk/VirtualNetworkConfig.java
@@ -50,6 +50,7 @@ public final class VirtualNetworkConfig implements Comparable<VirtualNetworkConf
     private boolean enabled;
     private long netconfRevision;
     private InetSocketAddress[] assignedAddresses;
+    private VirtualNetworkRoute[] routes;
 
     private VirtualNetworkConfig() {
 
@@ -60,13 +61,24 @@ public final class VirtualNetworkConfig implements Comparable<VirtualNetworkConf
         if(assignedAddresses.length == cfg.assignedAddresses.length) {
             for(int i = 0; i < assignedAddresses.length; ++i) {
                 if(!assignedAddresses[i].equals(cfg.assignedAddresses[i])) {
-                    return false;
+                    aaEqual = false;
                 }
             }
         } else {
             aaEqual = false;
         }
 
+        boolean routesEqual = true;
+        if(routes.length == cfg.routes.length) {
+            for (int i = 0; i < routes.length; ++i) {
+                if (!routes[i].equals(cfg.routes[i])) {
+                    routesEqual = false;
+                }
+            }
+        } else {
+            routesEqual = false;
+        }
+
         return nwid == cfg.nwid &&
                mac == cfg.mac &&
                name.equals(cfg.name) &&
@@ -78,7 +90,7 @@ public final class VirtualNetworkConfig implements Comparable<VirtualNetworkConf
                broadcastEnabled == cfg.broadcastEnabled &&
                portError == cfg.portError &&
                enabled == cfg.enabled &&
-               aaEqual;
+               aaEqual && routesEqual;
     }
 
     public int compareTo(VirtualNetworkConfig cfg) {
@@ -188,4 +200,11 @@ public final class VirtualNetworkConfig implements Comparable<VirtualNetworkConf
     public final InetSocketAddress[] assignedAddresses() {
         return assignedAddresses;
     }
+
+    /**
+     * ZeroTier-assigned routes (in {@link com.zerotier.sdk.VirtualNetworkRoute} objects)
+     *
+     * @return
+     */
+    public final VirtualNetworkRoute[] routes() { return routes; }
 }
diff --git a/java/src/com/zerotier/sdk/VirtualNetworkRoute.java b/java/src/com/zerotier/sdk/VirtualNetworkRoute.java
new file mode 100644
index 00000000..b89dce7b
--- /dev/null
+++ b/java/src/com/zerotier/sdk/VirtualNetworkRoute.java
@@ -0,0 +1,102 @@
+/*
+ * 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/
+ */
+
+package com.zerotier.sdk;
+
+import java.net.InetSocketAddress;
+
+public final class VirtualNetworkRoute implements Comparable<VirtualNetworkRoute>
+{
+	private VirtualNetworkRoute() {
+        target = null;
+        via = null;
+        flags = 0;
+        metric = 0;
+    }
+
+	/**
+	 * Target network / netmask bits (in port field) or NULL or 0.0.0.0/0 for default
+	 */
+	public InetSocketAddress target;
+
+	/**
+	 * Gateway IP address (port ignored) or NULL (family == 0) for LAN-local (no gateway)
+	 */
+	public InetSocketAddress via;
+
+	/**
+	 * Route flags
+	 */
+	public int flags;
+
+	/**
+	 * Route metric (not currently used)
+	 */
+	public int metric;
+
+
+    @Override
+	public int compareTo(VirtualNetworkRoute other) {
+        return target.toString().compareTo(other.target.toString());
+	}
+
+    public boolean equals(VirtualNetworkRoute other) {
+        boolean targetEquals;
+        if (target == null && other.target == null) {
+            targetEquals = true;
+        }
+        else if (target == null && other.target != null) {
+            targetEquals = false;
+        }
+        else if (target != null && other.target == null) {
+            targetEquals = false;
+        }
+        else {
+            targetEquals = target.equals(other.target);
+        }
+
+
+        boolean viaEquals;
+        if (via == null && other.via == null) {
+            viaEquals = true;
+        }
+        else if (via == null && other.via != null) {
+            viaEquals = false;
+        }
+        else if (via != null && other.via == null) {
+            viaEquals = false;
+        }
+        else {
+            viaEquals = via.equals(other.via);
+        }
+
+        return viaEquals &&
+                viaEquals &&
+                flags == other.flags &&
+                metric == other.metric;
+    }
+}