1.10.4 merge into main (#1893)

* add note about forceTcpRelay

* Create a sample systemd unit for tcp proxy

* set gitattributes for rust & cargo so hashes dont conflict on Windows

* Revert "set gitattributes for rust & cargo so hashes dont conflict on Windows"

This reverts commit 032dc5c108195f6bbc2e224f00da5b785df4b7f9.

* Turn off autocrlf for rust source

Doesn't appear to play nice well when it comes to git and vendored cargo package hashes

* Fix #1883 (#1886)

Still unknown as to why, but the call to `nc->GetProperties()` can fail
when setting a friendly name on the Windows virtual ethernet adapter.
Ensure that `ncp` is not null before continuing and accessing the device
GUID.

* Don't vendor packages for zeroidc (#1885)

* Added docker environment way to join networks (#1871)

* add StringUtils

* fix headers
use recommended headers and remove unused headers

* move extern "C"
only JNI functions need to be exported

* cleanup

* fix ANDROID-50: RESULT_ERROR_BAD_PARAMETER typo

* fix typo in log message

* fix typos in JNI method signatures

* fix typo

* fix ANDROID-51: fieldName is uninitialized

* fix ANDROID-35: memory leak

* fix missing DeleteLocalRef in loops

* update to use unique error codes

* add GETENV macro

* add LOG_TAG defines

* ANDROID-48: add ZT_jnicache.cpp

* ANDROID-48: use ZT_jnicache.cpp and remove ZT_jnilookup.cpp and ZT_jniarray.cpp

* add Event.fromInt

* add PeerRole.fromInt

* add ResultCode.fromInt

* fix ANDROID-36: issues with ResultCode

* add VirtualNetworkConfigOperation.fromInt

* fix ANDROID-40: VirtualNetworkConfigOperation out-of-sync with ZT_VirtualNetworkConfigOperation enum

* add VirtualNetworkStatus.fromInt

* fix ANDROID-37: VirtualNetworkStatus out-of-sync with ZT_VirtualNetworkStatus enum

* add VirtualNetworkType.fromInt

* make NodeStatus a plain data class

* fix ANDROID-52: synchronization bug with nodeMap

* Node init work: separate Node construction and init

* add Node.toString

* make PeerPhysicalPath a plain data class

* remove unused PeerPhysicalPath.fixed

* add array functions

* make Peer a plain data class

* make Version a plain data class

* fix ANDROID-42: copy/paste error

* fix ANDROID-49: VirtualNetworkConfig.equals is wrong

* reimplement VirtualNetworkConfig.equals

* reimplement VirtualNetworkConfig.compareTo

* add VirtualNetworkConfig.hashCode

* make VirtualNetworkConfig a plain data class

* remove unused VirtualNetworkConfig.enabled

* reimplement VirtualNetworkDNS.equals

* add VirtualNetworkDNS.hashCode

* make VirtualNetworkDNS a plain data class

* reimplement VirtualNetworkRoute.equals

* reimplement VirtualNetworkRoute.compareTo

* reimplement VirtualNetworkRoute.toString

* add VirtualNetworkRoute.hashCode

* make VirtualNetworkRoute a plain data class

* add isSocketAddressEmpty

* add addressPort

* add fromSocketAddressObject

* invert logic in a couple of places and return early

* newInetAddress and newInetSocketAddress work
allow newInetSocketAddress to return NULL if given empty address

* fix ANDROID-38: stack corruption in onSendPacketRequested

* use GETENV macro

* JniRef work
JniRef does not use callbacks struct, so remove
fix NewGlobalRef / DeleteGlobalRef mismatch

* use PRId64 macros

* switch statement work

* comments and logging

* Modifier 'public' is redundant for interface members

* NodeException can be made a checked Exception

* 'NodeException' does not define a 'serialVersionUID' field

* 'finalize()' should not be overridden
this is fine to do because ZeroTierOneService calls close() when it is done

* error handling, error reporting, asserts, logging

* simplify loadLibrary

* rename Node.networks -> Node.networkConfigs

* Windows file permissions fix (#1887)

* Allow macOS interfaces to use multiple IP addresses (#1879)

Co-authored-by: Sean OMeara <[email protected]>
Co-authored-by: Grant Limberg <[email protected]>

* Fix condition where full HELLOs might not be sent when necessary (#1877)

Co-authored-by: Grant Limberg <[email protected]>

* 1.10.4 version bumps

* Add security policy to repo (#1889)

* [+] add e2k64 arch (#1890)

* temp fix for ANDROID-56: crash inside newNetworkConfig from too many args

* 1.10.4 release notes

---------

Co-authored-by: travis laduke <[email protected]>
Co-authored-by: Grant Limberg <[email protected]>
Co-authored-by: Grant Limberg <[email protected]>
Co-authored-by: Leonardo Amaral <[email protected]>
Co-authored-by: Brenton Bostick <[email protected]>
Co-authored-by: Sean OMeara <[email protected]>
Co-authored-by: Joseph Henry <[email protected]>
Co-authored-by: Roman Peshkichev <[email protected]>

.github/workflows/build.yml

@@ -6,8 +6,8 @@ jobs:
     steps:
     - name: gitconfig
       run: |
-        git config --global core.autocrlf false
-        git config --global core.eol lf
+        git config --global core.autocrlf input
+      #        git config --global core.eol lf
     - name: checkout
       uses: actions/checkout@v3
     - name: Install Rust
@@ -42,8 +42,8 @@ jobs:
     steps:
     - name: gitconfig
       run: |
-        git config --global core.autocrlf false
-        git config --global core.eol lf
+        git config --global core.autocrlf input
+      #        git config --global core.eol lf
     - name: checkout
       uses: actions/checkout@v3
     - name: Install Rust
@@ -77,8 +77,8 @@ jobs:
     steps:
     - name: gitconfig
       run: |
-        git config --global core.autocrlf false
-        git config --global core.eol lf
+        git config --global core.autocrlf true
+      #        git config --global core.eol lf
     - name: checkout
       uses: actions/checkout@v3
     - name: Install Rust

README.docker.md

@@ -60,6 +60,7 @@ To ensure you have a network available before trying to listen on it. Without pr
 
 You can control a few settings including the identity used and the authtoken used to interact with the control socket (which you can forward and access through `localhost:9993`).
 
+- `ZEROTIER_JOIN_NETWORKS`: additional way to set networks to join.
 - `ZEROTIER_API_SECRET`: replaces the `authtoken.secret` before booting and allows you to manage the control socket's authentication key.
 - `ZEROTIER_IDENTITY_PUBLIC`: the `identity.public` file for zerotier-one. Use `zerotier-idtool` to generate one of these for you.
 - `ZEROTIER_IDENTITY_SECRET`: the `identity.secret` file for zerotier-one. Use `zerotier-idtool` to generate one of these for you.

RELEASE-NOTES.md

@@ -1,6 +1,19 @@
 ZeroTier Release Notes
 ======
 
+# 2023-03-07 -- Version 1.10.4
+
+ * SECURITY FIX (Windows): this version fixes a file permission problem on
+   Windows that could allow non-privileged users on a Windows system to read
+   privileged files in the ZeroTier service's working directory. This could
+   allow an unprivileged local Windows user to administrate the local ZeroTier
+   instance without appropriate local permissions. This issue is not remotely
+   exploitable unless a remote user can read arbitrary local files, and does
+   not impact other operating systems.
+
+ * Fix a bug in the handling of multiple IP address assignments to virtual
+   interfaces on macOS.
+
 # 2023-02-15 -- Version 1.10.3
 
  * Fix for duplicate paths in client. Could cause connectivity issues. Affects all platforms.

SECURITY.md

@@ -0,0 +1,95 @@
+# Security
+
+ZeroTier takes the security of our software products and services seriously, which 
+includes all source code repositories managed through our GitHub organization.
+
+## Supported Versions
+
+The following versions of ZeroTier One receive security updates
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.10.x   | :white_check_mark: |
+| 1.8.x   | :white_check_mark:  |
+| < 1.8.0 | :x: |
+
+## Reporting a Vulnerability
+
+**Please do not report security issues through public GitHub issues**
+
+Instead, please report vulnerabilities via email to [email protected]. If possible,
+please encrypt with our PGP key (see below).
+
+Please include the following information, or as much as you can provide to help us 
+understand the nature and scope of the issue:
+
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## [email protected] PGP key
+
+```
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=lheL
+-----END PGP PUBLIC KEY BLOCK-----
+```

debian/changelog

@@ -1,3 +1,9 @@
+zerotier-one (1.10.4) unstable; urgency=medium
+
+  * See RELEASE-NOTES.md for release notes.
+
+ -- Adam Ierymenko <[email protected]>  Mon, 06 Mar 2023 01:00:00 -0700
+
 zerotier-one (1.10.3) unstable; urgency=medium
 
   * See RELEASE-NOTES.md for release notes.

entrypoint.sh.release

@@ -71,13 +71,23 @@ trap killzerotier INT TERM
 log "Configuring networks to join"
 mkdir -p /var/lib/zerotier-one/networks.d
 
-log_params "Joining networks:" $@
+log_params "Joining networks from command line:" $@
 for i in "$@"
 do
   log_detail_params "Configuring join:" "$i"
   touch "/var/lib/zerotier-one/networks.d/${i}.conf"
 done
 
+if [ "x$ZEROTIER_JOIN_NETWORKS" != "x" ]
+then
+  log_params "Joining networks from environment:" $ZEROTIER_JOIN_NETWORKS
+  for i in "$ZEROTIER_JOIN_NETWORKS"
+  do
+    log_detail_params "Configuring join:" "$i"
+    touch "/var/lib/zerotier-one/networks.d/${i}.conf"
+  done
+fi
+
 log "Starting ZeroTier"
 nohup /usr/sbin/zerotier-one &
 

ext/installfiles/mac/ZeroTier One.pkgproj

@@ -701,7 +701,7 @@
 				<key>USE_HFS+_COMPRESSION</key>
 				<false/>
 				<key>VERSION</key>
-				<string>1.10.3</string>
+				<string>1.10.4</string>
 			</dict>
 			<key>TYPE</key>
 			<integer>0</integer>

java/jni/ZT_jniarray.cpp

@@ -1,112 +0,0 @@
-//
-// Created by Grant Limberg on 10/21/20.
-//
-
-#include "ZT_jniarray.h"
-#include <vector>
-#include <string>
-#include <cassert>
-
-jclass java_util_ArrayList;
-jmethodID java_util_ArrayList_;
-jmethodID java_util_ArrayList_size;
-jmethodID java_util_ArrayList_get;
-jmethodID java_util_ArrayList_add;
-
-void InitListJNI(JNIEnv* env) {
-    java_util_ArrayList      = static_cast<jclass>(env->NewGlobalRef(env->FindClass("java/util/ArrayList")));
-    java_util_ArrayList_     = env->GetMethodID(java_util_ArrayList, "<init>", "(I)V");
-    java_util_ArrayList_size = env->GetMethodID (java_util_ArrayList, "size", "()I");
-    java_util_ArrayList_get  = env->GetMethodID(java_util_ArrayList, "get", "(I)Ljava/lang/Object;");
-    java_util_ArrayList_add  = env->GetMethodID(java_util_ArrayList, "add", "(Ljava/lang/Object;)Z");
-}
-
-jclass ListJNI::getListClass(JNIEnv* env) {
-    jclass jclazz = env->FindClass("java/util/List");
-    assert(jclazz != nullptr);
-    return jclazz;
-}
-
-jclass ListJNI::getArrayListClass(JNIEnv* env) {
-    jclass jclazz = env->FindClass("java/util/ArrayList");
-    assert(jclazz != nullptr);
-    return jclazz;
-}
-
-jclass ListJNI::getIteratorClass(JNIEnv* env) {
-    jclass jclazz = env->FindClass("java/util/Iterator");
-    assert(jclazz != nullptr);
-    return jclazz;
-}
-
-jmethodID ListJNI::getIteratorMethod(JNIEnv* env) {
-    static jmethodID mid = env->GetMethodID(
-            getListClass(env), "iterator", "()Ljava/util/Iterator;");
-    assert(mid != nullptr);
-    return mid;
-}
-
-jmethodID ListJNI::getHasNextMethod(JNIEnv* env) {
-    static jmethodID mid = env->GetMethodID(
-            getIteratorClass(env), "hasNext", "()Z");
-    assert(mid != nullptr);
-    return mid;
-}
-
-jmethodID ListJNI::getNextMethod(JNIEnv* env) {
-    static jmethodID mid = env->GetMethodID(
-            getIteratorClass(env), "next", "()Ljava/lang/Object;");
-    assert(mid != nullptr);
-    return mid;
-}
-
-jmethodID ListJNI::getArrayListConstructorMethodId(JNIEnv* env, jclass jclazz) {
-    static jmethodID mid = env->GetMethodID(
-            jclazz, "<init>", "(I)V");
-    assert(mid != nullptr);
-    return mid;
-}
-
-jmethodID ListJNI::getListAddMethodId(JNIEnv* env) {
-    static jmethodID mid = env->GetMethodID(
-            getListClass(env), "add", "(Ljava/lang/Object;)Z");
-    assert(mid != nullptr);
-    return mid;
-}
-
-jclass ByteJNI::getByteClass(JNIEnv* env) {
-    jclass jclazz = env->FindClass("java/lang/Byte");
-    assert(jclazz != nullptr);
-    return jclazz;
-}
-
-jmethodID ByteJNI::getByteValueMethod(JNIEnv* env) {
-    static jmethodID mid = env->GetMethodID(
-            getByteClass(env), "byteValue", "()B");
-    assert(mid != nullptr);
-    return mid;
-}
-
-jobject cppToJava(JNIEnv* env, std::vector<std::string> vector) {
-    jobject result = env->NewObject(java_util_ArrayList, java_util_ArrayList_, vector.size());
-    for (std::string s: vector) {
-        jstring element = env->NewStringUTF(s.c_str());
-        env->CallBooleanMethod(result, java_util_ArrayList_add, element);
-        env->DeleteLocalRef(element);
-    }
-    return result;
-}
-
-std::vector<std::string> javaToCpp(JNIEnv* env, jobject arrayList) {
-    jint len = env->CallIntMethod(arrayList, java_util_ArrayList_size);
-    std::vector<std::string> result;
-    result.reserve(len);
-    for (jint i=0; i<len; i++) {
-        jstring element = static_cast<jstring>(env->CallObjectMethod(arrayList, java_util_ArrayList_get, i));
-        const char* pchars = env->GetStringUTFChars(element, nullptr);
-        result.emplace_back(pchars);
-        env->ReleaseStringUTFChars(element, pchars);
-        env->DeleteLocalRef(element);
-    }
-    return result;
-}

java/jni/ZT_jniarray.h

@@ -1,60 +0,0 @@
-//
-// Created by Grant Limberg on 10/21/20.
-//
-
-#ifndef ZEROTIERANDROID_ZT_JNIARRAY_H
-#define ZEROTIERANDROID_ZT_JNIARRAY_H
-
-#include <jni.h>
-#include <vector>
-#include <string>
-
-extern jclass java_util_ArrayList;
-extern jmethodID java_util_ArrayList_;
-extern jmethodID java_util_ArrayList_size;
-extern jmethodID java_util_ArrayList_get;
-extern jmethodID java_util_ArrayList_add;
-
-void InitListJNI(JNIEnv* env);
-
-class ListJNI {
-public:
-    // Get the java class id of java.util.List.
-    static jclass getListClass(JNIEnv* env);
-
-    // Get the java class id of java.util.ArrayList.
-    static jclass getArrayListClass(JNIEnv* env);
-
-    // Get the java class id of java.util.Iterator.
-    static jclass getIteratorClass(JNIEnv* env);
-
-    // Get the java method id of java.util.List.iterator().
-    static jmethodID getIteratorMethod(JNIEnv* env);
-
-    // Get the java method id of java.util.Iterator.hasNext().
-    static jmethodID getHasNextMethod(JNIEnv* env);
-
-    // Get the java method id of java.util.Iterator.next().
-    static jmethodID getNextMethod(JNIEnv* env);
-
-    // Get the java method id of arrayList constructor.
-    static jmethodID getArrayListConstructorMethodId(JNIEnv* env, jclass jclazz);
-
-    // Get the java method id of java.util.List.add().
-    static jmethodID getListAddMethodId(JNIEnv* env);
-};
-
-class ByteJNI {
-public:
-    // Get the java class id of java.lang.Byte.
-    static jclass getByteClass(JNIEnv* env);
-
-    // Get the java method id of java.lang.Byte.byteValue.
-    static jmethodID getByteValueMethod(JNIEnv* env);
-};
-
-jobject cppToJava(JNIEnv* env, std::vector<std::string> vector);
-
-std::vector<std::string> javaToCpp(JNIEnv* env, jobject arrayList);
-
-#endif //ZEROTIERANDROID_ZT_JNIARRAY_H

java/jni/ZT_jnicache.cpp

@@ -0,0 +1,244 @@
+//
+// Created by Brenton Bostick on 1/18/23.
+//
+
+#include "ZT_jnicache.h"
+
+#include "ZT_jniutils.h"
+
+#include <cassert>
+
+#define LOG_TAG "Cache"
+
+#define EXCEPTIONANDNULLCHECK(var) \
+    do { \
+        if (env->ExceptionCheck()) { \
+            assert(false && "Exception"); \
+        } \
+        if ((var) == NULL) { \
+            assert(false && #var " is NULL"); \
+        } \
+    } while (false)
+
+#define SETCLASS(classVar, classNameString) \
+	do { \
+        jclass classVar ## _local = env->FindClass(classNameString); \
+        EXCEPTIONANDNULLCHECK(classVar ## _local); \
+        classVar = reinterpret_cast<jclass>(env->NewGlobalRef(classVar ## _local)); \
+        EXCEPTIONANDNULLCHECK(classVar); \
+        env->DeleteLocalRef(classVar ## _local); \
+    } while (false)
+
+#define SETOBJECT(objectVar, code) \
+	do { \
+        jobject objectVar ## _local = code; \
+        EXCEPTIONANDNULLCHECK(objectVar ## _local); \
+        objectVar = env->NewGlobalRef(objectVar ## _local); \
+        EXCEPTIONANDNULLCHECK(objectVar); \
+        env->DeleteLocalRef(objectVar ## _local); \
+    } while (false)
+
+
+//
+// Classes
+//
+
+jclass ArrayList_class;
+jclass DataStoreGetListener_class;
+jclass DataStorePutListener_class;
+jclass EventListener_class;
+jclass Event_class;
+jclass Inet4Address_class;
+jclass Inet6Address_class;
+jclass InetAddress_class;
+jclass InetSocketAddress_class;
+jclass NodeStatus_class;
+jclass Node_class;
+jclass PacketSender_class;
+jclass PathChecker_class;
+jclass PeerPhysicalPath_class;
+jclass PeerRole_class;
+jclass Peer_class;
+jclass ResultCode_class;
+jclass Version_class;
+jclass VirtualNetworkConfigListener_class;
+jclass VirtualNetworkConfigOperation_class;
+jclass VirtualNetworkConfig_class;
+jclass VirtualNetworkDNS_class;
+jclass VirtualNetworkFrameListener_class;
+jclass VirtualNetworkRoute_class;
+jclass VirtualNetworkStatus_class;
+jclass VirtualNetworkType_class;
+
+//
+// Instance methods
+//
+
+jmethodID ArrayList_add_method;
+jmethodID ArrayList_ctor;
+jmethodID DataStoreGetListener_onDataStoreGet_method;
+jmethodID DataStorePutListener_onDataStorePut_method;
+jmethodID DataStorePutListener_onDelete_method;
+jmethodID EventListener_onEvent_method;
+jmethodID EventListener_onTrace_method;
+jmethodID InetAddress_getAddress_method;
+jmethodID InetSocketAddress_ctor;
+jmethodID InetSocketAddress_getAddress_method;
+jmethodID InetSocketAddress_getPort_method;
+jmethodID NodeStatus_ctor;
+jmethodID PacketSender_onSendPacketRequested_method;
+jmethodID PathChecker_onPathCheck_method;
+jmethodID PathChecker_onPathLookup_method;
+jmethodID PeerPhysicalPath_ctor;
+jmethodID Peer_ctor;
+jmethodID Version_ctor;
+jmethodID VirtualNetworkConfigListener_onNetworkConfigurationUpdated_method;
+jmethodID VirtualNetworkConfig_ctor;
+jmethodID VirtualNetworkDNS_ctor;
+jmethodID VirtualNetworkFrameListener_onVirtualNetworkFrame_method;
+jmethodID VirtualNetworkRoute_ctor;
+
+//
+// Static methods
+//
+
+jmethodID Event_fromInt_method;
+jmethodID InetAddress_getByAddress_method;
+jmethodID PeerRole_fromInt_method;
+jmethodID ResultCode_fromInt_method;
+jmethodID VirtualNetworkConfigOperation_fromInt_method;
+jmethodID VirtualNetworkStatus_fromInt_method;
+jmethodID VirtualNetworkType_fromInt_method;
+
+//
+// Enums
+//
+
+jobject ResultCode_RESULT_FATAL_ERROR_INTERNAL_enum;
+jobject ResultCode_RESULT_OK_enum;
+
+void setupJNICache(JavaVM *vm) {
+
+    JNIEnv *env;
+    GETENV(env, vm);
+
+    //
+    // Classes
+    //
+
+    SETCLASS(ArrayList_class, "java/util/ArrayList");
+    SETCLASS(DataStoreGetListener_class, "com/zerotier/sdk/DataStoreGetListener");
+    SETCLASS(DataStorePutListener_class, "com/zerotier/sdk/DataStorePutListener");
+    SETCLASS(EventListener_class, "com/zerotier/sdk/EventListener");
+    SETCLASS(Event_class, "com/zerotier/sdk/Event");
+    SETCLASS(Inet4Address_class, "java/net/Inet4Address");
+    SETCLASS(Inet6Address_class, "java/net/Inet6Address");
+    SETCLASS(InetAddress_class, "java/net/InetAddress");
+    SETCLASS(InetSocketAddress_class, "java/net/InetSocketAddress");
+    SETCLASS(NodeStatus_class, "com/zerotier/sdk/NodeStatus");
+    SETCLASS(Node_class, "com/zerotier/sdk/Node");
+    SETCLASS(PacketSender_class, "com/zerotier/sdk/PacketSender");
+    SETCLASS(PathChecker_class, "com/zerotier/sdk/PathChecker");
+    SETCLASS(PeerPhysicalPath_class, "com/zerotier/sdk/PeerPhysicalPath");
+    SETCLASS(PeerRole_class, "com/zerotier/sdk/PeerRole");
+    SETCLASS(Peer_class, "com/zerotier/sdk/Peer");
+    SETCLASS(ResultCode_class, "com/zerotier/sdk/ResultCode");
+    SETCLASS(Version_class, "com/zerotier/sdk/Version");
+    SETCLASS(VirtualNetworkConfigListener_class, "com/zerotier/sdk/VirtualNetworkConfigListener");
+    SETCLASS(VirtualNetworkConfigOperation_class, "com/zerotier/sdk/VirtualNetworkConfigOperation");
+    SETCLASS(VirtualNetworkConfig_class, "com/zerotier/sdk/VirtualNetworkConfig");
+    SETCLASS(VirtualNetworkDNS_class, "com/zerotier/sdk/VirtualNetworkDNS");
+    SETCLASS(VirtualNetworkFrameListener_class, "com/zerotier/sdk/VirtualNetworkFrameListener");
+    SETCLASS(VirtualNetworkRoute_class, "com/zerotier/sdk/VirtualNetworkRoute");
+    SETCLASS(VirtualNetworkStatus_class, "com/zerotier/sdk/VirtualNetworkStatus");
+    SETCLASS(VirtualNetworkType_class, "com/zerotier/sdk/VirtualNetworkType");
+
+    //
+    // Instance methods
+    //
+
+    EXCEPTIONANDNULLCHECK(ArrayList_add_method = env->GetMethodID(ArrayList_class, "add", "(Ljava/lang/Object;)Z"));
+    EXCEPTIONANDNULLCHECK(ArrayList_ctor = env->GetMethodID(ArrayList_class, "<init>", "(I)V"));
+    EXCEPTIONANDNULLCHECK(DataStoreGetListener_onDataStoreGet_method = env->GetMethodID(DataStoreGetListener_class, "onDataStoreGet", "(Ljava/lang/String;[B)J"));
+    EXCEPTIONANDNULLCHECK(DataStorePutListener_onDataStorePut_method = env->GetMethodID(DataStorePutListener_class, "onDataStorePut", "(Ljava/lang/String;[BZ)I"));
+    EXCEPTIONANDNULLCHECK(DataStorePutListener_onDelete_method = env->GetMethodID(DataStorePutListener_class, "onDelete", "(Ljava/lang/String;)I"));
+    EXCEPTIONANDNULLCHECK(EventListener_onEvent_method = env->GetMethodID(EventListener_class, "onEvent", "(Lcom/zerotier/sdk/Event;)V"));
+    EXCEPTIONANDNULLCHECK(EventListener_onTrace_method = env->GetMethodID(EventListener_class, "onTrace", "(Ljava/lang/String;)V"));
+    EXCEPTIONANDNULLCHECK(InetAddress_getAddress_method = env->GetMethodID(InetAddress_class, "getAddress", "()[B"));
+    EXCEPTIONANDNULLCHECK(InetSocketAddress_ctor = env->GetMethodID(InetSocketAddress_class, "<init>", "(Ljava/net/InetAddress;I)V"));
+    EXCEPTIONANDNULLCHECK(InetSocketAddress_getAddress_method = env->GetMethodID(InetSocketAddress_class, "getAddress", "()Ljava/net/InetAddress;"));
+    EXCEPTIONANDNULLCHECK(InetSocketAddress_getPort_method = env->GetMethodID(InetSocketAddress_class, "getPort", "()I"));
+    EXCEPTIONANDNULLCHECK(NodeStatus_ctor = env->GetMethodID(NodeStatus_class, "<init>", "(JLjava/lang/String;Ljava/lang/String;Z)V"));
+    EXCEPTIONANDNULLCHECK(PacketSender_onSendPacketRequested_method = env->GetMethodID(PacketSender_class, "onSendPacketRequested", "(JLjava/net/InetSocketAddress;[BI)I"));
+    EXCEPTIONANDNULLCHECK(PathChecker_onPathCheck_method = env->GetMethodID(PathChecker_class, "onPathCheck", "(JJLjava/net/InetSocketAddress;)Z"));
+    EXCEPTIONANDNULLCHECK(PathChecker_onPathLookup_method = env->GetMethodID(PathChecker_class, "onPathLookup", "(JI)Ljava/net/InetSocketAddress;"));
+    EXCEPTIONANDNULLCHECK(PeerPhysicalPath_ctor = env->GetMethodID(PeerPhysicalPath_class, "<init>", "(Ljava/net/InetSocketAddress;JJZ)V"));
+    EXCEPTIONANDNULLCHECK(Peer_ctor = env->GetMethodID(Peer_class, "<init>", "(JIIIILcom/zerotier/sdk/PeerRole;[Lcom/zerotier/sdk/PeerPhysicalPath;)V"));
+    EXCEPTIONANDNULLCHECK(Version_ctor = env->GetMethodID(Version_class, "<init>", "(III)V"));
+    EXCEPTIONANDNULLCHECK(VirtualNetworkConfigListener_onNetworkConfigurationUpdated_method = env->GetMethodID(VirtualNetworkConfigListener_class, "onNetworkConfigurationUpdated", "(JLcom/zerotier/sdk/VirtualNetworkConfigOperation;Lcom/zerotier/sdk/VirtualNetworkConfig;)I"));
+
+
+    //
+    // ANDROID-56: temporarily remove parameters to prevent crashing
+    //
+//    EXCEPTIONANDNULLCHECK(VirtualNetworkConfig_ctor = env->GetMethodID(VirtualNetworkConfig_class, "<init>", "(JJLjava/lang/String;Lcom/zerotier/sdk/VirtualNetworkStatus;Lcom/zerotier/sdk/VirtualNetworkType;IZZZIJ[Ljava/net/InetSocketAddress;[Lcom/zerotier/sdk/VirtualNetworkRoute;Lcom/zerotier/sdk/VirtualNetworkDNS;)V"));
+    EXCEPTIONANDNULLCHECK(VirtualNetworkConfig_ctor = env->GetMethodID(VirtualNetworkConfig_class, "<init>", "(JJLjava/lang/String;Lcom/zerotier/sdk/VirtualNetworkStatus;Lcom/zerotier/sdk/VirtualNetworkType;IZZZ[Ljava/net/InetSocketAddress;[Lcom/zerotier/sdk/VirtualNetworkRoute;Lcom/zerotier/sdk/VirtualNetworkDNS;)V"));
+
+
+    EXCEPTIONANDNULLCHECK(VirtualNetworkDNS_ctor = env->GetMethodID(VirtualNetworkDNS_class, "<init>", "(Ljava/lang/String;Ljava/util/ArrayList;)V"));
+    EXCEPTIONANDNULLCHECK(VirtualNetworkFrameListener_onVirtualNetworkFrame_method = env->GetMethodID(VirtualNetworkFrameListener_class, "onVirtualNetworkFrame", "(JJJJJ[B)V"));
+    EXCEPTIONANDNULLCHECK(VirtualNetworkRoute_ctor = env->GetMethodID(VirtualNetworkRoute_class, "<init>", "(Ljava/net/InetSocketAddress;Ljava/net/InetSocketAddress;II)V"));
+
+    //
+    // Static methods
+    //
+
+    EXCEPTIONANDNULLCHECK(Event_fromInt_method = env->GetStaticMethodID(Event_class, "fromInt", "(I)Lcom/zerotier/sdk/Event;"));
+    EXCEPTIONANDNULLCHECK(InetAddress_getByAddress_method = env->GetStaticMethodID(InetAddress_class, "getByAddress", "([B)Ljava/net/InetAddress;"));
+    EXCEPTIONANDNULLCHECK(PeerRole_fromInt_method = env->GetStaticMethodID(PeerRole_class, "fromInt", "(I)Lcom/zerotier/sdk/PeerRole;"));
+    EXCEPTIONANDNULLCHECK(ResultCode_fromInt_method = env->GetStaticMethodID(ResultCode_class, "fromInt", "(I)Lcom/zerotier/sdk/ResultCode;"));
+    EXCEPTIONANDNULLCHECK(VirtualNetworkConfigOperation_fromInt_method = env->GetStaticMethodID(VirtualNetworkConfigOperation_class, "fromInt", "(I)Lcom/zerotier/sdk/VirtualNetworkConfigOperation;"));
+    EXCEPTIONANDNULLCHECK(VirtualNetworkStatus_fromInt_method = env->GetStaticMethodID(VirtualNetworkStatus_class, "fromInt", "(I)Lcom/zerotier/sdk/VirtualNetworkStatus;"));
+    EXCEPTIONANDNULLCHECK(VirtualNetworkType_fromInt_method = env->GetStaticMethodID(VirtualNetworkType_class, "fromInt", "(I)Lcom/zerotier/sdk/VirtualNetworkType;"));
+
+    //
+    // Enums
+    //
+
+    SETOBJECT(ResultCode_RESULT_FATAL_ERROR_INTERNAL_enum, createResultObject(env, ZT_RESULT_FATAL_ERROR_INTERNAL));
+    SETOBJECT(ResultCode_RESULT_OK_enum, createResultObject(env, ZT_RESULT_OK));
+}
+
+void teardownJNICache(JavaVM *vm) {
+
+    JNIEnv *env;
+    GETENV(env, vm);
+
+    env->DeleteGlobalRef(ArrayList_class);
+    env->DeleteGlobalRef(DataStoreGetListener_class);
+    env->DeleteGlobalRef(DataStorePutListener_class);
+    env->DeleteGlobalRef(EventListener_class);
+    env->DeleteGlobalRef(Event_class);
+    env->DeleteGlobalRef(InetAddress_class);
+    env->DeleteGlobalRef(InetSocketAddress_class);
+    env->DeleteGlobalRef(NodeStatus_class);
+    env->DeleteGlobalRef(Node_class);
+    env->DeleteGlobalRef(PacketSender_class);
+    env->DeleteGlobalRef(PathChecker_class);
+    env->DeleteGlobalRef(PeerPhysicalPath_class);
+    env->DeleteGlobalRef(PeerRole_class);
+    env->DeleteGlobalRef(Peer_class);
+    env->DeleteGlobalRef(ResultCode_class);
+    env->DeleteGlobalRef(Version_class);
+    env->DeleteGlobalRef(VirtualNetworkConfigListener_class);
+    env->DeleteGlobalRef(VirtualNetworkConfigOperation_class);
+    env->DeleteGlobalRef(VirtualNetworkConfig_class);
+    env->DeleteGlobalRef(VirtualNetworkDNS_class);
+    env->DeleteGlobalRef(VirtualNetworkFrameListener_class);
+    env->DeleteGlobalRef(VirtualNetworkRoute_class);
+    env->DeleteGlobalRef(VirtualNetworkStatus_class);
+    env->DeleteGlobalRef(VirtualNetworkType_class);
+
+    env->DeleteGlobalRef(ResultCode_RESULT_FATAL_ERROR_INTERNAL_enum);
+    env->DeleteGlobalRef(ResultCode_RESULT_OK_enum);
+}

java/jni/ZT_jnicache.h

@@ -0,0 +1,92 @@
+//
+// Created by Brenton Bostick on 1/18/23.
+//
+
+#ifndef ZEROTIERANDROID_JNICACHE_H
+#define ZEROTIERANDROID_JNICACHE_H
+
+#include <jni.h>
+
+
+//
+// Classes
+//
+
+extern jclass ArrayList_class;
+extern jclass DataStoreGetListener_class;
+extern jclass DataStorePutListener_class;
+extern jclass EventListener_class;
+extern jclass Event_class;
+extern jclass Inet4Address_class;
+extern jclass Inet6Address_class;
+extern jclass InetAddress_class;
+extern jclass InetSocketAddress_class;
+extern jclass NodeStatus_class;
+extern jclass Node_class;
+extern jclass PacketSender_class;
+extern jclass PathChecker_class;
+extern jclass PeerPhysicalPath_class;
+extern jclass PeerRole_class;
+extern jclass Peer_class;
+extern jclass ResultCode_class;
+extern jclass Version_class;
+extern jclass VirtualNetworkConfigListener_class;
+extern jclass VirtualNetworkConfigOperation_class;
+extern jclass VirtualNetworkConfig_class;
+extern jclass VirtualNetworkDNS_class;
+extern jclass VirtualNetworkFrameListener_class;
+extern jclass VirtualNetworkRoute_class;
+extern jclass VirtualNetworkStatus_class;
+extern jclass VirtualNetworkType_class;
+
+//
+// Instance methods
+//
+
+extern jmethodID ArrayList_add_method;
+extern jmethodID ArrayList_ctor;
+extern jmethodID DataStoreGetListener_onDataStoreGet_method;
+extern jmethodID DataStorePutListener_onDataStorePut_method;
+extern jmethodID DataStorePutListener_onDelete_method;
+extern jmethodID EventListener_onEvent_method;
+extern jmethodID EventListener_onTrace_method;
+extern jmethodID InetAddress_getAddress_method;
+extern jmethodID InetSocketAddress_ctor;
+extern jmethodID InetSocketAddress_getAddress_method;
+extern jmethodID InetSocketAddress_getPort_method;
+extern jmethodID NodeStatus_ctor;
+extern jmethodID PacketSender_onSendPacketRequested_method;
+extern jmethodID PathChecker_onPathCheck_method;
+extern jmethodID PathChecker_onPathLookup_method;
+extern jmethodID PeerPhysicalPath_ctor;
+extern jmethodID Peer_ctor;
+extern jmethodID Version_ctor;
+extern jmethodID VirtualNetworkConfigListener_onNetworkConfigurationUpdated_method;
+extern jmethodID VirtualNetworkConfig_ctor;
+extern jmethodID VirtualNetworkDNS_ctor;
+extern jmethodID VirtualNetworkFrameListener_onVirtualNetworkFrame_method;
+extern jmethodID VirtualNetworkRoute_ctor;
+
+//
+// Static methods
+//
+
+extern jmethodID Event_fromInt_method;
+extern jmethodID InetAddress_getByAddress_method;
+extern jmethodID PeerRole_fromInt_method;
+extern jmethodID ResultCode_fromInt_method;
+extern jmethodID VirtualNetworkConfigOperation_fromInt_method;
+extern jmethodID VirtualNetworkStatus_fromInt_method;
+extern jmethodID VirtualNetworkType_fromInt_method;
+
+//
+// Enums
+//
+
+extern jobject ResultCode_RESULT_FATAL_ERROR_INTERNAL_enum;
+extern jobject ResultCode_RESULT_OK_enum;
+
+void setupJNICache(JavaVM *vm);
+void teardownJNICache(JavaVM *vm);
+
+#endif // ZEROTIERANDROID_JNICACHE_H

java/jni/ZT_jnilookup.cpp

@@ -1,158 +0,0 @@
-/*
- * 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/
- */
-
-#include "ZT_jnilookup.h"
-#include "ZT_jniutils.h"
-
-JniLookup::JniLookup()
-    : m_jvm(NULL)
-{
-    LOGV("JNI Cache Created");
-}
-
-JniLookup::JniLookup(JavaVM *jvm)
-    : m_jvm(jvm)
-{
-    LOGV("JNI Cache Created");
-}
-
-JniLookup::~JniLookup()
-{
-    LOGV("JNI Cache Destroyed");
-}
-
-
-void JniLookup::setJavaVM(JavaVM *jvm)
-{ 
-    LOGV("Assigned JVM to object");
-    m_jvm = jvm; 
-}
-
-
-jclass JniLookup::findClass(const std::string &name)
-{
-    if(!m_jvm)
-        return NULL;
-
-    // get the class from the JVM
-    JNIEnv *env = NULL;
-    if(m_jvm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK)
-    {
-        LOGE("Error retrieving JNI Environment");
-        return NULL;
-    }
-    const char *c = name.c_str();
-    jclass cls = env->FindClass(c);
-    if(env->ExceptionCheck())
-    {
-        LOGE("Error finding class: %s", name.c_str());
-        return NULL;
-    }
-
-    return cls;
-}
-
-
-jmethodID JniLookup::findMethod(jclass cls, const std::string &methodName, const std::string &methodSig)
-{
-    if(!m_jvm)
-        return NULL;
-
-    JNIEnv *env = NULL;
-    if(m_jvm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK)
-    {
-        return NULL;
-    }
-
-    jmethodID mid = env->GetMethodID(cls, methodName.c_str(), methodSig.c_str());
-    if(env->ExceptionCheck())
-    {
-        return NULL;
-    }
-
-    return mid;
-}
-
-jmethodID JniLookup::findStaticMethod(jclass cls, const std::string &methodName, const std::string &methodSig)
-{
-    if(!m_jvm)
-        return NULL;
-
-    JNIEnv *env = NULL;
-    if(m_jvm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK)
-    {
-        return NULL;
-    }
-
-    jmethodID mid = env->GetStaticMethodID(cls, methodName.c_str(), methodSig.c_str());
-    if(env->ExceptionCheck())
-    {
-        return NULL;
-    }
-
-    return mid;
-}
-
-jfieldID JniLookup::findField(jclass cls, const std::string &fieldName, const std::string &typeStr)
-{
-    if(!m_jvm)
-        return NULL;
-
-    JNIEnv *env = NULL;
-    if(m_jvm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK)
-    {
-        return NULL;
-    }
-
-    jfieldID fid = env->GetFieldID(cls, fieldName.c_str(), typeStr.c_str());
-    if(env->ExceptionCheck())
-    {
-        return NULL;
-    }
-
-    return fid;
-}
-
-jfieldID JniLookup::findStaticField(jclass cls, const std::string &fieldName, const std::string &typeStr)
-{
-    if(!m_jvm)
-        return NULL;
-
-    JNIEnv *env = NULL;
-    if(m_jvm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK)
-    {
-        return NULL;
-    }
-
-    jfieldID fid = env->GetStaticFieldID(cls, fieldName.c_str(), typeStr.c_str());
-    if(env->ExceptionCheck())
-    {
-        return NULL;
-    }
-
-    return fid;
-}

java/jni/ZT_jnilookup.h

@@ -1,54 +0,0 @@
-/*
- * 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/
- */
-
-#ifndef ZT_JNILOOKUP_H_
-#define ZT_JNILOOKUP_H_
-
-#include <jni.h>
-#include <map>
-#include <string>
-
-
-
-class JniLookup {
-public:
-    JniLookup();
-    JniLookup(JavaVM *jvm);
-    ~JniLookup();
-
-    void setJavaVM(JavaVM *jvm);
-
-    jclass findClass(const std::string &name);
-    jmethodID findMethod(jclass cls, const std::string &methodName, const std::string &methodSig);
-    jmethodID findStaticMethod(jclass cls, const std::string &methodName, const std::string &methodSig);
-    jfieldID findField(jclass cls, const std::string &fieldName, const std::string &typeStr);
-    jfieldID findStaticField(jclass cls, const std::string &fieldName, const std::string &typeStr);
-private:
-    JavaVM *m_jvm;
-};
-
-#endif

java/jni/ZT_jniutils.cpp

@@ -17,322 +17,123 @@
  */
 
 #include "ZT_jniutils.h"
-#include "ZT_jnilookup.h"
-#include "ZT_jniarray.h"
+
+#include "ZT_jnicache.h"
 
 #include <string>
-#include <assert.h>
+#include <cassert>
 
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <sys/types.h>
-#include <sys/socket.h>
-
-extern JniLookup lookup;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#define LOG_TAG "Utils"
 
 jobject createResultObject(JNIEnv *env, ZT_ResultCode code)
 {
-    jclass resultClass = NULL;
-
-    jobject resultObject = NULL;
-
-    resultClass = lookup.findClass("com/zerotier/sdk/ResultCode");
-    if(resultClass == NULL)
-    {
-        LOGE("Couldn't find ResultCode class");
-        return NULL; // exception thrown
-    }
-
-    std::string fieldName;
-    switch(code)
-    {
-    case ZT_RESULT_OK:
-    case ZT_RESULT_OK_IGNORED:
-        LOGV("ZT_RESULT_OK");
-        fieldName = "RESULT_OK";
-        break;
-    case ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY:
-        LOGV("ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY");
-        fieldName = "RESULT_FATAL_ERROR_OUT_OF_MEMORY";
-        break;
-    case ZT_RESULT_FATAL_ERROR_DATA_STORE_FAILED:
-        LOGV("RESULT_FATAL_ERROR_DATA_STORE_FAILED");
-        fieldName = "RESULT_FATAL_ERROR_DATA_STORE_FAILED";
-        break;
-    case ZT_RESULT_ERROR_NETWORK_NOT_FOUND:
-        LOGV("ZT_RESULT_ERROR_NETWORK_NOT_FOUND");
-        fieldName = "RESULT_ERROR_NETWORK_NOT_FOUND";
-        break;
-    case ZT_RESULT_ERROR_UNSUPPORTED_OPERATION:
-        LOGV("ZT_RESULT_ERROR_UNSUPPORTED_OPERATION");
-        fieldName = "RESULT_ERROR_UNSUPPORTED_OPERATION";
-        break;
-    case ZT_RESULT_ERROR_BAD_PARAMETER:
-        LOGV("ZT_RESULT_ERROR_BAD_PARAMETER");
-        fieldName = "ZT_RESULT_ERROR_BAD_PARAMETER";
-        break;
-    case ZT_RESULT_FATAL_ERROR_INTERNAL:
-    default:
-        LOGV("ZT_RESULT_FATAL_ERROR_INTERNAL");
-        fieldName = "RESULT_FATAL_ERROR_INTERNAL";
-        break;
-    }
-
-    jfieldID enumField = lookup.findStaticField(resultClass, fieldName.c_str(), "Lcom/zerotier/sdk/ResultCode;");
-    if(env->ExceptionCheck() || enumField == NULL)
-    {
-        LOGE("Error on FindStaticField");
+    jobject resultObject = env->CallStaticObjectMethod(ResultCode_class, ResultCode_fromInt_method, code);
+    if(env->ExceptionCheck() || resultObject == NULL) {
+        LOGE("Error creating ResultCode object");
         return NULL;
     }
 
-    resultObject = env->GetStaticObjectField(resultClass, enumField);
-    if(env->ExceptionCheck() || resultObject == NULL)
-    {
-        LOGE("Error on GetStaticObjectField");
-    }
     return resultObject;
 }
 
 
 jobject createVirtualNetworkStatus(JNIEnv *env, ZT_VirtualNetworkStatus status)
 {
-    jobject statusObject = NULL;
-
-    jclass statusClass = lookup.findClass("com/zerotier/sdk/VirtualNetworkStatus");
-    if(statusClass == NULL)
-    {
-        return NULL; // exception thrown
-    }
-
-    std::string fieldName;
-    switch(status)
-    {
-    case ZT_NETWORK_STATUS_REQUESTING_CONFIGURATION:
-        fieldName = "NETWORK_STATUS_REQUESTING_CONFIGURATION";
-        break;
-    case ZT_NETWORK_STATUS_OK:
-        fieldName = "NETWORK_STATUS_OK";
-        break;
-    case ZT_NETWORK_STATUS_AUTHENTICATION_REQUIRED:
-        fieldName = "NETWORK_STATUS_AUTHENTICATION_REQUIRED";
-        break;
-    case ZT_NETWORK_STATUS_ACCESS_DENIED:
-        fieldName = "NETWORK_STATUS_ACCESS_DENIED";
-        break;
-    case ZT_NETWORK_STATUS_NOT_FOUND:
-        fieldName = "NETWORK_STATUS_NOT_FOUND";
-        break;
-    case ZT_NETWORK_STATUS_PORT_ERROR:
-        fieldName = "NETWORK_STATUS_PORT_ERROR";
-        break;
-    case ZT_NETWORK_STATUS_CLIENT_TOO_OLD:
-        fieldName = "NETWORK_STATUS_CLIENT_TOO_OLD";
-        break;
+    jobject statusObject = env->CallStaticObjectMethod(VirtualNetworkStatus_class, VirtualNetworkStatus_fromInt_method, status);
+    if (env->ExceptionCheck() || statusObject == NULL) {
+        LOGE("Error creating VirtualNetworkStatus object");
+        return NULL;
     }
 
-    jfieldID enumField = lookup.findStaticField(statusClass, fieldName.c_str(), "Lcom/zerotier/sdk/VirtualNetworkStatus;");
-
-    statusObject = env->GetStaticObjectField(statusClass, enumField);
-
     return statusObject;
 }
 
 jobject createEvent(JNIEnv *env, ZT_Event event)
 {
-    jclass eventClass = NULL;
-    jobject eventObject = NULL;
-
-    eventClass = lookup.findClass("com/zerotier/sdk/Event");
-    if(eventClass == NULL)
-    {
+    jobject eventObject = env->CallStaticObjectMethod(Event_class, Event_fromInt_method, event);
+    if (env->ExceptionCheck() || eventObject == NULL) {
+        LOGE("Error creating Event object");
         return NULL;
     }
 
-    std::string fieldName;
-    switch(event)
-    {
-    case ZT_EVENT_UP:
-        fieldName = "EVENT_UP";
-        break;
-    case ZT_EVENT_OFFLINE:
-        fieldName = "EVENT_OFFLINE";
-        break;
-    case ZT_EVENT_ONLINE:
-        fieldName = "EVENT_ONLINE";
-        break;
-    case ZT_EVENT_DOWN:
-        fieldName = "EVENT_DOWN";
-        break;
-    case ZT_EVENT_FATAL_ERROR_IDENTITY_COLLISION:
-        fieldName = "EVENT_FATAL_ERROR_IDENTITY_COLLISION";
-        break;
-    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;");
-
-    eventObject = env->GetStaticObjectField(eventClass, enumField);
-
     return eventObject;
 }
 
 jobject createPeerRole(JNIEnv *env, ZT_PeerRole role)
 {
-    jclass peerRoleClass = NULL;
-    jobject peerRoleObject = NULL;
-
-    peerRoleClass = lookup.findClass("com/zerotier/sdk/PeerRole");
-    if(peerRoleClass == NULL)
-    {
+    jobject peerRoleObject = env->CallStaticObjectMethod(PeerRole_class, PeerRole_fromInt_method, role);
+    if (env->ExceptionCheck() || peerRoleObject == NULL) {
+        LOGE("Error creating PeerRole object");
         return NULL;
     }
 
-    std::string fieldName;
-    switch(role)
-    {
-    case ZT_PEER_ROLE_LEAF:
-        fieldName = "PEER_ROLE_LEAF";
-        break;
-    case ZT_PEER_ROLE_MOON:
-        fieldName = "PEER_ROLE_MOON";
-        break;
-    case ZT_PEER_ROLE_PLANET:
-        fieldName = "PEER_ROLE_PLANET";
-        break;
-    }
-
-    jfieldID enumField = lookup.findStaticField(peerRoleClass, fieldName.c_str(), "Lcom/zerotier/sdk/PeerRole;");
-
-    peerRoleObject = env->GetStaticObjectField(peerRoleClass, enumField);
-
     return peerRoleObject;
 }
 
 jobject createVirtualNetworkType(JNIEnv *env, ZT_VirtualNetworkType type)
 {
-    jclass vntypeClass = NULL;
-    jobject vntypeObject = NULL;
-
-    vntypeClass = lookup.findClass("com/zerotier/sdk/VirtualNetworkType");
-    if(env->ExceptionCheck() || vntypeClass == NULL)
-    {
+    jobject vntypeObject = env->CallStaticObjectMethod(VirtualNetworkType_class, VirtualNetworkType_fromInt_method, type);
+    if (env->ExceptionCheck() || vntypeObject == NULL) {
+        LOGE("Error creating VirtualNetworkType object");
         return NULL;
     }
 
-    std::string fieldName;
-    switch(type)
-    {
-    case ZT_NETWORK_TYPE_PRIVATE:
-        fieldName = "NETWORK_TYPE_PRIVATE";
-        break;
-    case ZT_NETWORK_TYPE_PUBLIC:
-        fieldName = "NETWORK_TYPE_PUBLIC";
-        break;
-    }
-
-    jfieldID enumField = lookup.findStaticField(vntypeClass, fieldName.c_str(), "Lcom/zerotier/sdk/VirtualNetworkType;");
-    vntypeObject = env->GetStaticObjectField(vntypeClass, enumField);
     return vntypeObject;
 }
 
 jobject createVirtualNetworkConfigOperation(JNIEnv *env, ZT_VirtualNetworkConfigOperation op)
 {
-    jclass vnetConfigOpClass = NULL;
-    jobject vnetConfigOpObject = NULL;
-
-    vnetConfigOpClass = lookup.findClass("com/zerotier/sdk/VirtualNetworkConfigOperation");
-    if(env->ExceptionCheck() || vnetConfigOpClass == NULL)
-    {
+    jobject vnetConfigOpObject = env->CallStaticObjectMethod(VirtualNetworkConfigOperation_class, VirtualNetworkConfigOperation_fromInt_method, op);
+    if (env->ExceptionCheck() || vnetConfigOpObject == NULL) {
+        LOGE("Error creating VirtualNetworkConfigOperation object");
         return NULL;
     }
 
-    std::string fieldName;
-    switch(op)
-    {
-    case ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_UP:
-        fieldName = "VIRTUAL_NETWORK_CONFIG_OPERATION_UP";
-        break;
-    case ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE:
-        fieldName = "VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE";
-        break;
-    case ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_DOWN:
-        fieldName = "VIRTUAL_NETWORK_CONFIG_OPERATION_DOWN";
-        break;
-    case ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_DESTROY:
-        fieldName = "VIRTUAL_NETWORK_CONFIG_OPERATION_DESTROY";
-        break;
-    }
-
-    jfieldID enumField = lookup.findStaticField(vnetConfigOpClass, fieldName.c_str(), "Lcom/zerotier/sdk/VirtualNetworkConfigOperation;");
-    vnetConfigOpObject = env->GetStaticObjectField(vnetConfigOpClass, enumField);
     return vnetConfigOpObject;
 }
 
 jobject newInetAddress(JNIEnv *env, const sockaddr_storage &addr)
 {
-    LOGV("newInetAddress");
-    jclass inetAddressClass = NULL;
-    jmethodID inetAddress_getByAddress = NULL;
-
-    inetAddressClass = lookup.findClass("java/net/InetAddress");
-    if(env->ExceptionCheck() || inetAddressClass == NULL)
-    {
-        LOGE("Error finding InetAddress class");
-        return NULL;
-    }
-
-    inetAddress_getByAddress = lookup.findStaticMethod(
-        inetAddressClass, "getByAddress", "([B)Ljava/net/InetAddress;");
-    if(env->ExceptionCheck() || inetAddress_getByAddress == NULL)
-    {
-        LOGE("Error finding getByAddress() static method");
-        return NULL;
-    }
-
     jobject inetAddressObj = NULL;
     switch(addr.ss_family)
     {
         case AF_INET6:
         {
             sockaddr_in6 *ipv6 = (sockaddr_in6*)&addr;
-            jbyteArray buff = env->NewByteArray(16);
-            if(buff == NULL)
+            const unsigned char *bytes = reinterpret_cast<const unsigned char *>(&ipv6->sin6_addr.s6_addr);
+
+            jbyteArray buff = newByteArray(env, bytes, 16);
+            if(env->ExceptionCheck() || buff == NULL)
             {
-                LOGE("Error creating IPV6 byte array");
                 return NULL;
             }
 
-            env->SetByteArrayRegion(buff, 0, 16, (jbyte*)ipv6->sin6_addr.s6_addr);
             inetAddressObj = env->CallStaticObjectMethod(
-                inetAddressClass, inetAddress_getByAddress, buff);
+                InetAddress_class, InetAddress_getByAddress_method, buff);
         }
         break;
         case AF_INET:
         {
             sockaddr_in *ipv4 = (sockaddr_in*)&addr;
-            jbyteArray buff = env->NewByteArray(4);
-            if(buff == NULL)
+            const unsigned char *bytes = reinterpret_cast<const unsigned char *>(&ipv4->sin_addr.s_addr);
+            jbyteArray buff = newByteArray(env, bytes, 4);
+            if(env->ExceptionCheck() || buff == NULL)
             {
-                LOGE("Error creating IPV4 byte array");
                 return NULL;
             }
 
-            env->SetByteArrayRegion(buff, 0, 4, (jbyte*)&ipv4->sin_addr);
             inetAddressObj = env->CallStaticObjectMethod(
-                inetAddressClass, inetAddress_getByAddress, buff);
+                InetAddress_class, InetAddress_getByAddress_method, buff);
         }
         break;
+        default:
+        {
+            assert(false && "addr.ss_family is neither AF_INET6 nor AF_INET");
+        }
     }
     if(env->ExceptionCheck() || inetAddressObj == NULL) {
         LOGE("Error creating InetAddress object");
@@ -342,693 +143,486 @@ jobject newInetAddress(JNIEnv *env, const sockaddr_storage &addr)
     return inetAddressObj;
 }
 
-jobject newInetSocketAddress(JNIEnv *env, const sockaddr_storage &addr)
-{
-    LOGV("newInetSocketAddress Called");
-    jclass inetSocketAddressClass = NULL;
-    jmethodID inetSocketAddress_constructor = NULL;
-
-    inetSocketAddressClass = lookup.findClass("java/net/InetSocketAddress");
-    if(env->ExceptionCheck() || inetSocketAddressClass == NULL)
-    {
-        LOGE("Error finding InetSocketAddress Class");
-        return NULL;
-    }
-
-    jobject 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
-    {
-        return NULL;
-    }
-
-    inetSocketAddress_constructor = lookup.findMethod(
-        inetSocketAddressClass, "<init>", "(Ljava/net/InetAddress;I)V");
-    if(env->ExceptionCheck() || inetSocketAddress_constructor == NULL)
-    {
-        LOGE("Error finding InetSocketAddress constructor");
-        return NULL;
-    }
+int addressPort(const sockaddr_storage addr) {
 
     int port = 0;
     switch(addr.ss_family)
     {
         case AF_INET6:
         {
-            LOGV("IPV6 Address");
             sockaddr_in6 *ipv6 = (sockaddr_in6*)&addr;
             port = ntohs(ipv6->sin6_port);
-            LOGV("Port %d", port);
         }
-        break;
+            break;
         case AF_INET:
         {
-            LOGV("IPV4 Address");
             sockaddr_in *ipv4 = (sockaddr_in*)&addr;
             port = ntohs(ipv4->sin_port);
-            LOGV("Port: %d", port);
         }
-        break;
+            break;
         default:
         {
-            break;
+            assert(false && "addr.ss_family is neither AF_INET6 nor AF_INET");
         }
     }
 
-
-    jobject inetSocketAddressObject = env->NewObject(inetSocketAddressClass, inetSocketAddress_constructor, inetAddressObject, port);
-    if(env->ExceptionCheck() || inetSocketAddressObject == NULL) {
-        LOGE("Error creating InetSocketAddress object");
-    }
-    return inetSocketAddressObject;
+    return port;
 }
 
-jobject newPeerPhysicalPath(JNIEnv *env, const ZT_PeerPhysicalPath &ppp)
+//
+// addr may be empty
+//
+// may return NULL
+//
+jobject newInetSocketAddress(JNIEnv *env, const sockaddr_storage &addr)
 {
-    LOGV("newPeerPhysicalPath Called");
-    jclass pppClass = NULL;
-
-    jfieldID addressField = NULL;
-    jfieldID lastSendField = NULL;
-    jfieldID lastReceiveField = NULL;
-    jfieldID preferredField = NULL;
-
-    jmethodID ppp_constructor = NULL;
-
-    pppClass = lookup.findClass("com/zerotier/sdk/PeerPhysicalPath");
-    if(env->ExceptionCheck() || pppClass == NULL)
+    if(isSocketAddressEmpty(addr))
     {
-        LOGE("Error finding PeerPhysicalPath class");
         return NULL;
     }
 
-    addressField = lookup.findField(pppClass, "address", "Ljava/net/InetSocketAddress;");
-    if(env->ExceptionCheck() || addressField == NULL)
-    {
-        LOGE("Error finding address field");
-        return NULL;
-    }
+    jobject inetAddressObject = newInetAddress(env, addr);
 
-    lastSendField = lookup.findField(pppClass, "lastSend", "J");
-    if(env->ExceptionCheck() || lastSendField == NULL)
+    if(env->ExceptionCheck() || inetAddressObject == NULL)
     {
-        LOGE("Error finding lastSend field");
         return NULL;
     }
 
-    lastReceiveField = lookup.findField(pppClass, "lastReceive", "J");
-    if(env->ExceptionCheck() || lastReceiveField == NULL)
-    {
-        LOGE("Error finding lastReceive field");
-        return NULL;
-    }
+    int port = addressPort(addr);
 
-    preferredField = lookup.findField(pppClass, "preferred", "Z");
-    if(env->ExceptionCheck() || preferredField == NULL)
-    {
-        LOGE("Error finding preferred field");
+    jobject inetSocketAddressObject = env->NewObject(InetSocketAddress_class, InetSocketAddress_ctor, inetAddressObject, port);
+    if(env->ExceptionCheck() || inetSocketAddressObject == NULL) {
+        LOGE("Error creating InetSocketAddress object");
         return NULL;
     }
+    return inetSocketAddressObject;
+}
 
-    ppp_constructor = lookup.findMethod(pppClass, "<init>", "()V");
-    if(env->ExceptionCheck() || ppp_constructor == NULL)
-    {
-        LOGE("Error finding PeerPhysicalPath constructor");
+jobject newPeerPhysicalPath(JNIEnv *env, const ZT_PeerPhysicalPath &ppp)
+{
+    //
+    // may be NULL
+    //
+    jobject addressObject = newInetSocketAddress(env, ppp.address);
+    if(env->ExceptionCheck()) {
         return NULL;
     }
 
-    jobject pppObject = env->NewObject(pppClass, ppp_constructor);
+    jobject pppObject = env->NewObject(
+            PeerPhysicalPath_class,
+            PeerPhysicalPath_ctor,
+            addressObject,
+            ppp.lastSend,
+            ppp.lastReceive,
+            ppp.preferred);
     if(env->ExceptionCheck() || pppObject == NULL)
     {
         LOGE("Error creating PPP object");
-        return NULL; // out of memory
-    }
-
-    jobject addressObject = newInetSocketAddress(env, ppp.address);
-    if(env->ExceptionCheck() || addressObject == NULL) {
-        LOGE("Error creating InetSocketAddress object");
         return NULL;
     }
 
-    env->SetObjectField(pppObject, addressField, addressObject);
-    env->SetLongField(pppObject, lastSendField, ppp.lastSend);
-    env->SetLongField(pppObject, lastReceiveField, ppp.lastReceive);
-    env->SetBooleanField(pppObject, preferredField, ppp.preferred);
-
-    if(env->ExceptionCheck()) {
-        LOGE("Exception assigning fields to PeerPhysicalPath object");
-    }
-
     return pppObject;
 }
 
 jobject newPeer(JNIEnv *env, const ZT_Peer &peer)
 {
-    LOGV("newPeer called");
-
-    jclass peerClass = NULL;
-
-    jfieldID addressField = NULL;
-    jfieldID versionMajorField = NULL;
-    jfieldID versionMinorField = NULL;
-    jfieldID versionRevField = NULL;
-    jfieldID latencyField = NULL;
-    jfieldID roleField = NULL;
-    jfieldID pathsField = NULL;
-
-    jmethodID peer_constructor = NULL;
-
-    peerClass = lookup.findClass("com/zerotier/sdk/Peer");
-    if(env->ExceptionCheck() || peerClass == NULL)
-    {
-        LOGE("Error finding Peer class");
-        return NULL;
-    }
-
-    addressField = lookup.findField(peerClass, "address", "J");
-    if(env->ExceptionCheck() || addressField == NULL)
-    {
-        LOGE("Error finding address field of Peer object");
-        return NULL;
-    }
-
-    versionMajorField = lookup.findField(peerClass, "versionMajor", "I");
-    if(env->ExceptionCheck() || versionMajorField == NULL)
-    {
-        LOGE("Error finding versionMajor field of Peer object");
-        return NULL;
-    }
-
-    versionMinorField = lookup.findField(peerClass, "versionMinor", "I");
-    if(env->ExceptionCheck() || versionMinorField == NULL)
-    {
-        LOGE("Error finding versionMinor field of Peer object");
-        return NULL;
-    }
-
-    versionRevField = lookup.findField(peerClass, "versionRev", "I");
-    if(env->ExceptionCheck() || versionRevField == NULL)
-    {
-        LOGE("Error finding versionRev field of Peer object");
-        return NULL;
-    }
-
-    latencyField = lookup.findField(peerClass, "latency", "I");
-    if(env->ExceptionCheck() || latencyField == NULL)
-    {
-        LOGE("Error finding latency field of Peer object");
-        return NULL;
-    }
-
-    roleField = lookup.findField(peerClass, "role", "Lcom/zerotier/sdk/PeerRole;");
-    if(env->ExceptionCheck() || roleField == NULL)
+    jobject peerRoleObj = createPeerRole(env, peer.role);
+    if(env->ExceptionCheck() || peerRoleObj == NULL)
     {
-        LOGE("Error finding role field of Peer object");
-        return NULL;
-    }
-
-    pathsField = lookup.findField(peerClass, "paths", "[Lcom/zerotier/sdk/PeerPhysicalPath;");
-    if(env->ExceptionCheck() || pathsField == NULL)
-    {
-        LOGE("Error finding paths field of Peer object");
-        return NULL;
+        return NULL; // out of memory
     }
 
-    peer_constructor = lookup.findMethod(peerClass, "<init>", "()V");
-    if(env->ExceptionCheck() || peer_constructor == NULL)
-    {
-        LOGE("Error finding Peer constructor");
+    jobjectArray arrayObject = newPeerPhysicalPathArray(env, peer.paths, peer.pathCount);
+    if (env->ExceptionCheck() || arrayObject == NULL) {
         return NULL;
     }
 
-    jobject peerObject = env->NewObject(peerClass, peer_constructor);
+    jobject peerObject = env->NewObject(
+            Peer_class,
+            Peer_ctor,
+            peer.address,
+            peer.versionMajor,
+            peer.versionMinor,
+            peer.versionRev,
+            peer.latency,
+            peerRoleObj,
+            arrayObject);
     if(env->ExceptionCheck() || peerObject == NULL)
     {
         LOGE("Error creating Peer object");
-        return NULL; // out of memory
-    }
-
-    env->SetLongField(peerObject, addressField, (jlong)peer.address);
-    env->SetIntField(peerObject, versionMajorField, peer.versionMajor);
-    env->SetIntField(peerObject, versionMinorField, peer.versionMinor);
-    env->SetIntField(peerObject, versionRevField, peer.versionRev);
-    env->SetIntField(peerObject, latencyField, peer.latency);
-    env->SetObjectField(peerObject, roleField, createPeerRole(env, peer.role));
-
-    jclass peerPhysicalPathClass = lookup.findClass("com/zerotier/sdk/PeerPhysicalPath");
-    if(env->ExceptionCheck() || peerPhysicalPathClass == NULL)
-    {
-        LOGE("Error finding PeerPhysicalPath class");
         return NULL;
     }
 
-    jobjectArray arrayObject = env->NewObjectArray(
-        peer.pathCount, peerPhysicalPathClass, NULL);
-    if(env->ExceptionCheck() || arrayObject == NULL)
-    {
-        LOGE("Error creating PeerPhysicalPath[] array");
-        return NULL;
-    }
-
-    for(unsigned int i = 0; i < peer.pathCount; ++i)
-    {
-        jobject path = newPeerPhysicalPath(env, peer.paths[i]);
-
-        env->SetObjectArrayElement(arrayObject, i, path);
-        if(env->ExceptionCheck()) {
-            LOGE("exception assigning PeerPhysicalPath to array");
-            break;
-        }
-    }
-
-    env->SetObjectField(peerObject, pathsField, arrayObject);
-
     return peerObject;
 }
 
 jobject newNetworkConfig(JNIEnv *env, const ZT_VirtualNetworkConfig &vnetConfig)
 {
-    jclass vnetConfigClass = NULL;
-    jmethodID vnetConfig_constructor = NULL;
-    jfieldID nwidField = NULL;
-    jfieldID macField = NULL;
-    jfieldID nameField = NULL;
-    jfieldID statusField = NULL;
-    jfieldID typeField = NULL;
-    jfieldID mtuField = NULL;
-    jfieldID dhcpField = NULL;
-    jfieldID bridgeField = NULL;
-    jfieldID broadcastEnabledField = NULL;
-    jfieldID portErrorField = NULL;
-    jfieldID netconfRevisionField = NULL;
-    jfieldID assignedAddressesField = NULL;
-    jfieldID routesField = NULL;
-    jfieldID dnsField = NULL;
-
-    vnetConfigClass = lookup.findClass("com/zerotier/sdk/VirtualNetworkConfig");
-    if(vnetConfigClass == NULL)
-    {
-        LOGE("Couldn't find com.zerotier.sdk.VirtualNetworkConfig");
-        return NULL;
-    }
-
-    vnetConfig_constructor = lookup.findMethod(
-        vnetConfigClass, "<init>", "()V");
-    if(env->ExceptionCheck() || vnetConfig_constructor == NULL)
+    jstring nameStr = env->NewStringUTF(vnetConfig.name);
+    if(env->ExceptionCheck() || nameStr == NULL)
     {
-        LOGE("Couldn't find VirtualNetworkConfig Constructor");
-        return NULL;
+        LOGE("Exception creating new string");
+        return NULL; // out of memory
     }
 
-    jobject vnetConfigObj = env->NewObject(vnetConfigClass, vnetConfig_constructor);
-    if(env->ExceptionCheck() || vnetConfigObj == NULL)
+    jobject statusObject = createVirtualNetworkStatus(env, vnetConfig.status);
+    if(env->ExceptionCheck() || statusObject == NULL)
     {
-        LOGE("Error creating new VirtualNetworkConfig object");
         return NULL;
     }
 
-    nwidField = lookup.findField(vnetConfigClass, "nwid", "J");
-    if(env->ExceptionCheck() || nwidField == NULL)
+    jobject typeObject = createVirtualNetworkType(env, vnetConfig.type);
+    if(env->ExceptionCheck() || typeObject == NULL)
     {
-        LOGE("Error getting nwid field");
         return NULL;
     }
 
-    macField = lookup.findField(vnetConfigClass, "mac", "J");
-    if(env->ExceptionCheck() || macField == NULL)
-    {
-        LOGE("Error getting mac field");
+    jobjectArray assignedAddrArrayObj = newInetSocketAddressArray(env, vnetConfig.assignedAddresses, vnetConfig.assignedAddressCount);
+    if (env->ExceptionCheck() || assignedAddrArrayObj == NULL) {
         return NULL;
     }
 
-    nameField = lookup.findField(vnetConfigClass, "name", "Ljava/lang/String;");
-    if(env->ExceptionCheck() || nameField == NULL)
-    {
-        LOGE("Error getting name field");
+    jobjectArray routesArrayObj = newVirtualNetworkRouteArray(env, vnetConfig.routes, vnetConfig.routeCount);
+    if (env->ExceptionCheck() || routesArrayObj == NULL) {
         return NULL;
     }
 
-    statusField = lookup.findField(vnetConfigClass, "status", "Lcom/zerotier/sdk/VirtualNetworkStatus;");
-    if(env->ExceptionCheck() || statusField == NULL)
-    {
-        LOGE("Error getting status field");
+    //
+    // may be NULL
+    //
+    jobject dnsObj = newVirtualNetworkDNS(env, vnetConfig.dns);
+    if(env->ExceptionCheck()) {
         return NULL;
     }
 
-    typeField = lookup.findField(vnetConfigClass, "type", "Lcom/zerotier/sdk/VirtualNetworkType;");
-    if(env->ExceptionCheck() || typeField == NULL)
+    jobject vnetConfigObj = env->NewObject(
+            VirtualNetworkConfig_class,
+            VirtualNetworkConfig_ctor,
+            vnetConfig.nwid,
+            vnetConfig.mac,
+            nameStr,
+            statusObject,
+            typeObject,
+            vnetConfig.mtu,
+            vnetConfig.dhcp,
+            vnetConfig.bridge,
+            vnetConfig.broadcastEnabled,
+            //
+            // ANDROID-56: temporarily remove parameters to prevent crashing
+            //
+//            vnetConfig.portError,
+//            vnetConfig.netconfRevision,
+            assignedAddrArrayObj,
+            routesArrayObj,
+            dnsObj);
+    if(env->ExceptionCheck() || vnetConfigObj == NULL)
     {
-        LOGE("Error getting type field");
+        LOGE("Error creating new VirtualNetworkConfig object");
         return NULL;
     }
 
-    mtuField = lookup.findField(vnetConfigClass, "mtu", "I");
-    if(env->ExceptionCheck() || mtuField == NULL)
-    {
-        LOGE("Error getting mtu field");
-        return NULL;
-    }
+    return vnetConfigObj;
+}
 
-    dhcpField = lookup.findField(vnetConfigClass, "dhcp", "Z");
-    if(env->ExceptionCheck() || dhcpField == NULL)
+jobject newVersion(JNIEnv *env, int major, int minor, int rev)
+{
+    // create a com.zerotier.sdk.Version object
+    jobject versionObj = env->NewObject(Version_class, Version_ctor, major, minor, rev);
+    if(env->ExceptionCheck() || versionObj == NULL)
     {
-        LOGE("Error getting dhcp field");
+        LOGE("Error creating new Version object");
         return NULL;
     }
 
-    bridgeField = lookup.findField(vnetConfigClass, "bridge", "Z");
-    if(env->ExceptionCheck() || bridgeField == NULL)
-    {
-        LOGE("Error getting bridge field");
-        return NULL;
-    }
+    return versionObj;
+}
 
-    broadcastEnabledField = lookup.findField(vnetConfigClass, "broadcastEnabled", "Z");
-    if(env->ExceptionCheck() || broadcastEnabledField == NULL)
-    {
-        LOGE("Error getting broadcastEnabled field");
+jobject newVirtualNetworkRoute(JNIEnv *env, const ZT_VirtualNetworkRoute &route)
+{
+    //
+    // may be NULL
+    //
+    jobject targetObj = newInetSocketAddress(env, route.target);
+    if (env->ExceptionCheck()) {
         return NULL;
     }
 
-    portErrorField = lookup.findField(vnetConfigClass, "portError", "I");
-    if(env->ExceptionCheck() || portErrorField == NULL)
-    {
-        LOGE("Error getting portError field");
+    //
+    // may be NULL
+    //
+    jobject viaObj = newInetSocketAddress(env, route.via);
+    if (env->ExceptionCheck()) {
         return NULL;
     }
 
-    netconfRevisionField = lookup.findField(vnetConfigClass, "netconfRevision", "J");
-    if(env->ExceptionCheck() || netconfRevisionField == NULL)
+    jobject routeObj = env->NewObject(
+            VirtualNetworkRoute_class,
+            VirtualNetworkRoute_ctor,
+            targetObj,
+            viaObj,
+            route.flags,
+            route.metric);
+    if(env->ExceptionCheck() || routeObj == NULL)
     {
-        LOGE("Error getting netconfRevision field");
+        LOGE("Exception creating VirtualNetworkRoute");
         return NULL;
     }
 
-    assignedAddressesField = lookup.findField(vnetConfigClass, "assignedAddresses",
-        "[Ljava/net/InetSocketAddress;");
-    if(env->ExceptionCheck() || assignedAddressesField == NULL)
-    {
-        LOGE("Error getting assignedAddresses field");
-        return NULL;
-    }
+    return routeObj;
+}
 
-    routesField = lookup.findField(vnetConfigClass, "routes",
-        "[Lcom/zerotier/sdk/VirtualNetworkRoute;");
-    if(env->ExceptionCheck() || routesField == NULL)
-    {
-        LOGE("Error getting routes field");
+//
+// may return NULL
+//
+jobject newVirtualNetworkDNS(JNIEnv *env, const ZT_VirtualNetworkDNS &dns)
+{
+    if (strlen(dns.domain) == 0) {
+        LOGD("dns.domain is empty; returning NULL");
         return NULL;
     }
 
-    dnsField = lookup.findField(vnetConfigClass, "dns", "Lcom/zerotier/sdk/VirtualNetworkDNS;");
-    if(env->ExceptionCheck() || dnsField == NULL)
-    {
-        LOGE("Error getting DNS field");
+    jstring domain = env->NewStringUTF(dns.domain);
+    if (env->ExceptionCheck() || domain == NULL) {
+        LOGE("Exception creating new string");
         return NULL;
     }
 
-    env->SetLongField(vnetConfigObj, nwidField, vnetConfig.nwid);
-    env->SetLongField(vnetConfigObj, macField, vnetConfig.mac);
-    jstring nameStr = env->NewStringUTF(vnetConfig.name);
-    if(env->ExceptionCheck() || nameStr == NULL)
-    {
-        return NULL; // out of memory
-    }
-    env->SetObjectField(vnetConfigObj, nameField, nameStr);
-
-    jobject statusObject = createVirtualNetworkStatus(env, vnetConfig.status);
-    if(env->ExceptionCheck() || statusObject == NULL)
-    {
+    jobject addrList = env->NewObject(ArrayList_class, ArrayList_ctor, 0);
+    if (env->ExceptionCheck() || addrList == NULL) {
+        LOGE("Exception creating new ArrayList");
         return NULL;
     }
-    env->SetObjectField(vnetConfigObj, statusField, statusObject);
 
-    jobject typeObject = createVirtualNetworkType(env, vnetConfig.type);
-    if(env->ExceptionCheck() || typeObject == NULL)
-    {
-        return NULL;
-    }
-    env->SetObjectField(vnetConfigObj, typeField, typeObject);
+    for (int i = 0; i < ZT_MAX_DNS_SERVERS; ++i) { //NOLINT
 
-    env->SetIntField(vnetConfigObj, mtuField, (int)vnetConfig.mtu);
-    env->SetBooleanField(vnetConfigObj, dhcpField, vnetConfig.dhcp);
-    env->SetBooleanField(vnetConfigObj, bridgeField, vnetConfig.bridge);
-    env->SetBooleanField(vnetConfigObj, broadcastEnabledField, vnetConfig.broadcastEnabled);
-    env->SetIntField(vnetConfigObj, portErrorField, vnetConfig.portError);
+        struct sockaddr_storage tmp = dns.server_addr[i];
 
-    jclass inetSocketAddressClass = lookup.findClass("java/net/InetSocketAddress");
-    if(env->ExceptionCheck() || inetSocketAddressClass == NULL)
-    {
-        LOGE("Error finding InetSocketAddress class");
-        return NULL;
-    }
-
-    jobjectArray assignedAddrArrayObj = env->NewObjectArray(
-        vnetConfig.assignedAddressCount, inetSocketAddressClass, NULL);
-    if(env->ExceptionCheck() || assignedAddrArrayObj == NULL)
-    {
-        LOGE("Error creating InetSocketAddress[] array");
-        return NULL;
-    }
-
-    for(unsigned int i = 0; i < vnetConfig.assignedAddressCount; ++i)
-    {
-        jobject inetAddrObj = newInetSocketAddress(env, vnetConfig.assignedAddresses[i]);
-        env->SetObjectArrayElement(assignedAddrArrayObj, i, inetAddrObj);
-        if(env->ExceptionCheck())
-        {
-            LOGE("Error assigning InetSocketAddress to array");
+        //
+        // may be NULL
+        //
+        jobject addr = newInetSocketAddress(env, tmp);
+        if (env->ExceptionCheck()) {
             return NULL;
         }
-    }
-
-    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;
-    }
+        if (addr == NULL) {
+            continue;
+        }
 
-    for(unsigned int i = 0; i < vnetConfig.routeCount; ++i)
-    {
-        jobject routeObj = newVirtualNetworkRoute(env, vnetConfig.routes[i]);
-        env->SetObjectArrayElement(routesArrayObj, i, routeObj);
+        env->CallBooleanMethod(addrList, ArrayList_add_method, addr);
         if(env->ExceptionCheck())
         {
-            LOGE("Error assigning VirtualNetworkRoute to array");
+            LOGE("Exception calling add");
             return NULL;
         }
-    }
 
-    env->SetObjectField(vnetConfigObj, routesField, routesArrayObj);
+        env->DeleteLocalRef(addr);
+    }
 
-    jobject dnsObj = newVirtualNetworkDNS(env, vnetConfig.dns);
-    if (dnsObj != NULL) {
-        env->SetObjectField(vnetConfigObj, dnsField, dnsObj);
+    jobject dnsObj = env->NewObject(
+            VirtualNetworkDNS_class,
+            VirtualNetworkDNS_ctor,
+            domain,
+            addrList);
+    if (env->ExceptionCheck() || dnsObj == NULL) {
+        LOGE("Exception creating new VirtualNetworkDNS");
+        return NULL;
     }
-    return vnetConfigObj;
+    return dnsObj;
 }
 
-jobject newVersion(JNIEnv *env, int major, int minor, int rev)
-{
-   // create a com.zerotier.sdk.Version object
-    jclass versionClass = NULL;
-    jmethodID versionConstructor = NULL;
+jobject newNodeStatus(JNIEnv *env, const ZT_NodeStatus &status) {
 
-    versionClass = lookup.findClass("com/zerotier/sdk/Version");
-    if(env->ExceptionCheck() || versionClass == NULL)
+    jstring pubIdentStr = env->NewStringUTF(status.publicIdentity);
+    if(env->ExceptionCheck() || pubIdentStr == NULL)
     {
+        LOGE("Exception creating new string");
         return NULL;
     }
 
-    versionConstructor = lookup.findMethod(
-        versionClass, "<init>", "()V");
-    if(env->ExceptionCheck() || versionConstructor == NULL)
+    jstring secIdentStr = env->NewStringUTF(status.secretIdentity);
+    if(env->ExceptionCheck() || secIdentStr == NULL)
     {
+        LOGE("Exception creating new string");
         return NULL;
     }
 
-    jobject versionObj = env->NewObject(versionClass, versionConstructor);
-    if(env->ExceptionCheck() || versionObj == NULL)
-    {
+    jobject nodeStatusObj = env->NewObject(
+            NodeStatus_class,
+            NodeStatus_ctor,
+            status.address,
+            pubIdentStr,
+            secIdentStr,
+            status.online);
+    if(env->ExceptionCheck() || nodeStatusObj == NULL) {
+        LOGE("Exception creating new NodeStatus");
         return NULL;
     }
 
-    // copy data to Version object
-    jfieldID majorField = NULL;
-    jfieldID minorField = NULL;
-    jfieldID revisionField = NULL;
+    return nodeStatusObj;
+}
 
-    majorField = lookup.findField(versionClass, "major", "I");
-    if(env->ExceptionCheck() || majorField == NULL)
-    {
-        return NULL;
-    }
+jobjectArray newPeerArray(JNIEnv *env, const ZT_Peer *peers, size_t count) {
+    return newArrayObject<ZT_Peer, newPeer>(env, peers, count, Peer_class);
+}
 
-    minorField = lookup.findField(versionClass, "minor", "I");
-    if(env->ExceptionCheck() || minorField == NULL)
-    {
-        return NULL;
-    }
+jobjectArray newVirtualNetworkConfigArray(JNIEnv *env, const ZT_VirtualNetworkConfig *networks, size_t count) {
+    return newArrayObject<ZT_VirtualNetworkConfig, newNetworkConfig>(env, networks, count, VirtualNetworkConfig_class);
+}
 
-    revisionField = lookup.findField(versionClass, "revision", "I");
-    if(env->ExceptionCheck() || revisionField == NULL)
-    {
-        return NULL;
-    }
+jobjectArray newPeerPhysicalPathArray(JNIEnv *env, const ZT_PeerPhysicalPath *paths, size_t count) {
+    return newArrayObject<ZT_PeerPhysicalPath, newPeerPhysicalPath>(env, paths, count, PeerPhysicalPath_class);
+}
 
-    env->SetIntField(versionObj, majorField, (jint)major);
-    env->SetIntField(versionObj, minorField, (jint)minor);
-    env->SetIntField(versionObj, revisionField, (jint)rev);
+jobjectArray newInetSocketAddressArray(JNIEnv *env, const sockaddr_storage *addresses, size_t count) {
+    return newArrayObject<sockaddr_storage, newInetSocketAddress>(env, addresses, count, InetSocketAddress_class);
+}
 
-    return versionObj;
+jobjectArray newVirtualNetworkRouteArray(JNIEnv *env, const ZT_VirtualNetworkRoute *routes, size_t count) {
+    return newArrayObject<ZT_VirtualNetworkRoute, newVirtualNetworkRoute>(env, routes, count, VirtualNetworkRoute_class);
 }
 
-jobject newVirtualNetworkRoute(JNIEnv *env, const ZT_VirtualNetworkRoute &route)
-{
-    jclass virtualNetworkRouteClass = NULL;
-    jmethodID routeConstructor = NULL;
+void newArrayObject_logCount(size_t count) {
+    LOGE("count > JSIZE_MAX: %zu", count);
+}
 
-    virtualNetworkRouteClass = lookup.findClass("com/zerotier/sdk/VirtualNetworkRoute");
-    if(env->ExceptionCheck() || virtualNetworkRouteClass == NULL)
-    {
-        return NULL;
-    }
+void newArrayObject_log(const char *msg) {
+    LOGE("%s", msg);
+}
 
-    routeConstructor = lookup.findMethod(virtualNetworkRouteClass, "<init>", "()V");
-    if(env->ExceptionCheck() || routeConstructor == NULL)
-    {
-        return NULL;
-    }
+jbyteArray newByteArray(JNIEnv *env, const unsigned char *bytes, size_t count) {
 
-    jobject routeObj = env->NewObject(virtualNetworkRouteClass, routeConstructor);
-    if(env->ExceptionCheck() || routeObj == NULL)
-    {
+    if (count > JSIZE_MAX) {
+        LOGE("count > JSIZE_MAX: %zu", count);
         return NULL;
     }
 
-    jfieldID targetField = NULL;
-    jfieldID viaField = NULL;
-    jfieldID flagsField = NULL;
-    jfieldID metricField = NULL;
+    jsize jCount = static_cast<jsize>(count);
+    const jbyte *jBytes = reinterpret_cast<const jbyte *>(bytes);
 
-    targetField = lookup.findField(virtualNetworkRouteClass, "target",
-        "Ljava/net/InetSocketAddress;");
-    if(env->ExceptionCheck() || targetField == NULL)
+    jbyteArray byteArrayObj = env->NewByteArray(jCount);
+    if(byteArrayObj == NULL)
     {
+        LOGE("NewByteArray returned NULL");
         return NULL;
     }
 
-    viaField = lookup.findField(virtualNetworkRouteClass, "via",
-        "Ljava/net/InetSocketAddress;");
-    if(env->ExceptionCheck() || targetField == NULL)
-    {
+    env->SetByteArrayRegion(byteArrayObj, 0, jCount, jBytes);
+    if (env->ExceptionCheck()) {
+        LOGE("Exception when calling SetByteArrayRegion");
         return NULL;
     }
 
-    flagsField = lookup.findField(virtualNetworkRouteClass, "flags", "I");
-    if(env->ExceptionCheck() || flagsField == NULL)
-    {
+    return byteArrayObj;
+}
+
+jbyteArray newByteArray(JNIEnv *env, size_t count) {
+
+    if (count > JSIZE_MAX) {
+        LOGE("count > JSIZE_MAX: %zu", count);
         return NULL;
     }
 
-    metricField = lookup.findField(virtualNetworkRouteClass, "metric", "I");
-    if(env->ExceptionCheck() || metricField == NULL)
+    jsize jCount = static_cast<jsize>(count);
+
+    jbyteArray byteArrayObj = env->NewByteArray(jCount);
+    if(byteArrayObj == NULL)
     {
+        LOGE("NewByteArray returned 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 byteArrayObj;
+}
 
-    return routeObj;
+bool isSocketAddressEmpty(const sockaddr_storage addr) {
+
+    //
+    // was:
+    // struct sockaddr_storage nullAddress = {0};
+    //
+    // but was getting this warning:
+    // warning: suggest braces around initialization of subobject
+    //
+    // when building ZeroTierOne
+    //
+    sockaddr_storage emptyAddress; //NOLINT
+
+    //
+    // It is possible to assume knowledge about internals of sockaddr_storage and construct
+    // correct 0-initializer, but it is simpler to just treat sockaddr_storage as opaque and
+    // use memset here to fill with 0
+    //
+    // This is also done in InetAddress.hpp for InetAddress
+    //
+    memset(&emptyAddress, 0, sizeof(sockaddr_storage));
+
+    return (memcmp(&addr, &emptyAddress, sizeof(sockaddr_storage)) == 0); //NOLINT
 }
 
-jobject newVirtualNetworkDNS(JNIEnv *env, const ZT_VirtualNetworkDNS &dns)
-{
-    jclass virtualNetworkDNSClass = NULL;
-    jmethodID dnsConstructor = NULL;
+//
+// returns empty sockaddr_storage on error
+//
+sockaddr_storage fromSocketAddressObject(JNIEnv *env, jobject sockAddressObject) {
 
-    virtualNetworkDNSClass = lookup.findClass("com/zerotier/sdk/VirtualNetworkDNS");
-    if (env->ExceptionCheck() || virtualNetworkDNSClass == NULL) {
-        return NULL;
-    }
+    sockaddr_storage emptyAddress; //NOLINT
 
-    dnsConstructor = lookup.findMethod(virtualNetworkDNSClass, "<init>", "()V");
-    if(env->ExceptionCheck() || dnsConstructor == NULL) {
-        return NULL;
-    }
+    memset(&emptyAddress, 0, sizeof(sockaddr_storage));
 
-    jobject dnsObj = env->NewObject(virtualNetworkDNSClass, dnsConstructor);
-    if(env->ExceptionCheck() || dnsObj == NULL) {
-        return NULL;
+    jint port = env->CallIntMethod(sockAddressObject, InetSocketAddress_getPort_method);
+    if(env->ExceptionCheck())
+    {
+        LOGE("Exception calling getPort");
+        return emptyAddress;
     }
 
-    jfieldID domainField = NULL;
-    jfieldID serversField = NULL;
-
-    domainField = lookup.findField(virtualNetworkDNSClass, "domain", "Ljava/lang/String;");
-    if(env->ExceptionCheck() || domainField == NULL)
+    jobject addressObject = env->CallObjectMethod(sockAddressObject, InetSocketAddress_getAddress_method);
+    if(env->ExceptionCheck() || addressObject == NULL)
     {
-        return NULL;
+        LOGE("Exception calling getAddress");
+        return emptyAddress;
     }
 
-    serversField = lookup.findField(virtualNetworkDNSClass, "servers", "Ljava/util/ArrayList;");
-    if(env->ExceptionCheck() || serversField == NULL) {
-        return NULL;
+    jbyteArray addressArrayObj = reinterpret_cast<jbyteArray>(env->CallObjectMethod(addressObject, InetAddress_getAddress_method));
+    if(env->ExceptionCheck() || addressArrayObj == NULL)
+    {
+        LOGE("Exception calling getAddress");
+        return emptyAddress;
     }
 
-    if (strlen(dns.domain) > 0) {
-        InitListJNI(env);
-        jstring domain = env->NewStringUTF(dns.domain);
+    sockaddr_storage addr = {};
 
-        jobject addrArray = env->NewObject(java_util_ArrayList, java_util_ArrayList_, 0);
+    if (env->IsInstanceOf(addressObject, Inet4Address_class)) {
 
-        struct sockaddr_storage nullAddr;
-        memset(&nullAddr, 0, sizeof(struct sockaddr_storage));
-        for(int i = 0; i < ZT_MAX_DNS_SERVERS; ++i) {
-            struct sockaddr_storage tmp = dns.server_addr[i];
+        // IPV4
 
-            if (memcmp(&tmp, &nullAddr, sizeof(struct sockaddr_storage)) != 0) {
-                jobject addr = newInetSocketAddress(env, tmp);
-                env->CallBooleanMethod(addrArray, java_util_ArrayList_add, addr);
-                env->DeleteLocalRef(addr);
-            }
-        }
+        assert(env->GetArrayLength(addressArrayObj) == 4);
+
+        sockaddr_in *addr_4 = reinterpret_cast<sockaddr_in *>(&addr);
+        addr_4->sin_family = AF_INET;
+        addr_4->sin_port = htons(port);
+
+        void *data = env->GetPrimitiveArrayCritical(addressArrayObj, NULL);
+        memcpy(&addr_4->sin_addr.s_addr, data, 4);
+        env->ReleasePrimitiveArrayCritical(addressArrayObj, data, 0);
 
-        env->SetObjectField(dnsObj, domainField, domain);
-        env->SetObjectField(dnsObj, serversField, addrArray);
+    } else if (env->IsInstanceOf(addressObject, Inet6Address_class)) {
 
-        return dnsObj;
+        // IPV6
+
+        assert(env->GetArrayLength(addressArrayObj) == 16);
+
+        sockaddr_in6 *addr_6 = reinterpret_cast<sockaddr_in6 *>(&addr);
+        addr_6->sin6_family = AF_INET6;
+        addr_6->sin6_port = htons(port);
+
+        void *data = env->GetPrimitiveArrayCritical(addressArrayObj, NULL);
+        memcpy(&addr_6->sin6_addr.s6_addr, data, 16);
+        env->ReleasePrimitiveArrayCritical(addressArrayObj, data, 0);
+
+    } else {
+        assert(false && "addressObject is neither Inet4Address nor Inet6Address");
     }
-    return NULL;
-}
 
-#ifdef __cplusplus
+    return addr;
 }
-#endif

java/jni/ZT_jniutils.h

@@ -15,18 +15,15 @@
  * 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>
+
 #include <jni.h>
 #include <ZeroTierOne.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define LOG_TAG "ZeroTierOneJNI"
+#include <limits> // for numeric_limits
+#include <sys/socket.h> // for sockaddr_storage
 
 #if defined(__ANDROID__)
 
@@ -55,6 +52,34 @@ extern "C" {
     #define LOGE(...) fprintf(stdout, __VA_ARGS__)
 #endif
 
+//
+// Call GetEnv and assert if there is an error
+//
+#define GETENV(env, vm) \
+    do { \
+        jint getEnvRet; \
+        assert(vm); \
+        if ((getEnvRet = vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6)) != JNI_OK) { \
+            LOGE("Error calling GetEnv: %d", getEnvRet); \
+            assert(false && "Error calling GetEnv"); \
+        } \
+    } while (false)
+
+//
+// Call GetJavaVM and assert if there is an error
+//
+#define GETJAVAVM(env, vm) \
+    do { \
+        jint getJavaVMRet; \
+        if ((getJavaVMRet = env->GetJavaVM(&vm)) != 0) { \
+            LOGE("Error calling GetJavaVM: %d", getJavaVMRet); \
+            assert(false && "Error calling GetJavaVM"); \
+        } \
+    } while (false)
+
+
+const jsize JSIZE_MAX = std::numeric_limits<jsize>::max();
+
 jobject createResultObject(JNIEnv *env, ZT_ResultCode code);
 jobject createVirtualNetworkStatus(JNIEnv *env, ZT_VirtualNetworkStatus status);
 jobject createVirtualNetworkType(JNIEnv *env, ZT_VirtualNetworkType type);
@@ -64,8 +89,7 @@ jobject createVirtualNetworkConfigOperation(JNIEnv *env, ZT_VirtualNetworkConfig
 
 jobject newInetSocketAddress(JNIEnv *env, const sockaddr_storage &addr);
 jobject newInetAddress(JNIEnv *env, const sockaddr_storage &addr);
-
-jobject newMulticastGroup(JNIEnv *env, const ZT_MulticastGroup &mc);
+int addressPort(const sockaddr_storage addr);
 
 jobject newPeer(JNIEnv *env, const ZT_Peer &peer);
 jobject newPeerPhysicalPath(JNIEnv *env, const ZT_PeerPhysicalPath &ppp);
@@ -78,8 +102,68 @@ jobject newVirtualNetworkRoute(JNIEnv *env, const ZT_VirtualNetworkRoute &route)
 
 jobject newVirtualNetworkDNS(JNIEnv *env, const ZT_VirtualNetworkDNS &dns);
 
-#ifdef __cplusplus
+jobject newNodeStatus(JNIEnv *env, const ZT_NodeStatus &status);
+
+jobjectArray newPeerArray(JNIEnv *env, const ZT_Peer *peers, size_t count);
+
+jobjectArray newVirtualNetworkConfigArray(JNIEnv *env, const ZT_VirtualNetworkConfig *networks, size_t count);
+
+jobjectArray newPeerPhysicalPathArray(JNIEnv *env, const ZT_PeerPhysicalPath *paths, size_t count);
+
+jobjectArray newInetSocketAddressArray(JNIEnv *env, const sockaddr_storage *addresses, size_t count);
+
+jobjectArray newVirtualNetworkRouteArray(JNIEnv *env, const ZT_VirtualNetworkRoute *routes, size_t count);
+
+//
+// log functions only for newArrayObject below
+//
+void newArrayObject_logCount(size_t count);
+void newArrayObject_log(const char *msg);
+
+//
+// function template for creating array objects
+//
+template <typename T, jobject (*F)(JNIEnv *, const T &)>
+jobjectArray newArrayObject(JNIEnv *env, const T *buffer, size_t count, jclass clazz) {
+
+    if (count > JSIZE_MAX) {
+        newArrayObject_logCount(count);
+        return NULL;
+    }
+
+    jsize jCount = static_cast<jsize>(count);
+
+    jobjectArray arrayObj = env->NewObjectArray(jCount, clazz, NULL);
+    if (env->ExceptionCheck() || arrayObj == NULL) {
+        newArrayObject_log("Error creating array object");
+        return NULL;
+    }
+
+    for (jsize i = 0; i < jCount; i++) {
+
+        jobject obj = F(env, buffer[i]);
+        if(env->ExceptionCheck() || obj == NULL) {
+            return NULL;
+        }
+
+        env->SetObjectArrayElement(arrayObj, i, obj);
+        if(env->ExceptionCheck()) {
+            newArrayObject_log("Error assigning object to array");
+            return NULL;
+        }
+
+        env->DeleteLocalRef(obj);
+    }
+
+    return arrayObj;
 }
-#endif
 
-#endif
+jbyteArray newByteArray(JNIEnv *env, const unsigned char *bytes, size_t count);
+
+jbyteArray newByteArray(JNIEnv *env, size_t count);
+
+bool isSocketAddressEmpty(const sockaddr_storage addr);
+
+sockaddr_storage fromSocketAddressObject(JNIEnv *env, jobject sockAddressObject);
+
+#endif // ZT_jniutils_h_

java/jni/com_zerotierone_sdk_Node.h

@@ -10,9 +10,17 @@ extern "C" {
 /*
  * Class:     com_zerotier_sdk_Node
  * Method:    node_init
- * Signature: (J)Lcom/zerotier/sdk/ResultCode;
+ * Signature: (JLcom/zerotier/sdk/DataStoreGetListener;Lcom/zerotier/sdk/DataStorePutListener;Lcom/zerotier/sdk/PacketSender;Lcom/zerotier/sdk/EventListener;Lcom/zerotier/sdk/VirtualNetworkFrameListener;Lcom/zerotier/sdk/VirtualNetworkConfigListener;Lcom/zerotier/sdk/PathChecker;)Lcom/zerotier/sdk/ResultCode;
  */
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_node_1init
+  (JNIEnv *, jobject, jlong, jobject, jobject, jobject, jobject, jobject, jobject, jobject);
+
+/*
+ * Class:     com_zerotier_sdk_Node
+ * Method:    node_isInited
+ * Signature: (J)Z;
+ */
+JNIEXPORT jboolean JNICALL Java_com_zerotier_sdk_Node_node_1isInited
   (JNIEnv *, jobject, jlong);
 
 /*
@@ -34,7 +42,7 @@ JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processVirtualNetworkFrame
 /*
  * Class:     com_zerotier_sdk_Node
  * Method:    processWirePacket
- * Signature: (JJLjava/net/InetSockAddress;Ljava/net/InetSockAddress;[B[J)Lcom/zerotier/sdk/ResultCode;
+ * Signature: (JJJLjava/net/InetSockAddress;[B[J)Lcom/zerotier/sdk/ResultCode;
  */
 JNIEXPORT jobject JNICALL Java_com_zerotier_sdk_Node_processWirePacket
   (JNIEnv *, jobject, jlong, jlong, jlong, jobject, jbyteArray, jlongArray);
@@ -121,10 +129,10 @@ JNIEXPORT jobjectArray JNICALL Java_com_zerotier_sdk_Node_peers
 
 /*
  * Class:     com_zerotier_sdk_Node
- * Method:    networks
+ * Method:    networkConfigs
  * Signature: (J)[Lcom/zerotier/sdk/VirtualNetworkConfig;
  */
-JNIEXPORT jobjectArray JNICALL Java_com_zerotier_sdk_Node_networks
+JNIEXPORT jobjectArray JNICALL Java_com_zerotier_sdk_Node_networkConfigs
   (JNIEnv *, jobject, jlong);
 
 #ifdef __cplusplus

java/src/com/zerotier/sdk/DataStoreGetListener.java

@@ -24,6 +24,7 @@
  * redistribute it in a modified binary form, please contact ZeroTier Networks
  * LLC. Start here: http://www.zerotier.com/
  */
+
 package com.zerotier.sdk;
 
 public interface DataStoreGetListener {
@@ -48,7 +49,7 @@ public interface DataStoreGetListener {
      * @param out_buffer buffer to put the object in
      * @return size of the object
      */
-    public long onDataStoreGet(
+    long onDataStoreGet(
             String name,
             byte[] out_buffer);
 }

java/src/com/zerotier/sdk/DataStorePutListener.java

@@ -24,6 +24,7 @@
  * redistribute it in a modified binary form, please contact ZeroTier Networks
  * LLC. Start here: http://www.zerotier.com/
  */
+
 package com.zerotier.sdk;
 
 public interface DataStorePutListener {
@@ -43,7 +44,7 @@ public interface DataStorePutListener {
      * @param secure set to user read/write only.
      * @return 0 on success.
      */
-    public int onDataStorePut(
+    int onDataStorePut(
         String name,
         byte[] buffer,
         boolean secure);
@@ -54,6 +55,6 @@ public interface DataStorePutListener {
      * @param name Object name
      * @return 0 on success.
      */
-    public int onDelete(
+    int onDelete(
         String name);
 }

java/src/com/zerotier/sdk/Event.java

@@ -27,26 +27,32 @@
 
 package com.zerotier.sdk;
 
+/**
+ * Status codes sent to status update callback when things happen
+ *
+ * Defined in ZeroTierOne.h as ZT_Event
+ */
 public enum Event {
+
     /**
      * Node has been initialized
      *
      * This is the first event generated, and is always sent. It may occur
      * before Node's constructor returns.
      */
-	EVENT_UP,
+    EVENT_UP(0),
 
     /**
      * Node is offline -- network does not seem to be reachable by any available strategy
      */
-	EVENT_OFFLINE,
+    EVENT_OFFLINE(1),
 
     /**
      * Node is online -- at least one upstream node appears reachable
      *
      * Meta-data: none
      */
-    EVENT_ONLINE,
+    EVENT_ONLINE(2),
 
     /**
      * Node is shutting down
@@ -55,7 +61,7 @@ public enum Event {
      * It's done for convenience, since cleaning up other state in the event
      * handler may appear more idiomatic.</p>
      */
-	EVENT_DOWN,
+    EVENT_DOWN(3),
 
     /**
      * Your identity has collided with another node's ZeroTier address
@@ -85,7 +91,7 @@ public enum Event {
      * condition is a good way to make sure it never arises. It's like how
      * umbrellas prevent rain and smoke detectors prevent fires. They do, right?</p>
      */
-	EVENT_FATAL_ERROR_IDENTITY_COLLISION,
+    EVENT_FATAL_ERROR_IDENTITY_COLLISION(4),
 
     /**
      * Trace (debugging) message
@@ -94,5 +100,55 @@ public enum Event {
      *
      * <p>Meta-data: {@link String}, TRACE message</p>
      */
-	EVENT_TRACE
-}
+    EVENT_TRACE(5),
+
+    /**
+     * VERB_USER_MESSAGE received
+     *
+     * These are generated when a VERB_USER_MESSAGE packet is received via
+     * ZeroTier VL1.
+     */
+    EVENT_USER_MESSAGE(6),
+
+    /**
+     * Remote trace received
+     *
+     * These are generated when a VERB_REMOTE_TRACE is received. Note
+     * that any node can fling one of these at us. It is your responsibility
+     * to filter and determine if it's worth paying attention to. If it's
+     * not just drop it. Most nodes that are not active controllers ignore
+     * these, and controllers only save them if they pertain to networks
+     * with remote tracing enabled.
+     */
+    EVENT_REMOTE_TRACE(7);
+
+    @SuppressWarnings({"FieldCanBeLocal", "unused"})
+    private final int id;
+
+    Event(int id) {
+        this.id = id;
+    }
+
+    public static Event fromInt(int id) {
+        switch (id) {
+            case 0:
+                return EVENT_UP;
+            case 1:
+                return EVENT_OFFLINE;
+            case 2:
+                return EVENT_ONLINE;
+            case 3:
+                return EVENT_DOWN;
+            case 4:
+                return EVENT_FATAL_ERROR_IDENTITY_COLLISION;
+            case 5:
+                return EVENT_TRACE;
+            case 6:
+                return EVENT_USER_MESSAGE;
+            case 7:
+                return EVENT_REMOTE_TRACE;
+            default:
+                throw new RuntimeException("Unhandled value: " + id);
+        }
+    }
+}

java/src/com/zerotier/sdk/EventListener.java

@@ -27,19 +27,17 @@
 
 package com.zerotier.sdk;
 
-import java.net.InetSocketAddress;
-import java.lang.String;
-
 /**
  * Interface to handle callbacks for ZeroTier One events.
  */
 public interface EventListener {
+
     /**
      * Callback for events with no other associated metadata
      * 
      * @param event {@link Event} enum
      */
-    public void onEvent(Event event);
+    void onEvent(Event event);
     
     /**
      * Trace messages
@@ -48,5 +46,5 @@ public interface EventListener {
      *
      * @param message the trace message
      */
-    public void onTrace(String message);
+    void onTrace(String message);
 }

java/src/com/zerotier/sdk/NativeUtils.java

@@ -1,93 +0,0 @@
-package com.zerotier.sdk;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
- 
-/**
- * Simple library class for working with JNI (Java Native Interface)
- * 
- * @see http://adamheinrich.com/2012/how-to-load-native-jni-library-from-jar
- *
- * @author Adam Heirnich <[email protected]>, http://www.adamh.cz
- */
-public class NativeUtils {
- 
-    /**
-     * Private constructor - this class will never be instanced
-     */
-    private NativeUtils() {
-    }
- 
-    /**
-     * Loads library from current JAR archive
-     * 
-     * The file from JAR is copied into system temporary directory and then loaded. The temporary file is deleted after exiting.
-     * Method uses String as filename because the pathname is "abstract", not system-dependent.
-     * 
-     * @param filename The filename inside JAR as absolute path (beginning with '/'), e.g. /package/File.ext
-     * @throws IOException If temporary file creation or read/write operation fails
-     * @throws IllegalArgumentException If source file (param path) does not exist
-     * @throws IllegalArgumentException If the path is not absolute or if the filename is shorter than three characters (restriction of {@see File#createTempFile(java.lang.String, java.lang.String)}).
-     */
-    public static void loadLibraryFromJar(String path) throws IOException {
- 
-        if (!path.startsWith("/")) {
-            throw new IllegalArgumentException("The path has to be absolute (start with '/').");
-        }
- 
-        // Obtain filename from path
-        String[] parts = path.split("/");
-        String filename = (parts.length > 1) ? parts[parts.length - 1] : null;
- 
-        // Split filename to prefix and suffix (extension)
-        String prefix = "";
-        String suffix = null;
-        if (filename != null) {
-            parts = filename.split("\\.", 2);
-            prefix = parts[0];
-            suffix = (parts.length > 1) ? "."+parts[parts.length - 1] : null; // Thanks, davs! :-)
-        }
- 
-        // Check if the filename is okay
-        if (filename == null || prefix.length() < 3) {
-            throw new IllegalArgumentException("The filename has to be at least 3 characters long.");
-        }
- 
-        // Prepare temporary file
-        File temp = File.createTempFile(prefix, suffix);
-        temp.deleteOnExit();
- 
-        if (!temp.exists()) {
-            throw new FileNotFoundException("File " + temp.getAbsolutePath() + " does not exist.");
-        }
- 
-        // Prepare buffer for data copying
-        byte[] buffer = new byte[1024];
-        int readBytes;
- 
-        // Open and check input stream
-        InputStream is = NativeUtils.class.getResourceAsStream(path);
-        if (is == null) {
-            throw new FileNotFoundException("File " + path + " was not found inside JAR.");
-        }
- 
-        // Open output stream and copy data between source file in JAR and the temporary file
-        OutputStream os = new FileOutputStream(temp);
-        try {
-            while ((readBytes = is.read(buffer)) != -1) {
-                os.write(buffer, 0, readBytes);
-            }
-        } finally {
-            // If read/write fails, close streams safely before throwing an exception
-            os.close();
-            is.close();
-        }
- 
-        // Finally, load the library
-        System.load(temp.getAbsolutePath());
-    }
-}

java/src/com/zerotier/sdk/Node.java

@@ -28,95 +28,72 @@
 package com.zerotier.sdk;
 
 import java.net.InetSocketAddress;
-import java.util.ArrayList;
-import java.io.IOException;
 
 /**
  * A ZeroTier One node
  */
 public class Node {
-	static {
-        try {
-    		System.loadLibrary("ZeroTierOneJNI");
-        } catch (UnsatisfiedLinkError e) {
-            try { 
-                if(System.getProperty("os.name").startsWith("Windows")) {
-                    System.out.println("Arch: " + System.getProperty("sun.arch.data.model"));
-                    if(System.getProperty("sun.arch.data.model").equals("64")) {
-                        NativeUtils.loadLibraryFromJar("/lib/ZeroTierOneJNI_win64.dll");
-                    } else {
-                        NativeUtils.loadLibraryFromJar("/lib/ZeroTierOneJNI_win32.dll");
-                    }
-                } else if(System.getProperty("os.name").startsWith("Mac")) {
-                    NativeUtils.loadLibraryFromJar("/lib/libZeroTierOneJNI.jnilib");
-                } else {
-                    // TODO: Linux
-                }
-            } catch (IOException ioe) {
-                ioe.printStackTrace();
-            }
-        }
-	}
+    static {
+        System.loadLibrary("ZeroTierOneJNI");
+    }
 
     private static final String TAG = "NODE";
 
     /**
      * Node ID for JNI purposes.
      * Currently set to the now value passed in at the constructor
-     * 
-     * -1 if the node has already been closed
      */
-    private long nodeId;
-
-    private final DataStoreGetListener getListener;
-    private final DataStorePutListener putListener;
-    private final PacketSender sender;
-    private final EventListener eventListener;
-    private final VirtualNetworkFrameListener frameListener;
-    private final VirtualNetworkConfigListener configListener;
-    private final PathChecker pathChecker;
+    private final long nodeId;
     
     /**
      * Create a new ZeroTier One node
      *
+     * @param now Current clock in milliseconds
+     */
+    public Node(long now) {
+        this.nodeId = now;
+    }
+
+    /**
+     * Init a new ZeroTier One node
+     *
      * <p>Note that this can take a few seconds the first time it's called, as it
      * will generate an identity.</p>
      *
-     * @param now Current clock in milliseconds
      * @param getListener User written instance of the {@link DataStoreGetListener} interface called to get objects from persistent storage.  This instance must be unique per Node object.
      * @param putListener User written instance of the {@link DataStorePutListener} interface called to put objects in persistent storage.  This instance must be unique per Node object.
-     * @param sender
+     * @param sender User written instance of the {@link PacketSender} interface to send ZeroTier packets out over the wire.
      * @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 frameListener User written instance of the {@link VirtualNetworkFrameListener} interface to send a frame out to a virtual network port.
      * @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,
-                DataStorePutListener putListener,
-                PacketSender sender,
-                EventListener eventListener,
-                VirtualNetworkFrameListener frameListener,
-                VirtualNetworkConfigListener configListener,
-                PathChecker pathChecker) throws NodeException
-	{
-        this.nodeId = now;
-
-        this.getListener = getListener;
-        this.putListener = putListener;
-        this.sender = sender;
-        this.eventListener = eventListener;
-        this.frameListener = frameListener;
-        this.configListener = configListener;
-        this.pathChecker = pathChecker;
-
-        ResultCode rc = node_init(now);
-        if(rc != ResultCode.RESULT_OK)
-        {
-            // TODO: Throw Exception
+    public ResultCode init(
+            DataStoreGetListener getListener,
+            DataStorePutListener putListener,
+            PacketSender sender,
+            EventListener eventListener,
+            VirtualNetworkFrameListener frameListener,
+            VirtualNetworkConfigListener configListener,
+            PathChecker pathChecker) throws NodeException {
+        ResultCode rc = node_init(
+                nodeId,
+                getListener,
+                putListener,
+                sender,
+                eventListener,
+                frameListener,
+                configListener,
+                pathChecker);
+        if(rc != ResultCode.RESULT_OK) {
             throw new NodeException(rc.toString());
         }
-	}
+        return rc;
+    }
+
+    public boolean isInited() {
+        return node_isInited(nodeId);
+    }
 
     /**
       * Close this Node.
@@ -124,15 +101,12 @@ public class Node {
       * <p>The Node object can no longer be used once this method is called.</p>
       */
     public void close() {
-        if(nodeId != -1) {
-            node_delete(nodeId);
-            nodeId = -1;
-        }
+        node_delete(nodeId);
     }
 
     @Override
-    protected void finalize() {
-        close();
+    public String toString() {
+        return "Node(" + nodeId + ")";
     }
 
     /**
@@ -166,6 +140,7 @@ public class Node {
      * Process a packet received from the physical wire
      *
      * @param now Current clock in milliseconds
+     * @param localSocket Local socket or -1
      * @param remoteAddress Origin of packet
      * @param packetData Packet data
      * @param nextBackgroundTaskDeadline Value/result: set to deadline for next call to processBackgroundTasks()
@@ -392,8 +367,8 @@ public class Node {
      *
      * @return List of networks or NULL on failure
      */
-    public VirtualNetworkConfig[] networks() {
-        return networks(nodeId);
+    public VirtualNetworkConfig[] networkConfigs() {
+        return networkConfigs(nodeId);
     }
 
     /**
@@ -408,7 +383,17 @@ public class Node {
     //
     // function declarations for JNI
     //
-    private native ResultCode node_init(long now);
+    private native ResultCode node_init(
+            long nodeId,
+            DataStoreGetListener dataStoreGetListener,
+            DataStorePutListener dataStorePutListener,
+            PacketSender packetSender,
+            EventListener eventListener,
+            VirtualNetworkFrameListener virtualNetworkFrameListener,
+            VirtualNetworkConfigListener virtualNetworkConfigListener,
+            PathChecker pathChecker);
+
+    private native boolean node_isInited(long nodeId);
 
     private native void node_delete(long nodeId);
 
@@ -471,5 +456,5 @@ public class Node {
 
     private native Peer[] peers(long nodeId);
 
-    private native VirtualNetworkConfig[] networks(long nodeId);
-}
+    private native VirtualNetworkConfig[] networkConfigs(long nodeId);
+}

java/src/com/zerotier/sdk/NodeException.java

@@ -27,10 +27,11 @@
 
 package com.zerotier.sdk;
 
-import java.lang.RuntimeException;
+public class NodeException extends Exception {
 
-public class NodeException extends RuntimeException {
+    private static final long serialVersionUID = 6268040509883125819L;
+    
     public NodeException(String message) {
         super(message);
     }
-}
+}

java/src/com/zerotier/sdk/NodeStatus.java

@@ -27,43 +27,64 @@
 
 package com.zerotier.sdk;
 
-public final class NodeStatus {
-	private long address;
-	private String publicIdentity;
-	private String secretIdentity;
-	private boolean online;
+import com.zerotier.sdk.util.StringUtils;
 
-	private NodeStatus() {}
+/**
+ * Current node status
+ *
+ * Defined in ZeroTierOne.h as ZT_NodeStatus
+ */
+public class NodeStatus {
+
+    private final long address;
+
+    private final String publicIdentity;
+
+    private final String secretIdentity;
+
+    private final boolean online;
+
+    public NodeStatus(long address, String publicIdentity, String secretIdentity, boolean online) {
+        this.address = address;
+        this.publicIdentity = publicIdentity;
+        this.secretIdentity = secretIdentity;
+        this.online = online;
+    }
+
+    @Override
+    public String toString() {
+        return "NodeStatus(" + StringUtils.addressToString(address) + ", " + publicIdentity + ", " + secretIdentity + ", " + online + ")";
+    }
 
 	/**
 	 * 40-bit ZeroTier address of this node
 	 */
-	public final long getAddress() {
-		return address;
-	}
+    public long getAddress() {
+        return address;
+    }
 
 	/**
 	 * Public identity in string-serialized form (safe to send to others)
 	 *
 	 * <p>This identity will remain valid as long as the node exists.</p>
 	 */
-	public final String getPublicIdentity() {
-		return publicIdentity;
-	}
+    public String getPublicIdentity() {
+        return publicIdentity;
+    }
 
 	/**
 	 * Full identity including secret key in string-serialized form
 	 *
 	 * <p>This identity will remain valid as long as the node exists.</p>
 	 */
-	public final String getSecretIdentity() {
-		return secretIdentity;
-	}
+    public String getSecretIdentity() {
+        return secretIdentity;
+    }
 
 	/**
 	 * True if some kind of connectivity appears available
 	 */
-	public final boolean isOnline() {
-		return online;
-	}
-}
+    public boolean isOnline() {
+        return online;
+    }
+}

java/src/com/zerotier/sdk/PacketSender.java

@@ -24,12 +24,14 @@
  * 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 interface PacketSender {
+
     /**
      * Function to send a ZeroTier packet out over the wire
      *
@@ -40,9 +42,10 @@ public interface PacketSender {
      * @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
+     * @param ttl TTL is ignored
      * @return 0 on success, any error code on failure.
      */
-    public int onSendPacketRequested(
+    int onSendPacketRequested(
             long localSocket,
             InetSocketAddress remoteAddr,
             byte[] packetData,

java/src/com/zerotier/sdk/PathChecker.java

@@ -8,6 +8,7 @@ package com.zerotier.sdk;
 import java.net.InetSocketAddress;
 
 public interface PathChecker {
+
     /**
      * Callback to check whether a path should be used for ZeroTier traffic
      *
@@ -28,6 +29,7 @@ public interface PathChecker {
      * @param ztAddress ZeroTier address or 0 for none/any
      * @param localSocket Local interface socket.  -1 if unspecified
      * @param remoteAddress remote address
+     * @return true if the path should be used
      */
     boolean onPathCheck(long ztAddress, long localSocket, InetSocketAddress remoteAddress);
 

java/src/com/zerotier/sdk/Peer.java

@@ -27,68 +27,92 @@
 
 package com.zerotier.sdk;
 
-import java.util.ArrayList;
+import com.zerotier.sdk.util.StringUtils;
+
+import java.util.Arrays;
 
 /**
- * Peer status result
+ * Peer status result buffer
+ *
+ * Defined in ZeroTierOne.h as ZT_Peer
  */
-public final class Peer {
-    private long address;
-    private int versionMajor;
-    private int versionMinor;
-    private int versionRev;
-    private int latency;
-    private PeerRole role;
-    private PeerPhysicalPath[] paths;
+public class Peer {
+
+    private final long address;
+
+    private final int versionMajor;
+
+    private final int versionMinor;
+
+    private final int versionRev;
 
-    private Peer() {}
+    private final int latency;
+
+    private final PeerRole role;
+
+    private final PeerPhysicalPath[] paths;
+
+    public Peer(long address, int versionMajor, int versionMinor, int versionRev, int latency, PeerRole role, PeerPhysicalPath[] paths) {
+        this.address = address;
+        this.versionMajor = versionMajor;
+        this.versionMinor = versionMinor;
+        this.versionRev = versionRev;
+        this.latency = latency;
+        this.role = role;
+        this.paths = paths;
+    }
+
+    @Override
+    public String toString() {
+        return "Peer(" + StringUtils.addressToString(address) + ", " + versionMajor + ", " + versionMinor + ", " + versionRev + ", " + latency + ", " + role + ", " + Arrays.toString(paths) + ")";
+    }
 
     /**
      * ZeroTier address (40 bits)
      */
-    public final long address() {
+    public long getAddress() {
         return address;
     }
 
     /**
      * Remote major version or -1 if not known
      */
-    public final int versionMajor() {
+    public int getVersionMajor() {
         return versionMajor;
     }
 
     /**
      * Remote minor version or -1 if not known
      */
-    public final int versionMinor() {
+    public int getVersionMinor() {
         return versionMinor;
     }
 
     /**
      * Remote revision or -1 if not known
      */
-    public final int versionRev() {
+    public int getVersionRev() {
         return versionRev;
     }
 
     /**
      * Last measured latency in milliseconds or zero if unknown
      */
-    public final int latency() {
+    public int getLatency() {
         return latency;
     }
 
     /**
      * What trust hierarchy role does this device have?
      */
-    public final PeerRole role() {
+    public PeerRole getRole() {
         return role;
     }
 
     /**
      * Known network paths to peer
      */
-    public final PeerPhysicalPath[] paths() {
+    public PeerPhysicalPath[] getPaths() {
         return paths;
     }
-}
+}

java/src/com/zerotier/sdk/PeerPhysicalPath.java

@@ -31,48 +31,62 @@ import java.net.InetSocketAddress;
 
 /**
  * Physical network path to a peer
+ *
+ * Defined in ZeroTierOne.h as ZT_PeerPhysicalPath
  */
-public final class PeerPhysicalPath {
-    private InetSocketAddress address;
-    private long lastSend;
-    private long lastReceive;
-    private boolean fixed;
-    private boolean preferred;
+public class PeerPhysicalPath {
+
+    private final InetSocketAddress address;
+
+    private final long lastSend;
+
+    private final long lastReceive;
+
+    private final boolean preferred;
+
+    public PeerPhysicalPath(InetSocketAddress address, long lastSend, long lastReceive, boolean preferred) {
+        this.address = address;
+        if (lastSend < 0) {
+            throw new RuntimeException("lastSend < 0: " + lastSend);
+        }
+        this.lastSend = lastSend;
+        if (lastReceive < 0) {
+            throw new RuntimeException("lastReceive < 0: " + lastReceive);
+        }
+        this.lastReceive = lastReceive;
+        this.preferred = preferred;
+    }
 
-    private PeerPhysicalPath() {}
+    @Override
+    public String toString() {
+        return "PeerPhysicalPath(" + address + ", " + lastSend + ", " + lastReceive + ", " + preferred + ")";
+    }
 
     /**
      * Address of endpoint
      */
-    public final InetSocketAddress address() {
+    public InetSocketAddress getAddress() {
         return address;
     }
 
     /**
      * Time of last send in milliseconds or 0 for never
      */
-    public final long lastSend() {
+    public long getLastSend() {
         return lastSend;
     }
 
     /**
      * Time of last receive in milliseconds or 0 for never
      */
-    public final long lastReceive() {
+    public long getLastReceive() {
         return lastReceive;
     }
 
-    /**
-     * Is path fixed? (i.e. not learned, static)
-     */
-    public final boolean isFixed() {
-        return fixed;
-    }
-
     /**
      * Is path preferred?
      */
-    public final boolean isPreferred() {
+    public boolean isPreferred() {
         return preferred;
     }
-}
+}

java/src/com/zerotier/sdk/PeerRole.java

@@ -27,19 +27,45 @@
 
 package com.zerotier.sdk;
 
+/**
+ * What trust hierarchy role does this peer have?
+ *
+ * Defined in ZeroTierOne.h as ZT_PeerRole
+ */
 public enum PeerRole {
+
     /**
      * An ordinary node
      */
-    PEER_ROLE_LEAF,
+    PEER_ROLE_LEAF(0),
 
     /**
      * moon root
      */
-    PEER_ROLE_MOON,
+    PEER_ROLE_MOON(1),
 
     /**
      * planetary root
      */
-    PEER_ROLE_PLANET
-}
+    PEER_ROLE_PLANET(2);
+
+    @SuppressWarnings({"FieldCanBeLocal", "unused"})
+    private final int id;
+
+    PeerRole(int id) {
+        this.id = id;
+    }
+
+    public static PeerRole fromInt(int id) {
+        switch (id) {
+            case 0:
+                return PEER_ROLE_LEAF;
+            case 1:
+                return PEER_ROLE_MOON;
+            case 2:
+                return PEER_ROLE_PLANET;
+            default:
+                throw new RuntimeException("Unhandled value: " + id);
+        }
+    }
+}

java/src/com/zerotier/sdk/ResultCode.java

@@ -34,12 +34,20 @@ package com.zerotier.sdk;
  * occurs, the node should be considered to not be working correctly. These
  * indicate serious problems like an inaccessible data store or a compile
  * problem.</p>
+ *
+ * Defined in ZeroTierOne.h as ZT_ResultCode
  */
 public enum ResultCode {
+
     /**
      * Operation completed normally
      */
-	RESULT_OK(0),
+    RESULT_OK(0),
+
+    /**
+     * Call produced no error but no action was taken
+     */
+    RESULT_OK_IGNORED(1),
 
     // Fatal errors (>=100, <1000)
     /**
@@ -68,12 +76,36 @@ public enum ResultCode {
 
     RESULT_ERROR_BAD_PARAMETER(1002);
 
-	
-	private final int id;
-    ResultCode(int id) { this.id = id; }
-    public int getValue() { return id; }
+    private final int id;
+
+    ResultCode(int id) {
+        this.id = id;
+    }
+
+    public static ResultCode fromInt(int id) {
+        switch (id) {
+            case 0:
+                return RESULT_OK;
+            case 1:
+                return RESULT_OK_IGNORED;
+            case 100:
+                return RESULT_FATAL_ERROR_OUT_OF_MEMORY;
+            case 101:
+                return RESULT_FATAL_ERROR_DATA_STORE_FAILED;
+            case 102:
+                return RESULT_FATAL_ERROR_INTERNAL;
+            case 1000:
+                return RESULT_ERROR_NETWORK_NOT_FOUND;
+            case 1001:
+                return RESULT_ERROR_UNSUPPORTED_OPERATION;
+            case 1002:
+                return RESULT_ERROR_BAD_PARAMETER;
+            default:
+                throw new RuntimeException("Unhandled value: " + id);
+        }
+    }
 
-    public boolean isFatal(int id) {
-    	return (id > 100 && id < 1000);
+    public boolean isFatal() {
+        return (id >= 100 && id < 1000);
     }
-}
+}

java/src/com/zerotier/sdk/Version.java

@@ -27,10 +27,27 @@
 
 package com.zerotier.sdk;
 
-public final class Version {
-    private Version() {}
-    
-	public int major = 0;
-	public int minor = 0;
-	public int revision = 0;
-}
+public class Version {
+
+    private final int major;
+    private final int minor;
+    private final int revision;
+
+    public Version(int major, int minor, int revision) {
+        this.major = major;
+        this.minor = minor;
+        this.revision = revision;
+    }
+
+    public int getMajor() {
+        return major;
+    }
+
+    public int getMinor() {
+        return minor;
+    }
+
+    public int getRevision() {
+        return revision;
+    }
+}

java/src/com/zerotier/sdk/VirtualNetworkConfig.java

@@ -29,197 +29,305 @@ package com.zerotier.sdk;
 
 import android.util.Log;
 
-import java.lang.Comparable;
-import java.lang.Override;
-import java.lang.String;
-import java.util.ArrayList;
+import com.zerotier.sdk.util.StringUtils;
+
 import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 
-public final class VirtualNetworkConfig implements Comparable<VirtualNetworkConfig> {
+/**
+ * Virtual network configuration
+ *
+ * Defined in ZeroTierOne.h as ZT_VirtualNetworkConfig
+ */
+public class VirtualNetworkConfig implements Comparable<VirtualNetworkConfig> {
+
     private final static String TAG = "VirtualNetworkConfig";
 
     public static final int MAX_MULTICAST_SUBSCRIPTIONS = 4096;
     public static final int ZT_MAX_ZT_ASSIGNED_ADDRESSES = 16;
 
-    private long nwid;
-    private long mac;
-    private String name;
-    private VirtualNetworkStatus status;
-    private VirtualNetworkType type;
-    private int mtu;
-    private boolean dhcp;
-    private boolean bridge;
-    private boolean broadcastEnabled;
-    private int portError;
-    private boolean enabled;
-    private long netconfRevision;
-    private InetSocketAddress[] assignedAddresses;
-    private VirtualNetworkRoute[] routes;
-    private VirtualNetworkDNS dns;
-
-    private VirtualNetworkConfig() {
+    private final long nwid;
 
-    }
+    private final long mac;
 
-    public boolean equals(VirtualNetworkConfig cfg) {
-        ArrayList<String> aaCurrent = new ArrayList<>();
-        ArrayList<String> aaNew = new ArrayList<>();
-        for (InetSocketAddress s : assignedAddresses) {
-            aaCurrent.add(s.toString());
-        }
-        for (InetSocketAddress s : cfg.assignedAddresses) {
-            aaNew.add(s.toString());
-        }
-        Collections.sort(aaCurrent);
-        Collections.sort(aaNew);
-        boolean aaEqual = aaCurrent.equals(aaNew);
-
-        ArrayList<String> rCurrent = new ArrayList<>();
-        ArrayList<String> rNew = new ArrayList<>();
-        for (VirtualNetworkRoute r : routes) {
-            rCurrent.add(r.toString());
+    private final String name;
+
+    private final VirtualNetworkStatus status;
+
+    private final VirtualNetworkType type;
+
+    private final int mtu;
+
+    private final boolean dhcp;
+
+    private final boolean bridge;
+
+    private final boolean broadcastEnabled;
+
+    //
+    // ANDROID-56: temporarily remove parameters to prevent crashing
+    //
+//    private final int portError;
+//
+//    private final long netconfRevision;
+
+    private final InetSocketAddress[] assignedAddresses;
+
+    private final VirtualNetworkRoute[] routes;
+
+    private final VirtualNetworkDNS dns;
+
+    public VirtualNetworkConfig(long nwid, long mac, String name, VirtualNetworkStatus status, VirtualNetworkType type, int mtu, boolean dhcp, boolean bridge, boolean broadcastEnabled, InetSocketAddress[] assignedAddresses, VirtualNetworkRoute[] routes, VirtualNetworkDNS dns) {
+        this.nwid = nwid;
+        this.mac = mac;
+        this.name = name;
+        this.status = status;
+        this.type = type;
+        if (mtu < 0) {
+            throw new RuntimeException("mtu < 0: " + mtu);
         }
-        for (VirtualNetworkRoute r : cfg.routes) {
-            rNew.add(r.toString());
+        this.mtu = mtu;
+        this.dhcp = dhcp;
+        this.bridge = bridge;
+        this.broadcastEnabled = broadcastEnabled;
+//        this.portError = portError;
+//        if (netconfRevision < 0) {
+//            throw new RuntimeException("netconfRevision < 0: " + netconfRevision);
+//        }
+//        this.netconfRevision = netconfRevision;
+        this.assignedAddresses = assignedAddresses;
+        this.routes = routes;
+        this.dns = dns;
+    }
+
+    @Override
+    public String toString() {
+        return "VirtualNetworkConfig(" + StringUtils.networkIdToString(nwid) + ", " + StringUtils.macAddressToString(mac) + ", " + name + ", " + status + ", " + type + ", " + mtu + ", " + dhcp + ", " + bridge + ", " + broadcastEnabled + ", " + Arrays.toString(assignedAddresses) + ", " + Arrays.toString(routes) + ", " + dns + ")";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+
+        if (!(o instanceof VirtualNetworkConfig)) {
+            return false;
         }
-        Collections.sort(rCurrent);
-        Collections.sort(rNew);
-        boolean routesEqual = rCurrent.equals(rNew);
+
+        VirtualNetworkConfig cfg = (VirtualNetworkConfig) o;
 
         if (this.nwid != cfg.nwid) {
-            Log.i(TAG, "nwid Changed. Old: " + Long.toHexString(this.nwid) + " (" + Long.toString(this.nwid) + "), " +
-                    "New: " + Long.toHexString(cfg.nwid) + " (" + Long.toString(cfg.nwid) + ")");
+            Log.i(TAG, "NetworkID Changed. Old: " + StringUtils.networkIdToString(this.nwid) + " (" + this.nwid + "), " +
+                    "New: " + StringUtils.networkIdToString(cfg.nwid) + " (" + cfg.nwid + ")");
+
+            return false;
         }
+
         if (this.mac != cfg.mac) {
-            Log.i(TAG, "MAC Changed. Old: " + Long.toHexString(this.mac) + ", New: " + Long.toHexString(cfg.mac));
+            Log.i(TAG, "MAC Changed. Old: " + StringUtils.macAddressToString(this.mac) + ", New: " + StringUtils.macAddressToString(cfg.mac));
+
+            return false;
         }
 
         if (!this.name.equals(cfg.name)) {
-            Log.i(TAG, "Name Changed.  Old: " + this.name + " New: "+ cfg.name);
+            Log.i(TAG, "Name Changed. Old: " + this.name + ", New: " + cfg.name);
+
+            return false;
         }
 
-        if (!this.type.equals(cfg.type)) {
-            Log.i(TAG, "TYPE changed.  Old " + this.type + ", New: " + cfg.type);
+        if (this.status != cfg.status) {
+            Log.i(TAG, "Status Changed. Old: " + this.status + ", New: " + cfg.status);
+
+            return false;
+        }
+
+        if (this.type != cfg.type) {
+            Log.i(TAG, "Type changed. Old " + this.type + ", New: " + cfg.type);
+
+            return false;
         }
 
         if (this.mtu != cfg.mtu) {
-            Log.i(TAG, "MTU Changed.  Old: " + this.mtu + ", New: " + cfg.mtu);
+            Log.i(TAG, "MTU Changed. Old: " + this.mtu + ", New: " + cfg.mtu);
+
+            return false;
         }
 
         if (this.dhcp != cfg.dhcp) {
             Log.i(TAG, "DHCP Flag Changed. Old: " + this.dhcp + ", New: " + cfg.dhcp);
+
+            return false;
         }
 
         if (this.bridge != cfg.bridge) {
             Log.i(TAG, "Bridge Flag Changed. Old: " + this.bridge + ", New: " + cfg.bridge);
+
+            return false;
         }
 
         if (this.broadcastEnabled != cfg.broadcastEnabled) {
-            Log.i(TAG, "Broadcast Flag Changed. Old: "+ this.broadcastEnabled +", New: " + this.broadcastEnabled);
-        }
+            Log.i(TAG, "Broadcast Flag Changed. Old: "+ this.broadcastEnabled + ", New: " + cfg.broadcastEnabled);
 
-        if (this.portError != cfg.portError) {
-            Log.i(TAG, "Port Error Changed. Old: " + this.portError + ", New: " + this.portError);
+            return false;
         }
 
-        if (this.enabled != cfg.enabled) {
-            Log.i(TAG, "Enabled Changed. Old: " + this.enabled + ", New: " + this.enabled);
-        }
+//        if (this.portError != cfg.portError) {
+//            Log.i(TAG, "Port Error Changed. Old: " + this.portError + ", New: " + cfg.portError);
+//
+//            return false;
+//        }
+//
+//        if (this.netconfRevision != cfg.netconfRevision) {
+//            Log.i(TAG, "NetConfRevision Changed. Old: " + this.netconfRevision + ", New: " + cfg.netconfRevision);
+//
+//            return false;
+//        }
+
+        if (!Arrays.equals(assignedAddresses, cfg.assignedAddresses)) {
+
+            ArrayList<String> aaCurrent = new ArrayList<>();
+            ArrayList<String> aaNew = new ArrayList<>();
+            for (InetSocketAddress s : assignedAddresses) {
+                aaCurrent.add(s.toString());
+            }
+            for (InetSocketAddress s : cfg.assignedAddresses) {
+                aaNew.add(s.toString());
+            }
+            Collections.sort(aaCurrent);
+            Collections.sort(aaNew);
 
-        if (!aaEqual) {
             Log.i(TAG, "Assigned Addresses Changed");
             Log.i(TAG, "Old:");
             for (String s : aaCurrent) {
                 Log.i(TAG, "    " + s);
             }
+            Log.i(TAG, "");
             Log.i(TAG, "New:");
             for (String s : aaNew) {
                 Log.i(TAG, "    " +s);
             }
+            Log.i(TAG, "");
+
+            return false;
         }
 
-        if (!routesEqual) {
+        if (!Arrays.equals(routes, cfg.routes)) {
+
+            ArrayList<String> rCurrent = new ArrayList<>();
+            ArrayList<String> rNew = new ArrayList<>();
+            for (VirtualNetworkRoute r : routes) {
+                rCurrent.add(r.toString());
+            }
+            for (VirtualNetworkRoute r : cfg.routes) {
+                rNew.add(r.toString());
+            }
+            Collections.sort(rCurrent);
+            Collections.sort(rNew);
+
             Log.i(TAG, "Managed Routes Changed");
             Log.i(TAG, "Old:");
             for (String s : rCurrent) {
                 Log.i(TAG, "    " + s);
             }
+            Log.i(TAG, "");
             Log.i(TAG, "New:");
             for (String s : rNew) {
                 Log.i(TAG, "    " + s);
             }
+            Log.i(TAG, "");
+
+            return false;
         }
 
-        boolean dnsEquals = false;
-        if (this.dns == null || cfg.dns == null) {
-            dnsEquals = true;
-        } else if (this.dns != null) {
-            dnsEquals = this.dns.equals(cfg.dns);
+        boolean dnsEquals;
+        if (this.dns == null) {
+            //noinspection RedundantIfStatement
+            if (cfg.dns == null) {
+                dnsEquals = true;
+            } else {
+                dnsEquals = false;
+            }
+        } else {
+            if (cfg.dns == null) {
+                dnsEquals = false;
+            } else {
+                dnsEquals = this.dns.equals(cfg.dns);
+            }
+        }
+
+        if (!dnsEquals) {
+            return false;
         }
 
-        return this.nwid == cfg.nwid &&
-               this.mac == cfg.mac &&
-               this.name.equals(cfg.name) &&
-               this.status.equals(cfg.status) &&
-               this.type.equals(cfg.type) &&
-               this.mtu == cfg.mtu &&
-               this.dhcp == cfg.dhcp &&
-               this.bridge == cfg.bridge &&
-               this.broadcastEnabled == cfg.broadcastEnabled &&
-               this.portError == cfg.portError &&
-               this.enabled == cfg.enabled &&
-               dnsEquals &&
-               aaEqual && routesEqual;
+        return true;
     }
 
+    @Override
     public int compareTo(VirtualNetworkConfig cfg) {
-        if(cfg.nwid == this.nwid) {
-            return 0;
-        } else {
-            return this.nwid > cfg.nwid ? 1 : -1;
-        }
+        return Long.compare(this.nwid, cfg.nwid);
+    }
+
+    @Override
+    public int hashCode() {
+
+        int result = 17;
+        result = 37 * result + (int) (nwid ^ (nwid >>> 32));
+        result = 37 * result + (int) (mac ^ (mac >>> 32));
+        result = 37 * result + name.hashCode();
+        result = 37 * result + status.hashCode();
+        result = 37 * result + type.hashCode();
+        result = 37 * result + mtu;
+        result = 37 * result + (dhcp ? 1 : 0);
+        result = 37 * result + (bridge ? 1 : 0);
+        result = 37 * result + (broadcastEnabled ? 1 : 0);
+//        result = 37 * result + portError;
+//        result = 37 * result + (int) (netconfRevision ^ (netconfRevision >>> 32));
+        result = 37 * result + Arrays.hashCode(assignedAddresses);
+        result = 37 * result + Arrays.hashCode(routes);
+        result = 37 * result + (dns == null ? 0 : dns.hashCode());
+
+        return result;
     }
 
     /**
      * 64-bit ZeroTier network ID
      */
-    public final long networkId() {
+    public long getNwid() {
         return nwid;
     }
 
     /**
-     * Ethernet MAC (40 bits) that should be assigned to port
+     * Ethernet MAC (48 bits) that should be assigned to port
      */
-    public final long macAddress() {
+    public long getMac() {
         return mac;
     }
 
     /**
      * Network name (from network configuration master)
      */
-    public final String name() {
+    public String getName() {
         return name;
     }
 
     /**
      * Network configuration request status
      */
-    public final VirtualNetworkStatus networkStatus() {
+    public VirtualNetworkStatus getStatus() {
         return status;
     }
 
     /**
      * Network type
      */
-    public final VirtualNetworkType networkType() {
+    public VirtualNetworkType getType() {
         return type;
     }
 
     /**
      * Maximum interface MTU
      */
-    public final int mtu() {
+    public int getMtu() {
         return mtu;
     }
 
@@ -230,7 +338,7 @@ public final class VirtualNetworkConfig implements Comparable<VirtualNetworkConf
      * for security or other reasons. This is simply a netconf parameter that
      * means 'DHCP is available on this network.'</p>
      */
-    public final boolean isDhcpAvailable() {
+    public boolean isDhcp() {
         return dhcp;
     }
 
@@ -240,35 +348,35 @@ public final class VirtualNetworkConfig implements Comparable<VirtualNetworkConf
      * <p>This is informational. If this is false, bridged packets will simply
      * be dropped and bridging won't work.</p>
      */
-    public final boolean isBridgeEnabled() {
+    public boolean isBridge() {
         return bridge;
     }
 
     /**
      * If true, this network supports and allows broadcast (ff:ff:ff:ff:ff:ff) traffic
      */
-    public final boolean broadcastEnabled() {
+    public boolean isBroadcastEnabled() {
         return broadcastEnabled;
     }
 
     /**
      * If the network is in PORT_ERROR state, this is the error most recently returned by the port config callback
      */
-    public final int portError() {
-        return portError;
-    }
+//    public int getPortError() {
+//        return portError;
+//    }
 
     /**
      * Network config revision as reported by netconf master
      *
      * <p>If this is zero, it means we're still waiting for our netconf.</p>
      */
-    public final long netconfRevision() {
-        return netconfRevision;
-    }
+//    public long getNetconfRevision() {
+//        return netconfRevision;
+//    }
 
     /**
-     * ZeroTier-assigned addresses (in {@link java.net.InetSocketAddress} objects)
+     * ZeroTier-assigned addresses (in {@link InetSocketAddress} objects)
      *
      * For IP, the port number of the sockaddr_XX structure contains the number
      * of bits in the address netmask. Only the IP address and port are used.
@@ -277,16 +385,21 @@ public final class VirtualNetworkConfig implements Comparable<VirtualNetworkConf
      * This is only used for ZeroTier-managed address assignments sent by the
      * virtual network's configuration master.
      */
-    public final InetSocketAddress[] assignedAddresses() {
+    public InetSocketAddress[] getAssignedAddresses() {
         return assignedAddresses;
     }
 
     /**
-     * ZeroTier-assigned routes (in {@link com.zerotier.sdk.VirtualNetworkRoute} objects)
-     *
-     * @return
+     * ZeroTier-assigned routes (in {@link VirtualNetworkRoute} objects)
      */
-    public final VirtualNetworkRoute[] routes() { return routes; }
+    public VirtualNetworkRoute[] getRoutes() {
+        return routes;
+    }
 
-    public final VirtualNetworkDNS dns() { return dns; }
+    /**
+     * Network specific DNS configuration
+     */
+    public VirtualNetworkDNS getDns() {
+        return dns;
+    }
 }

java/src/com/zerotier/sdk/VirtualNetworkConfigListener.java

@@ -25,11 +25,11 @@
  * LLC. Start here: http://www.zerotier.com/
  */
 
-
 package com.zerotier.sdk;
 
 
 public interface VirtualNetworkConfigListener {
+
     /**
      * Callback called to update virtual network port configuration
      *
@@ -40,7 +40,7 @@ public interface VirtualNetworkConfigListener {
      * This in turn should be used by the underlying implementation to create
      * and configure tap devices at the OS (or virtual network stack) layer.</P>
      *
-     * This should not call {@link Node#multicastSubscribe} or other network-modifying
+     * This should not call {@link Node#multicastSubscribe(long, long)} or other network-modifying
      * methods, as this could cause a deadlock in multithreaded or interrupt
      * driven environments.
      *
@@ -53,8 +53,8 @@ public interface VirtualNetworkConfigListener {
      * @param config {@link VirtualNetworkConfig} object with the new configuration
      * @return 0 on success
      */
-    public int onNetworkConfigurationUpdated(
+    int onNetworkConfigurationUpdated(
             long nwid,
             VirtualNetworkConfigOperation op,
             VirtualNetworkConfig config);
-}
+}

java/src/com/zerotier/sdk/VirtualNetworkConfigOperation.java

@@ -24,26 +24,55 @@
  * redistribute it in a modified binary form, please contact ZeroTier Networks
  * LLC. Start here: http://www.zerotier.com/
  */
+
 package com.zerotier.sdk;
 
+/**
+ * Virtual network configuration update type
+ *
+ * Defined in ZeroTierOne.h as ZT_VirtualNetworkConfigOperation
+ */
 public enum VirtualNetworkConfigOperation {
+
     /**
      * Network is coming up (either for the first time or after service restart)
      */
-    VIRTUAL_NETWORK_CONFIG_OPERATION_UP,
+    VIRTUAL_NETWORK_CONFIG_OPERATION_UP(1),
 
     /**
      * Network configuration has been updated
      */
-    VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE,
+    VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE(2),
 
     /**
      * Network is going down (not permanently)
      */
-    VIRTUAL_NETWORK_CONFIG_OPERATION_DOWN,
+    VIRTUAL_NETWORK_CONFIG_OPERATION_DOWN(3),
 
     /**
      * Network is going down permanently (leave/delete)
      */
-    VIRTUAL_NETWORK_CONFIG_OPERATION_DESTROY
+    VIRTUAL_NETWORK_CONFIG_OPERATION_DESTROY(4);
+
+    @SuppressWarnings({"FieldCanBeLocal", "unused"})
+    private final int id;
+
+    VirtualNetworkConfigOperation(int id) {
+        this.id = id;
+    }
+
+    public static VirtualNetworkConfigOperation fromInt(int id) {
+        switch (id) {
+            case 1:
+                return VIRTUAL_NETWORK_CONFIG_OPERATION_UP;
+            case 2:
+                return VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE;
+            case 3:
+                return VIRTUAL_NETWORK_CONFIG_OPERATION_DOWN;
+            case 4:
+                return VIRTUAL_NETWORK_CONFIG_OPERATION_DESTROY;
+            default:
+                throw new RuntimeException("Unhandled value: " + id);
+        }
+    }
 }

java/src/com/zerotier/sdk/VirtualNetworkDNS.java

@@ -8,15 +8,48 @@ package com.zerotier.sdk;
 import java.net.InetSocketAddress;
 import java.util.ArrayList;
 
+/**
+ * DNS configuration to be pushed on a virtual network
+ *
+ * Defined in ZeroTierOne.h as ZT_VirtualNetworkDNS
+ */
 public class VirtualNetworkDNS implements Comparable<VirtualNetworkDNS> {
-    private String domain;
-    private ArrayList<InetSocketAddress> servers;
 
-    public VirtualNetworkDNS() {}
+    private final String domain;
+    private final ArrayList<InetSocketAddress> servers;
+
+    public VirtualNetworkDNS(String domain, ArrayList<InetSocketAddress> servers) {
+        this.domain = domain;
+        this.servers = servers;
+    }
+
+    @Override
+    public String toString() {
+        return "VirtualNetworkDNS(" + domain + ", " + servers + ")";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+
+        if (o == null) {
+            return false;
+        }
+
+        if (!(o instanceof VirtualNetworkDNS)) {
+            return false;
+        }
 
-    public boolean equals(VirtualNetworkDNS o) {
-        if (o == null) return false;
-        return domain.equals(o.domain) && servers.equals(o.servers);
+        VirtualNetworkDNS d = (VirtualNetworkDNS) o;
+
+        if (!domain.equals(d.domain)) {
+            return false;
+        }
+
+        if (!servers.equals(d.servers)) {
+            return false;
+        }
+
+        return true;
     }
 
     @Override
@@ -24,7 +57,21 @@ public class VirtualNetworkDNS implements Comparable<VirtualNetworkDNS> {
         return domain.compareTo(o.domain);
     }
 
-    public String getSearchDomain() { return domain; }
+    @Override
+    public int hashCode() {
+
+        int result = 17;
+        result = 37 * result + domain.hashCode();
+        result = 37 * result + servers.hashCode();
+
+        return result;
+    }
+
+    public String getDomain() {
+        return domain;
+    }
 
-    public ArrayList<InetSocketAddress> getServers() { return servers; }
+    public ArrayList<InetSocketAddress> getServers() {
+        return servers;
+    }
 }

java/src/com/zerotier/sdk/VirtualNetworkFrameListener.java

@@ -28,17 +28,18 @@
 package com.zerotier.sdk;
 
 public interface VirtualNetworkFrameListener {
+
     /**
      * Function to send a frame out to a virtual network port
      * 
      * @param nwid ZeroTier One network ID
      * @param srcMac source MAC address
      * @param destMac destination MAC address
-     * @param ethertype
-     * @param vlanId
+     * @param etherType EtherType
+     * @param vlanId VLAN ID
      * @param frameData data to send
      */
-    public void onVirtualNetworkFrame(
+    void onVirtualNetworkFrame(
                 long nwid,
                 long srcMac,
                 long destMac,

java/src/com/zerotier/sdk/VirtualNetworkRoute.java

@@ -29,80 +29,135 @@ package com.zerotier.sdk;
 
 import java.net.InetSocketAddress;
 
-public final class VirtualNetworkRoute implements Comparable<VirtualNetworkRoute>
+/**
+ * A route to be pushed on a virtual network
+ *
+ * Defined in ZeroTierOne.h as ZT_VirtualNetworkRoute
+ */
+public 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;
-
+    private final InetSocketAddress target;
+    
 	/**
 	 * Gateway IP address (port ignored) or NULL (family == 0) for LAN-local (no gateway)
 	 */
-	public InetSocketAddress via;
+    private final InetSocketAddress via;
 
 	/**
 	 * Route flags
 	 */
-	public int flags;
+    private final int flags;
 
 	/**
 	 * Route metric (not currently used)
 	 */
-	public int metric;
+    private final int metric;
 
-	@Override
+    public VirtualNetworkRoute(InetSocketAddress target, InetSocketAddress via, int flags, int metric) {
+        this.target = target;
+        this.via = via;
+        this.flags = flags;
+        this.metric = metric;
+    }
+
+    @Override
     public String toString() {
-	    StringBuilder sb = new StringBuilder();
-	    sb.append(target.toString());
-        if (via != null) {
-            sb.append(via.toString());
-        }
-        return sb.toString();
+        return "VirtualNetworkRoute(" + target + ", " + via + ", " + flags + ", " + metric + ")";
     }
 
     @Override
-	public int compareTo(VirtualNetworkRoute other) {
-        return this.toString().compareTo(other.toString());
-	}
-
-    public boolean equals(VirtualNetworkRoute other) {
-        boolean targetEquals = false;
-        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;
+    public int compareTo(VirtualNetworkRoute other) {
+        throw new RuntimeException("Unimplemented");
+    }
+
+    @Override
+    public boolean equals(Object o) {
+
+        if (!(o instanceof VirtualNetworkRoute)) {
+            return false;
         }
-        else {
-            targetEquals = target.toString().equals(other.target.toString());
+
+        VirtualNetworkRoute other = (VirtualNetworkRoute) o;
+
+        boolean targetEquals;
+        if (target == null) {
+            //noinspection RedundantIfStatement
+            if (other.target == null) {
+                targetEquals = true;
+            } else {
+                targetEquals = false;
+            }
+        } else {
+            if (other.target == null) {
+                targetEquals = false;
+            } else {
+                targetEquals = target.equals(other.target);
+            }
         }
 
+        if (!targetEquals) {
+            return false;
+        }
 
         boolean viaEquals;
-        if (via == null && other.via == null) {
-            viaEquals = true;
+        if (via == null) {
+            //noinspection RedundantIfStatement
+            if (other.via == null) {
+                viaEquals = true;
+            } else {
+                viaEquals = false;
+            }
+        } else {
+            if (other.via == null) {
+                viaEquals = false;
+            } else {
+                viaEquals = via.equals(other.via);
+            }
         }
-        else if (via == null && other.via != null) {
-            viaEquals = false;
+
+        if (!viaEquals) {
+            return false;
         }
-        else if (via != null && other.via == null) {
-            viaEquals = false;
+
+        if (flags != other.flags) {
+            return false;
         }
-        else {
-            viaEquals = via.toString().equals(other.via.toString());
+
+        if (metric != other.metric) {
+            return false;
         }
 
-        return viaEquals && targetEquals;
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+
+        int result = 17;
+        result = 37 * result + (target == null ? 0 : target.hashCode());
+        result = 37 * result + (via == null ? 0 : via.hashCode());
+        result = 37 * result + flags;
+        result = 37 * result + metric;
+
+        return result;
+    }
+
+    public InetSocketAddress getTarget() {
+        return target;
+    }
+
+    public InetSocketAddress getVia() {
+        return via;
+    }
+
+    public int getFlags() {
+        return flags;
+    }
+
+    public int getMetric() {
+        return metric;
     }
 }

java/src/com/zerotier/sdk/VirtualNetworkStatus.java

@@ -24,41 +24,76 @@
  * redistribute it in a modified binary form, please contact ZeroTier Networks
  * LLC. Start here: http://www.zerotier.com/
  */
+
 package com.zerotier.sdk;
 
+/**
+ * Virtual network status codes
+ *
+ * Defined in ZeroTierOne.h as ZT_VirtualNetworkStatus
+ */
 public enum VirtualNetworkStatus {
+
     /**
      * Waiting for network configuration (also means revision == 0)
      */
-    NETWORK_STATUS_REQUESTING_CONFIGURATION,
+    NETWORK_STATUS_REQUESTING_CONFIGURATION(0),
 
     /**
      * Configuration received and we are authorized
      */
-    NETWORK_STATUS_OK,
-
-    /**
-     * Netconf master said SSO auth required.
-     */
-    NETWORK_STATUS_AUTHENTICATION_REQUIRED,
+    NETWORK_STATUS_OK(1),
 
     /**
      * Netconf master told us 'nope'
      */
-    NETWORK_STATUS_ACCESS_DENIED,
+    NETWORK_STATUS_ACCESS_DENIED(2),
 
     /**
      * Netconf master exists, but this virtual network does not
      */
-    NETWORK_STATUS_NOT_FOUND,
+    NETWORK_STATUS_NOT_FOUND(3),
 
     /**
      * Initialization of network failed or other internal error
      */
-    NETWORK_STATUS_PORT_ERROR,
+    NETWORK_STATUS_PORT_ERROR(4),
 
     /**
      * ZeroTier One version too old
      */
-    NETWORK_STATUS_CLIENT_TOO_OLD
+    NETWORK_STATUS_CLIENT_TOO_OLD(5),
+
+    /**
+     * External authentication is required (e.g. SSO)
+     */
+    NETWORK_STATUS_AUTHENTICATION_REQUIRED(6);
+
+    @SuppressWarnings({"FieldCanBeLocal", "unused"})
+    private final int id;
+
+    VirtualNetworkStatus(int id) {
+        this.id = id;
+    }
+
+    public static VirtualNetworkStatus fromInt(int id) {
+        switch (id) {
+            case 0:
+                return NETWORK_STATUS_REQUESTING_CONFIGURATION;
+            case 1:
+                return NETWORK_STATUS_OK;
+            case 2:
+                return NETWORK_STATUS_ACCESS_DENIED;
+            case 3:
+                return NETWORK_STATUS_NOT_FOUND;
+            case 4:
+                return NETWORK_STATUS_PORT_ERROR;
+            case 5:
+                return NETWORK_STATUS_CLIENT_TOO_OLD;
+            case 6:
+                return NETWORK_STATUS_AUTHENTICATION_REQUIRED;
+            default:
+                throw new RuntimeException("Unhandled value: " + id);
+        }
+    }
 }

java/src/com/zerotier/sdk/VirtualNetworkType.java

@@ -24,16 +24,41 @@
  * redistribute it in a modified binary form, please contact ZeroTier Networks
  * LLC. Start here: http://www.zerotier.com/
  */
+
 package com.zerotier.sdk;
 
+/**
+ * Virtual network type codes
+ *
+ * Defined in ZeroTierOne.h as ZT_VirtualNetworkType
+ */
 public enum VirtualNetworkType {
+
     /**
      * Private networks are authorized via certificates of membership
      */
-    NETWORK_TYPE_PRIVATE,
+    NETWORK_TYPE_PRIVATE(0),
 
     /**
      * Public networks have no access control -- they'll always be AUTHORIZED
      */
-    NETWORK_TYPE_PUBLIC
+    NETWORK_TYPE_PUBLIC(1);
+
+    @SuppressWarnings({"FieldCanBeLocal", "unused"})
+    private final int id;
+
+    VirtualNetworkType(int id) {
+        this.id = id;
+    }
+
+    public static VirtualNetworkType fromInt(int id) {
+        switch (id) {
+            case 0:
+                return NETWORK_TYPE_PRIVATE;
+            case 1:
+                return NETWORK_TYPE_PUBLIC;
+            default:
+                throw new RuntimeException("Unhandled value: " + id);
+        }
+    }
 }

java/src/com/zerotier/sdk/util/StringUtils.java

@@ -0,0 +1,52 @@
+/*
+ * ZeroTier One - Network Virtualization Everywhere
+ * Copyright (C) 2011-2023  ZeroTier, Inc.  https://www.zerotier.com/
+ */
+
+package com.zerotier.sdk.util;
+
+public class StringUtils {
+
+    /**
+     * Convert mac address to string.
+     *
+     * @param mac MAC address
+     * @return string in XX:XX:XX:XX:XX:XX format
+     */
+    public static String macAddressToString(long mac) {
+
+        int[] macChars = new int[6];
+        for (int i = 0; i < 6; i++) {
+            macChars[i] = (int) (mac % 256);
+            mac >>= 8;
+        }
+
+        return String.format("%02x:%02x:%02x:%02x:%02x:%02x", macChars[5], macChars[4], macChars[3], macChars[2], macChars[1], macChars[0]);
+    }
+
+    /**
+     * Convert long to hex string.
+     *
+     * @param networkId long
+     * @return string with 0 padding
+     */
+    public static String networkIdToString(long networkId) {
+        return String.format("%016x", networkId);
+    }
+
+    /**
+     * Convert node address to string.
+     *
+     * Node addresses are 40 bits, so print 10 hex characters.
+     *
+     * @param address Node address
+     * @return formatted string
+     */
+    public static String addressToString(long address) {
+        return String.format("%010x", address);
+    }
+
+    public static String etherTypeToString(long etherType) {
+        return String.format("%04x", etherType);
+    }
+}

java/test/com/zerotier/sdk/util/StringUtilsTest.java

@@ -0,0 +1,73 @@
+/*
+ * ZeroTier One - Network Virtualization Everywhere
+ * Copyright (C) 2011-2023  ZeroTier, Inc.  https://www.zerotier.com/
+ */
+
+package com.zerotier.sdk.util;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class StringUtilsTest {
+
+    public StringUtilsTest() {
+    }
+
+    public String oldMacDisplay(long mac) {
+
+        String macStr = Long.toHexString(mac);
+
+        if (macStr.length() > 12) {
+            throw new RuntimeException();
+        }
+
+        while (macStr.length() < 12) {
+            //noinspection StringConcatenationInLoop
+            macStr = "0" + macStr;
+        }
+
+        //noinspection StringBufferReplaceableByString
+        StringBuilder displayMac = new StringBuilder();
+        displayMac.append(macStr.charAt(0));
+        displayMac.append(macStr.charAt(1));
+        displayMac.append(':');
+        displayMac.append(macStr.charAt(2));
+        displayMac.append(macStr.charAt(3));
+        displayMac.append(':');
+        displayMac.append(macStr.charAt(4));
+        displayMac.append(macStr.charAt(5));
+        displayMac.append(':');
+        displayMac.append(macStr.charAt(6));
+        displayMac.append(macStr.charAt(7));
+        displayMac.append(':');
+        displayMac.append(macStr.charAt(8));
+        displayMac.append(macStr.charAt(9));
+        displayMac.append(':');
+        displayMac.append(macStr.charAt(10));
+        displayMac.append(macStr.charAt(11));
+
+        return displayMac.toString();
+    }
+
+    @Test
+    public void testMacDisplay() {
+
+        long mac1 = 1234567891;
+        assertThat(StringUtils.macAddressToString(mac1)).isEqualTo(oldMacDisplay(mac1));
+
+        long mac2 = 999999999;
+        assertThat(StringUtils.macAddressToString(mac2)).isEqualTo(oldMacDisplay(mac2));
+
+        long mac3 = 0x7fffffffffffL;
+        assertThat(StringUtils.macAddressToString(mac3)).isEqualTo(oldMacDisplay(mac3));
+        assertThat(StringUtils.macAddressToString(mac3)).isEqualTo("7f:ff:ff:ff:ff:ff");
+
+        long mac4 = 0x7fafcf3f8fffL;
+        assertThat(StringUtils.macAddressToString(mac4)).isEqualTo(oldMacDisplay(mac4));
+        assertThat(StringUtils.macAddressToString(mac4)).isEqualTo("7f:af:cf:3f:8f:ff");
+    }
+}

make-linux.mk

@@ -146,6 +146,9 @@ endif
 ifeq ($(CC_MACH),e2k)
 	ZT_ARCHITECTURE=2
 endif
+ifeq ($(CC_MACH),e2k64)
+	ZT_ARCHITECTURE=2
+endif
 ifeq ($(CC_MACH),i386)
 	ZT_ARCHITECTURE=1
 	ZT_SSO_SUPPORTED=1

node/Peer.cpp

@@ -530,7 +530,9 @@ unsigned int Peer::doPingAndKeepalive(void *tPtr,int64_t now)
 	performMultipathStateCheck(tPtr, now);
 
 	const bool sendFullHello = ((now - _lastSentFullHello) >= ZT_PEER_PING_PERIOD);
-	_lastSentFullHello = now;
+	if (sendFullHello) {
+		_lastSentFullHello = now;
+	}
 
 	// Right now we only keep pinging links that have the maximum priority. The
 	// priority is used to track cluster redirections, meaning that when a cluster

one.cpp

@@ -2235,6 +2235,27 @@ int main(int argc,char **argv)
 		}
 	}
 
+	// Check and fix permissions on critical files at startup
+	try {
+		char p[4096];
+		OSUtils::ztsnprintf(p, sizeof(p), "%s" ZT_PATH_SEPARATOR_S "identity.secret", homeDir.c_str());
+		if (OSUtils::fileExists(p)) {
+			OSUtils::lockDownFile(p, false);
+		}
+	}
+	catch (...) {
+	}
+
+	try {
+		char p[4096];
+		OSUtils::ztsnprintf(p, sizeof(p), "%s" ZT_PATH_SEPARATOR_S "authtoken.secret", homeDir.c_str());
+		if (OSUtils::fileExists(p)) {
+			OSUtils::lockDownFile(p, false);
+		}
+	}
+	catch (...) {
+	}
+
 	// This can be removed once the new controller code has been around for many versions
 	if (OSUtils::fileExists((homeDir + ZT_PATH_SEPARATOR_S + "controller.db").c_str(),true)) {
 		fprintf(stderr,"%s: FATAL: an old controller.db exists in %s -- see instructions in controller/README.md for how to migrate!" ZT_EOL_S,argv[0],homeDir.c_str());

osdep/OSUtils.cpp

@@ -257,6 +257,16 @@ void OSUtils::lockDownFile(const char *path,bool isDir)
 			CloseHandle(processInfo.hProcess);
 			CloseHandle(processInfo.hThread);
 		}
+
+		// Remove 'Everyone' group from R/RX access
+		startupInfo.cb = sizeof(startupInfo);
+		memset(&startupInfo, 0, sizeof(STARTUPINFOA));
+		memset(&processInfo, 0, sizeof(PROCESS_INFORMATION));
+		if (CreateProcessA(NULL, (LPSTR)(std::string("C:\\Windows\\System32\\icacls.exe \"") + path + "\" /remove:g Everyone /t /c /Q").c_str(), NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &startupInfo, &processInfo)) {
+			WaitForSingleObject(processInfo.hProcess, INFINITE);
+			CloseHandle(processInfo.hProcess);
+			CloseHandle(processInfo.hThread);
+		}
 	}
 #endif
 #endif

osdep/WindowsEthernetTap.cpp

@@ -850,12 +850,14 @@ void WindowsEthernetTap::setFriendlyName(const char *dn)
 					NETCON_PROPERTIES *ncp = nullptr;
 					nc->GetProperties(&ncp);
 
-					GUID curId = ncp->guidId;
-					if (curId == _deviceGuid) {
-						wchar_t wtext[255];
-						mbstowcs(wtext, dn, strlen(dn)+1);
-						nc->Rename(wtext);
-						found = true;
+					if (ncp != nullptr) {
+						GUID curId = ncp->guidId;
+						if (curId == _deviceGuid) {
+							wchar_t wtext[255];
+							mbstowcs(wtext, dn, strlen(dn)+1);
+							nc->Rename(wtext);
+							found = true;
+						}
 					}
 					nc->Release();
 				}

service/OneService.cpp

@@ -2271,6 +2271,12 @@ public:
 		if (syncIps) {
 			std::vector<InetAddress> newManagedIps;
 			newManagedIps.reserve(n.config().assignedAddressCount);
+
+#ifdef __APPLE__
+			std::vector<InetAddress> newManagedIps2;
+			newManagedIps2.reserve(n.config().assignedAddressCount);
+#endif
+
 			for(unsigned int i=0;i<n.config().assignedAddressCount;++i) {
 				const InetAddress *ii = reinterpret_cast<const InetAddress *>(&(n.config().assignedAddresses[i]));
 				if (checkIfManagedIsAllowed(n,*ii))
@@ -2290,15 +2296,41 @@ public:
 				}
 			}
 
+
 			for(std::vector<InetAddress>::iterator ip(newManagedIps.begin());ip!=newManagedIps.end();++ip) {
+
+#ifdef __APPLE__
+				// We can't add multiple addresses to an interface on macOs unless we futz with the netmask.
+				// see `man ifconfig`, alias section
+				// "If the address is on the same subnet as the first network address for this interface, a non-conflicting netmask must be given.  Usually 0xffffffff is most appropriate."
+
+				auto same_subnet = [ip](InetAddress i){
+					return ip->network() == i.network();
+				};
+
 				if (std::find(n.managedIps().begin(),n.managedIps().end(),*ip) == n.managedIps().end()) {
+					// if same subnet as a previously added address
+					if (
+						std::find_if(n.managedIps().begin(),n.managedIps().end(), same_subnet) != n.managedIps().end() ||
+						std::find_if(newManagedIps2.begin(),newManagedIps2.end(), same_subnet) != newManagedIps2.end()
+					) {
+						if (ip->isV4()) {
+							ip->setPort(32);
+						} else {
+							ip->setPort(128);
+						}
+					} else {
+						newManagedIps2.push_back(*ip);
+					}
+				}
+#endif
+
 					if (!n.tap()->addIp(*ip))
 						fprintf(stderr,"ERROR: unable to add ip address %s" ZT_EOL_S, ip->toString(ipbuf));
 
 					#ifdef __WINDOWS__
 					WinFWHelper::newICMPRule(*ip, n.config().nwid);
 					#endif
-				}
 			}
 
 #ifdef __APPLE__

tcp-proxy/README.md

@@ -18,7 +18,11 @@ To reduce latency, the tcp-relay should be as close as possible to the nodes it
 
 #### Option 1 - local.conf configuration
 See [Service docs](https://github.com/zerotier/ZeroTierOne/blob/e0acccc3c918b59678033e585b31eb000c68fdf2/service/README.md) for more info on local.conf
-`{ "settings": { "tcpFallbackRelay": "198.51.100.123/443"  } }`
+`{ "settings": { "tcpFallbackRelay": "198.51.100.123/443", "forceTcpRelay": true  } }`
+
+
+In this example, `forceTcpRelay` is enabled. This is helpful for testing or if you know you'll need tcp relay. It takes a few minutes for zerotier-one to realize it needs to relay otherwise. 
+
 
 
 #### Option 2 - redirect 204.80.128.1 to your own IP

tcp-proxy/zerotier-proxy.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=ZeroTier TCP Proxy sample unit
+
+[Service]
+ExecStart=/var/lib/zerotier-one/tcp-proxy
+Restart=on-failure
+
+# The zerotier-one install script creates this user/group
+User=zerotier-one
+Group=zerotier-one
+
+
+[Install]
+WantedBy=multi-user.target

version.h

@@ -27,7 +27,7 @@
 /**
  * Revision
  */
-#define ZEROTIER_ONE_VERSION_REVISION 3
+#define ZEROTIER_ONE_VERSION_REVISION 4
 
 /**
  * Build version

zeroidc/.cargo/config.toml

@@ -1,9 +1,3 @@
-[source.crates-io]
-replace-with = "vendored-sources"
-
-[source.vendored-sources]
-directory = "vendor"
-
 [target.x86_64-apple-darwin]
 rustflags=["-C", "link-arg=-mmacosx-version-min=10.13"]
 

zeroidc/.gitattributes

@@ -0,0 +1,3 @@
+# disable autocrlf because it doesn't mix well with
+# vendored rust packages
+* text=false

zeroidc/vendor/ansi_term/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.lock":"31bb7b361278d99a00595cbd916c444e6fd193b5f0b1ea0cf2d9454440739501","Cargo.toml":"4ca681d6949661455ac88541ffa68ebc7db50cb2b6e9a2134e6d0687da4997c3","LICENCE":"2762990c7fbba9d550802a2593c1d857dcd52596bb0f9f192a97e9a7ac5f4f9e","README.md":"8d983e1bb3cc99724010d9073a5be6452cd49bd57a877525fd0a5dd41e6591d5","examples/256_colours.rs":"5f2845068bc2d93cff4a61f18ffa44fbbbc91be771dfd686d537d343f37041da","examples/basic_colours.rs":"d610795f3743d10d90ec4e5ab32cc09fb16640896cecd2f93fca434a0920397c","examples/rgb_colours.rs":"8399e5131e959a56c932036b790e601fb4ad658856112daf87f933889b443f2c","src/ansi.rs":"988fb87936064fa006fcc9474ac62099c8d6e98d38bb80cec2cd864066482a08","src/debug.rs":"61343f8bf13695020102c033aeaacd9ccd3ec830eacbf9011127e61829451d20","src/difference.rs":"9b4b8f91c72932bfda262abdceff0ec124a5a8dd27d07bd4d2e5e7889135c6c9","src/display.rs":"c04f2397d1d1d86a5e2188c2840c505cb0baeaf9706a88d4bbe56eadc67811b9","src/lib.rs":"b85df4b9b8832cda777db049efa2ec84b9847438fa3feaf8540e597ce2532a47","src/style.rs":"1042fc973f5ea8bbb2a2faec334aad530520b53edc9b3296174ae38c1060490b","src/util.rs":"07c127f732887573a1c9126fc0288e13e7a8f1f803513b95e50aac2905171b0d","src/windows.rs":"7ce7dd6738b9728fcd3908c284b6f29a9bdfb34af761b4c7385cf7e3e1b20e64","src/write.rs":"c9ec03764ad1ecea8b680243c9cafc5e70919fcea7500cc18246ffd8f6bb4b33"},"package":"d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"}

zeroidc/vendor/ansi_term/Cargo.lock

@@ -1,168 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "aho-corasick"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "ansi_term"
-version = "0.12.1"
-dependencies = [
- "doc-comment 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 1.0.94 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "doc-comment"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "itoa"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "memchr"
-version = "2.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "proc-macro2"
-version = "0.4.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "quote"
-version = "0.6.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "regex"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "aho-corasick 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex-syntax 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "ryu"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "serde"
-version = "1.0.94"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "serde_derive 1.0.94 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.94"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.39 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "ryu 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 1.0.94 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "syn"
-version = "0.15.39"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "thread_local"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "unicode-xid"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "winapi"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[metadata]
-"checksum aho-corasick 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "58fb5e95d83b38284460a5fda7d6470aa0b8844d283a0b614b8535e880800d2d"
-"checksum doc-comment 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "923dea538cea0aa3025e8685b20d6ee21ef99c4f77e954a30febbaac5ec73a97"
-"checksum itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "501266b7edd0174f8530248f87f99c88fbe60ca4ef3dd486835b8d8d53136f7f"
-"checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-"checksum memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88579771288728879b57485cc7d6b07d648c9f0141eb955f8ab7f9d45394468e"
-"checksum proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)" = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759"
-"checksum quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)" = "6ce23b6b870e8f94f81fb0a363d65d86675884b34a09043c81e5562f11c1f8e1"
-"checksum regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88c3d9193984285d544df4a30c23a4e62ead42edf70a4452ceb76dac1ce05c26"
-"checksum regex-syntax 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b143cceb2ca5e56d5671988ef8b15615733e7ee16cd348e064333b251b89343f"
-"checksum ryu 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c92464b447c0ee8c4fb3824ecc8383b81717b9f1e74ba2e72540aef7b9f82997"
-"checksum serde 1.0.94 (registry+https://github.com/rust-lang/crates.io-index)" = "076a696fdea89c19d3baed462576b8f6d663064414b5c793642da8dfeb99475b"
-"checksum serde_derive 1.0.94 (registry+https://github.com/rust-lang/crates.io-index)" = "ef45eb79d6463b22f5f9e16d283798b7c0175ba6050bc25c1a946c122727fe7b"
-"checksum serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)" = "051c49229f282f7c6f3813f8286cc1e3323e8051823fce42c7ea80fe13521704"
-"checksum syn 0.15.39 (registry+https://github.com/rust-lang/crates.io-index)" = "b4d960b829a55e56db167e861ddb43602c003c7be0bee1d345021703fac2fb7c"
-"checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
-"checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
-"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
-"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

zeroidc/vendor/ansi_term/Cargo.toml

@@ -1,43 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "ansi_term"
-version = "0.12.1"
-authors = ["[email protected]", "Ryan Scheel (Havvy) <[email protected]>", "Josh Triplett <[email protected]>"]
-description = "Library for ANSI terminal colours and styles (bold, underline)"
-homepage = "https://github.com/ogham/rust-ansi-term"
-documentation = "https://docs.rs/ansi_term"
-readme = "README.md"
-license = "MIT"
-repository = "https://github.com/ogham/rust-ansi-term"
-
-[lib]
-name = "ansi_term"
-[dependencies.serde]
-version = "1.0.90"
-features = ["derive"]
-optional = true
-[dev-dependencies.doc-comment]
-version = "0.3"
-
-[dev-dependencies.regex]
-version = "1.1.9"
-
-[dev-dependencies.serde_json]
-version = "1.0.39"
-
-[features]
-derive_serde_style = ["serde"]
-[target."cfg(target_os=\"windows\")".dependencies.winapi]
-version = "0.3.4"
-features = ["consoleapi", "errhandlingapi", "fileapi", "handleapi", "processenv"]

zeroidc/vendor/ansi_term/LICENCE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Benjamin Sago
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

zeroidc/vendor/ansi_term/README.md

@@ -1,183 +0,0 @@
-# rust-ansi-term [![ansi-term on crates.io](http://meritbadge.herokuapp.com/ansi-term)](https://crates.io/crates/ansi_term) [![Build status](https://img.shields.io/travis/ogham/rust-ansi-term/master.svg?style=flat)](https://travis-ci.org/ogham/rust-ansi-term) [![Build status](https://img.shields.io/appveyor/ci/ogham/rust-ansi-term/master.svg?style=flat&logo=AppVeyor&logoColor=silver)](https://ci.appveyor.com/project/ogham/rust-ansi-term) [![Coverage status](https://coveralls.io/repos/ogham/rust-ansi-term/badge.svg?branch=master&service=github)](https://coveralls.io/github/ogham/rust-ansi-term?branch=master)
-
-This is a library for controlling colours and formatting, such as red bold text or blue underlined text, on ANSI terminals.
-
-### [View the Rustdoc](https://docs.rs/ansi_term/)
-
-
-# Installation
-
-This crate works with [Cargo](http://crates.io). Add the following to your `Cargo.toml` dependencies section:
-
-```toml
-[dependencies]
-ansi_term = "0.12"
-```
-
-
-## Basic usage
-
-There are three main types in this crate that you need to be concerned with: `ANSIString`, `Style`, and `Colour`.
-
-A `Style` holds stylistic information: foreground and background colours, whether the text should be bold, or blinking, or other properties.
-The `Colour` enum represents the available colours.
-And an `ANSIString` is a string paired with a `Style`.
-
-`Color` is also available as an alias to `Colour`.
-
-To format a string, call the `paint` method on a `Style` or a `Colour`, passing in the string you want to format as the argument.
-For example, here’s how to get some red text:
-
-```rust
-use ansi_term::Colour::Red;
-
-println!("This is in red: {}", Red.paint("a red string"));
-```
-
-It’s important to note that the `paint` method does *not* actually return a string with the ANSI control characters surrounding it.
-Instead, it returns an `ANSIString` value that has a `Display` implementation that, when formatted, returns the characters.
-This allows strings to be printed with a minimum of `String` allocations being performed behind the scenes.
-
-If you *do* want to get at the escape codes, then you can convert the `ANSIString` to a string as you would any other `Display` value:
-
-```rust
-use ansi_term::Colour::Red;
-
-let red_string = Red.paint("a red string").to_string();
-```
-
-**Note for Windows 10 users:** On Windows 10, the application must enable ANSI support first:
-
-```rust,ignore
-let enabled = ansi_term::enable_ansi_support();
-```
-
-## Bold, underline, background, and other styles
-
-For anything more complex than plain foreground colour changes, you need to construct `Style` values themselves, rather than beginning with a `Colour`.
-You can do this by chaining methods based on a new `Style`, created with `Style::new()`.
-Each method creates a new style that has that specific property set.
-For example:
-
-```rust
-use ansi_term::Style;
-
-println!("How about some {} and {}?",
-         Style::new().bold().paint("bold"),
-         Style::new().underline().paint("underline"));
-```
-
-For brevity, these methods have also been implemented for `Colour` values, so you can give your styles a foreground colour without having to begin with an empty `Style` value:
-
-```rust
-use ansi_term::Colour::{Blue, Yellow};
-
-println!("Demonstrating {} and {}!",
-         Blue.bold().paint("blue bold"),
-         Yellow.underline().paint("yellow underline"));
-
-println!("Yellow on blue: {}", Yellow.on(Blue).paint("wow!"));
-```
-
-The complete list of styles you can use are:
-`bold`, `dimmed`, `italic`, `underline`, `blink`, `reverse`, `hidden`, and `on` for background colours.
-
-In some cases, you may find it easier to change the foreground on an existing `Style` rather than starting from the appropriate `Colour`.
-You can do this using the `fg` method:
-
-```rust
-use ansi_term::Style;
-use ansi_term::Colour::{Blue, Cyan, Yellow};
-
-println!("Yellow on blue: {}", Style::new().on(Blue).fg(Yellow).paint("yow!"));
-println!("Also yellow on blue: {}", Cyan.on(Blue).fg(Yellow).paint("zow!"));
-```
-
-You can turn a `Colour` into a `Style` with the `normal` method.
-This will produce the exact same `ANSIString` as if you just used the `paint` method on the `Colour` directly, but it’s useful in certain cases: for example, you may have a method that returns `Styles`, and need to represent both the “red bold” and “red, but not bold” styles with values of the same type. The `Style` struct also has a `Default` implementation if you want to have a style with *nothing* set.
-
-```rust
-use ansi_term::Style;
-use ansi_term::Colour::Red;
-
-Red.normal().paint("yet another red string");
-Style::default().paint("a completely regular string");
-```
-
-
-## Extended colours
-
-You can access the extended range of 256 colours by using the `Colour::Fixed` variant, which takes an argument of the colour number to use.
-This can be included wherever you would use a `Colour`:
-
-```rust
-use ansi_term::Colour::Fixed;
-
-Fixed(134).paint("A sort of light purple");
-Fixed(221).on(Fixed(124)).paint("Mustard in the ketchup");
-```
-
-The first sixteen of these values are the same as the normal and bold standard colour variants.
-There’s nothing stopping you from using these as `Fixed` colours instead, but there’s nothing to be gained by doing so either.
-
-You can also access full 24-bit colour by using the `Colour::RGB` variant, which takes separate `u8` arguments for red, green, and blue:
-
-```rust
-use ansi_term::Colour::RGB;
-
-RGB(70, 130, 180).paint("Steel blue");
-```
-
-## Combining successive coloured strings
-
-The benefit of writing ANSI escape codes to the terminal is that they *stack*: you do not need to end every coloured string with a reset code if the text that follows it is of a similar style.
-For example, if you want to have some blue text followed by some blue bold text, it’s possible to send the ANSI code for blue, followed by the ANSI code for bold, and finishing with a reset code without having to have an extra one between the two strings.
-
-This crate can optimise the ANSI codes that get printed in situations like this, making life easier for your terminal renderer.
-The `ANSIStrings` struct takes a slice of several `ANSIString` values, and will iterate over each of them, printing only the codes for the styles that need to be updated as part of its formatting routine.
-
-The following code snippet uses this to enclose a binary number displayed in red bold text inside some red, but not bold, brackets:
-
-```rust
-use ansi_term::Colour::Red;
-use ansi_term::{ANSIString, ANSIStrings};
-
-let some_value = format!("{:b}", 42);
-let strings: &[ANSIString<'static>] = &[
-    Red.paint("["),
-    Red.bold().paint(some_value),
-    Red.paint("]"),
-];
-
-println!("Value: {}", ANSIStrings(strings));
-```
-
-There are several things to note here.
-Firstly, the `paint` method can take *either* an owned `String` or a borrowed `&str`.
-Internally, an `ANSIString` holds a copy-on-write (`Cow`) string value to deal with both owned and borrowed strings at the same time.
-This is used here to display a `String`, the result of the `format!` call, using the same mechanism as some statically-available `&str` slices.
-Secondly, that the `ANSIStrings` value works in the same way as its singular counterpart, with a `Display` implementation that only performs the formatting when required.
-
-## Byte strings
-
-This library also supports formatting `[u8]` byte strings; this supports applications working with text in an unknown encoding.
-`Style` and `Colour` support painting `[u8]` values, resulting in an `ANSIByteString`.
-This type does not implement `Display`, as it may not contain UTF-8, but it does provide a method `write_to` to write the result to any value that implements `Write`:
-
-```rust
-use ansi_term::Colour::Green;
-
-Green.paint("user data".as_bytes()).write_to(&mut std::io::stdout()).unwrap();
-```
-
-Similarly, the type `ANSIByteStrings` supports writing a list of `ANSIByteString` values with minimal escape sequences:
-
-```rust
-use ansi_term::Colour::Green;
-use ansi_term::ANSIByteStrings;
-
-ANSIByteStrings(&[
-    Green.paint("user data 1\n".as_bytes()),
-    Green.bold().paint("user data 2\n".as_bytes()),
-]).write_to(&mut std::io::stdout()).unwrap();
-```

zeroidc/vendor/ansi_term/examples/256_colours.rs

@@ -1,73 +0,0 @@
-extern crate ansi_term;
-use ansi_term::Colour;
-
-// This example prints out the 256 colours.
-// They're arranged like this:
-//
-// - 0 to 8 are the eight standard colours.
-// - 9 to 15 are the eight bold colours.
-// - 16 to 231 are six blocks of six-by-six colour squares.
-// - 232 to 255 are shades of grey.
-
-fn main() {
-
-    // First two lines
-    for c in 0..8 {
-        glow(c, c != 0);
-        print!(" ");
-    }
-    print!("\n");
-    for c in 8..16 {
-        glow(c, c != 8);
-        print!(" ");
-    }
-    print!("\n\n");
-
-    // Six lines of the first three squares
-    for row in 0..6 {
-        for square in 0..3 {
-            for column in 0..6 {
-                glow(16 + square * 36 + row * 6 + column, row >= 3);
-                print!(" ");
-            }
-
-            print!("  ");
-        }
-
-        print!("\n");
-    }
-    print!("\n");
-
-    // Six more lines of the other three squares
-    for row in 0..6 {
-        for square in 0..3 {
-            for column in 0..6 {
-                glow(124 + square * 36 + row * 6 + column, row >= 3);
-                print!(" ");
-            }
-
-            print!("  ");
-        }
-
-        print!("\n");
-    }
-    print!("\n");
-
-    // The last greyscale lines
-    for c in 232..=243 {
-        glow(c, false);
-        print!(" ");
-    }
-    print!("\n");
-    for c in 244..=255 {
-        glow(c, true);
-        print!(" ");
-    }
-    print!("\n");
-}
-
-fn glow(c: u8, light_bg: bool) {
-    let base = if light_bg { Colour::Black } else { Colour::White };
-    let style = base.on(Colour::Fixed(c));
-    print!("{}", style.paint(&format!(" {:3} ", c)));
-}

zeroidc/vendor/ansi_term/examples/basic_colours.rs

@@ -1,18 +0,0 @@
-extern crate ansi_term;
-use ansi_term::{Style, Colour::*};
-
-// This example prints out the 16 basic colours.
-
-fn main() {
-    let normal = Style::default();
-
-    println!("{} {}", normal.paint("Normal"), normal.bold().paint("bold"));
-    println!("{} {}", Black.paint("Black"),   Black.bold().paint("bold"));
-    println!("{} {}", Red.paint("Red"),       Red.bold().paint("bold"));
-    println!("{} {}", Green.paint("Green"),   Green.bold().paint("bold"));
-    println!("{} {}", Yellow.paint("Yellow"), Yellow.bold().paint("bold"));
-    println!("{} {}", Blue.paint("Blue"),     Blue.bold().paint("bold"));
-    println!("{} {}", Purple.paint("Purple"), Purple.bold().paint("bold"));
-    println!("{} {}", Cyan.paint("Cyan"),     Cyan.bold().paint("bold"));
-    println!("{} {}", White.paint("White"),   White.bold().paint("bold"));
-}

zeroidc/vendor/ansi_term/examples/rgb_colours.rs

@@ -1,23 +0,0 @@
-extern crate ansi_term;
-use ansi_term::{Style, Colour};
-
-// This example prints out a colour gradient in a grid by calculating each
-// character’s red, green, and blue components, and using 24-bit colour codes
-// to display them.
-
-const WIDTH:  i32 = 80;
-const HEIGHT: i32 = 24;
-
-fn main() {
-    for row in 0 .. HEIGHT {
-        for col in 0 .. WIDTH {
-            let r = (row * 255 / HEIGHT) as u8;
-            let g = (col * 255 / WIDTH) as u8;
-            let b = 128;
-
-            print!("{}", Style::default().on(Colour::RGB(r, g, b)).paint(" "));
-        }
-
-        print!("\n");
-    }
-}

zeroidc/vendor/ansi_term/src/ansi.rs

@@ -1,374 +0,0 @@
-use style::{Colour, Style};
-
-use std::fmt;
-
-use write::AnyWrite;
-
-
-// ---- generating ANSI codes ----
-
-impl Style {
-
-    /// Write any bytes that go *before* a piece of text to the given writer.
-    fn write_prefix<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-
-        // If there are actually no styles here, then don’t write *any* codes
-        // as the prefix. An empty ANSI code may not affect the terminal
-        // output at all, but a user may just want a code-free string.
-        if self.is_plain() {
-            return Ok(());
-        }
-
-        // Write the codes’ prefix, then write numbers, separated by
-        // semicolons, for each text style we want to apply.
-        write!(f, "\x1B[")?;
-        let mut written_anything = false;
-
-        {
-            let mut write_char = |c| {
-                if written_anything { write!(f, ";")?; }
-                written_anything = true;
-                write!(f, "{}", c)?;
-                Ok(())
-            };
-
-            if self.is_bold           { write_char('1')? }
-            if self.is_dimmed         { write_char('2')? }
-            if self.is_italic         { write_char('3')? }
-            if self.is_underline      { write_char('4')? }
-            if self.is_blink          { write_char('5')? }
-            if self.is_reverse        { write_char('7')? }
-            if self.is_hidden         { write_char('8')? }
-            if self.is_strikethrough  { write_char('9')? }
-        }
-
-        // The foreground and background colours, if specified, need to be
-        // handled specially because the number codes are more complicated.
-        // (see `write_background_code` and `write_foreground_code`)
-        if let Some(bg) = self.background {
-            if written_anything { write!(f, ";")?; }
-            written_anything = true;
-            bg.write_background_code(f)?;
-        }
-
-        if let Some(fg) = self.foreground {
-            if written_anything { write!(f, ";")?; }
-            fg.write_foreground_code(f)?;
-        }
-
-        // All the codes end with an `m`, because reasons.
-        write!(f, "m")?;
-
-        Ok(())
-    }
-
-    /// Write any bytes that go *after* a piece of text to the given writer.
-    fn write_suffix<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        if self.is_plain() {
-            Ok(())
-        }
-        else {
-            write!(f, "{}", RESET)
-        }
-    }
-}
-
-
-/// The code to send to reset all styles and return to `Style::default()`.
-pub static RESET: &str = "\x1B[0m";
-
-
-
-impl Colour {
-    fn write_foreground_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        match *self {
-            Colour::Black      => write!(f, "30"),
-            Colour::Red        => write!(f, "31"),
-            Colour::Green      => write!(f, "32"),
-            Colour::Yellow     => write!(f, "33"),
-            Colour::Blue       => write!(f, "34"),
-            Colour::Purple     => write!(f, "35"),
-            Colour::Cyan       => write!(f, "36"),
-            Colour::White      => write!(f, "37"),
-            Colour::Fixed(num) => write!(f, "38;5;{}", &num),
-            Colour::RGB(r,g,b) => write!(f, "38;2;{};{};{}", &r, &g, &b),
-        }
-    }
-
-    fn write_background_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        match *self {
-            Colour::Black      => write!(f, "40"),
-            Colour::Red        => write!(f, "41"),
-            Colour::Green      => write!(f, "42"),
-            Colour::Yellow     => write!(f, "43"),
-            Colour::Blue       => write!(f, "44"),
-            Colour::Purple     => write!(f, "45"),
-            Colour::Cyan       => write!(f, "46"),
-            Colour::White      => write!(f, "47"),
-            Colour::Fixed(num) => write!(f, "48;5;{}", &num),
-            Colour::RGB(r,g,b) => write!(f, "48;2;{};{};{}", &r, &g, &b),
-        }
-    }
-}
-
-
-/// Like `ANSIString`, but only displays the style prefix.
-///
-/// This type implements the `Display` trait, meaning it can be written to a
-/// `std::fmt` formatting without doing any extra allocation, and written to a
-/// string with the `.to_string()` method. For examples, see
-/// [`Style::prefix`](struct.Style.html#method.prefix).
-#[derive(Clone, Copy, Debug)]
-pub struct Prefix(Style);
-
-/// Like `ANSIString`, but only displays the difference between two
-/// styles.
-///
-/// This type implements the `Display` trait, meaning it can be written to a
-/// `std::fmt` formatting without doing any extra allocation, and written to a
-/// string with the `.to_string()` method. For examples, see
-/// [`Style::infix`](struct.Style.html#method.infix).
-#[derive(Clone, Copy, Debug)]
-pub struct Infix(Style, Style);
-
-/// Like `ANSIString`, but only displays the style suffix.
-///
-/// This type implements the `Display` trait, meaning it can be written to a
-/// `std::fmt` formatting without doing any extra allocation, and written to a
-/// string with the `.to_string()` method. For examples, see
-/// [`Style::suffix`](struct.Style.html#method.suffix).
-#[derive(Clone, Copy, Debug)]
-pub struct Suffix(Style);
-
-
-impl Style {
-
-    /// The prefix bytes for this style. These are the bytes that tell the
-    /// terminal to use a different colour or font style.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::{Style, Colour::Blue};
-    ///
-    /// let style = Style::default().bold();
-    /// assert_eq!("\x1b[1m",
-    ///            style.prefix().to_string());
-    ///
-    /// let style = Blue.bold();
-    /// assert_eq!("\x1b[1;34m",
-    ///            style.prefix().to_string());
-    ///
-    /// let style = Style::default();
-    /// assert_eq!("",
-    ///            style.prefix().to_string());
-    /// ```
-    pub fn prefix(self) -> Prefix {
-        Prefix(self)
-    }
-
-    /// The infix bytes between this style and `next` style. These are the bytes
-    /// that tell the terminal to change the style to `next`. These may include
-    /// a reset followed by the next colour and style, depending on the two styles.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::{Style, Colour::Green};
-    ///
-    /// let style = Style::default().bold();
-    /// assert_eq!("\x1b[32m",
-    ///            style.infix(Green.bold()).to_string());
-    ///
-    /// let style = Green.normal();
-    /// assert_eq!("\x1b[1m",
-    ///            style.infix(Green.bold()).to_string());
-    ///
-    /// let style = Style::default();
-    /// assert_eq!("",
-    ///            style.infix(style).to_string());
-    /// ```
-    pub fn infix(self, next: Style) -> Infix {
-        Infix(self, next)
-    }
-
-    /// The suffix for this style. These are the bytes that tell the terminal
-    /// to reset back to its normal colour and font style.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::{Style, Colour::Green};
-    ///
-    /// let style = Style::default().bold();
-    /// assert_eq!("\x1b[0m",
-    ///            style.suffix().to_string());
-    ///
-    /// let style = Green.normal().bold();
-    /// assert_eq!("\x1b[0m",
-    ///            style.suffix().to_string());
-    ///
-    /// let style = Style::default();
-    /// assert_eq!("",
-    ///            style.suffix().to_string());
-    /// ```
-    pub fn suffix(self) -> Suffix {
-        Suffix(self)
-    }
-}
-
-
-impl Colour {
-
-    /// The prefix bytes for this colour as a `Style`. These are the bytes
-    /// that tell the terminal to use a different colour or font style.
-    ///
-    /// See also [`Style::prefix`](struct.Style.html#method.prefix).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour::Green;
-    ///
-    /// assert_eq!("\x1b[0m",
-    ///            Green.suffix().to_string());
-    /// ```
-    pub fn prefix(self) -> Prefix {
-        Prefix(self.normal())
-    }
-
-    /// The infix bytes between this colour and `next` colour. These are the bytes
-    /// that tell the terminal to use the `next` colour, or to do nothing if
-    /// the two colours are equal.
-    ///
-    /// See also [`Style::infix`](struct.Style.html#method.infix).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour::{Red, Yellow};
-    ///
-    /// assert_eq!("\x1b[33m",
-    ///            Red.infix(Yellow).to_string());
-    /// ```
-    pub fn infix(self, next: Colour) -> Infix {
-        Infix(self.normal(), next.normal())
-    }
-
-    /// The suffix for this colour as a `Style`. These are the bytes that
-    /// tell the terminal to reset back to its normal colour and font style.
-    ///
-    /// See also [`Style::suffix`](struct.Style.html#method.suffix).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour::Purple;
-    ///
-    /// assert_eq!("\x1b[0m",
-    ///            Purple.suffix().to_string());
-    /// ```
-    pub fn suffix(self) -> Suffix {
-        Suffix(self.normal())
-    }
-}
-
-
-impl fmt::Display for Prefix {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let f: &mut fmt::Write = f;
-        self.0.write_prefix(f)
-    }
-}
-
-
-impl fmt::Display for Infix {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use difference::Difference;
-
-        match Difference::between(&self.0, &self.1) {
-            Difference::ExtraStyles(style) => {
-                let f: &mut fmt::Write = f;
-                style.write_prefix(f)
-            },
-            Difference::Reset => {
-                let f: &mut fmt::Write = f;
-                write!(f, "{}{}", RESET, self.1.prefix())
-            },
-            Difference::NoDifference => {
-                Ok(())   // nothing to write
-            },
-        }
-    }
-}
-
-
-impl fmt::Display for Suffix {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let f: &mut fmt::Write = f;
-        self.0.write_suffix(f)
-    }
-}
-
-
-
-#[cfg(test)]
-mod test {
-    use style::Style;
-    use style::Colour::*;
-
-    macro_rules! test {
-        ($name: ident: $style: expr; $input: expr => $result: expr) => {
-            #[test]
-            fn $name() {
-                assert_eq!($style.paint($input).to_string(), $result.to_string());
-
-                let mut v = Vec::new();
-                $style.paint($input.as_bytes()).write_to(&mut v).unwrap();
-                assert_eq!(v.as_slice(), $result.as_bytes());
-            }
-        };
-    }
-
-    test!(plain:                 Style::default();                  "text/plain" => "text/plain");
-    test!(red:                   Red;                               "hi" => "\x1B[31mhi\x1B[0m");
-    test!(black:                 Black.normal();                    "hi" => "\x1B[30mhi\x1B[0m");
-    test!(yellow_bold:           Yellow.bold();                     "hi" => "\x1B[1;33mhi\x1B[0m");
-    test!(yellow_bold_2:         Yellow.normal().bold();            "hi" => "\x1B[1;33mhi\x1B[0m");
-    test!(blue_underline:        Blue.underline();                  "hi" => "\x1B[4;34mhi\x1B[0m");
-    test!(green_bold_ul:         Green.bold().underline();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
-    test!(green_bold_ul_2:       Green.underline().bold();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
-    test!(purple_on_white:       Purple.on(White);                  "hi" => "\x1B[47;35mhi\x1B[0m");
-    test!(purple_on_white_2:     Purple.normal().on(White);         "hi" => "\x1B[47;35mhi\x1B[0m");
-    test!(yellow_on_blue:        Style::new().on(Blue).fg(Yellow);  "hi" => "\x1B[44;33mhi\x1B[0m");
-    test!(yellow_on_blue_2:      Cyan.on(Blue).fg(Yellow);          "hi" => "\x1B[44;33mhi\x1B[0m");
-    test!(cyan_bold_on_white:    Cyan.bold().on(White);             "hi" => "\x1B[1;47;36mhi\x1B[0m");
-    test!(cyan_ul_on_white:      Cyan.underline().on(White);        "hi" => "\x1B[4;47;36mhi\x1B[0m");
-    test!(cyan_bold_ul_on_white: Cyan.bold().underline().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
-    test!(cyan_ul_bold_on_white: Cyan.underline().bold().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
-    test!(fixed:                 Fixed(100);                        "hi" => "\x1B[38;5;100mhi\x1B[0m");
-    test!(fixed_on_purple:       Fixed(100).on(Purple);             "hi" => "\x1B[45;38;5;100mhi\x1B[0m");
-    test!(fixed_on_fixed:        Fixed(100).on(Fixed(200));         "hi" => "\x1B[48;5;200;38;5;100mhi\x1B[0m");
-    test!(rgb:                   RGB(70,130,180);                   "hi" => "\x1B[38;2;70;130;180mhi\x1B[0m");
-    test!(rgb_on_blue:           RGB(70,130,180).on(Blue);          "hi" => "\x1B[44;38;2;70;130;180mhi\x1B[0m");
-    test!(blue_on_rgb:           Blue.on(RGB(70,130,180));          "hi" => "\x1B[48;2;70;130;180;34mhi\x1B[0m");
-    test!(rgb_on_rgb:            RGB(70,130,180).on(RGB(5,10,15));  "hi" => "\x1B[48;2;5;10;15;38;2;70;130;180mhi\x1B[0m");
-    test!(bold:                  Style::new().bold();               "hi" => "\x1B[1mhi\x1B[0m");
-    test!(underline:             Style::new().underline();          "hi" => "\x1B[4mhi\x1B[0m");
-    test!(bunderline:            Style::new().bold().underline();   "hi" => "\x1B[1;4mhi\x1B[0m");
-    test!(dimmed:                Style::new().dimmed();             "hi" => "\x1B[2mhi\x1B[0m");
-    test!(italic:                Style::new().italic();             "hi" => "\x1B[3mhi\x1B[0m");
-    test!(blink:                 Style::new().blink();              "hi" => "\x1B[5mhi\x1B[0m");
-    test!(reverse:               Style::new().reverse();            "hi" => "\x1B[7mhi\x1B[0m");
-    test!(hidden:                Style::new().hidden();             "hi" => "\x1B[8mhi\x1B[0m");
-    test!(stricken:              Style::new().strikethrough();      "hi" => "\x1B[9mhi\x1B[0m");
-
-    #[test]
-    fn test_infix() {
-        assert_eq!(Style::new().dimmed().infix(Style::new()).to_string(), "\x1B[0m");
-        assert_eq!(White.dimmed().infix(White.normal()).to_string(), "\x1B[0m\x1B[37m");
-        assert_eq!(White.normal().infix(White.bold()).to_string(), "\x1B[1m");
-        assert_eq!(White.normal().infix(Blue.normal()).to_string(), "\x1B[34m");
-        assert_eq!(Blue.bold().infix(Blue.bold()).to_string(), "");
-    }
-}

zeroidc/vendor/ansi_term/src/debug.rs

@@ -1,134 +0,0 @@
-use std::fmt;
-
-use style::Style;
-
-/// Styles have a special `Debug` implementation that only shows the fields that
-/// are set. Fields that haven’t been touched aren’t included in the output.
-///
-/// This behaviour gets bypassed when using the alternate formatting mode
-/// `format!("{:#?}")`.
-///
-///     use ansi_term::Colour::{Red, Blue};
-///     assert_eq!("Style { fg(Red), on(Blue), bold, italic }",
-///                format!("{:?}", Red.on(Blue).bold().italic()));
-impl fmt::Debug for Style {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        if fmt.alternate() {
-            fmt.debug_struct("Style")
-               .field("foreground",    &self.foreground)
-               .field("background",    &self.background)
-               .field("blink",         &self.is_blink)
-               .field("bold",          &self.is_bold)
-               .field("dimmed",        &self.is_dimmed)
-               .field("hidden",        &self.is_hidden)
-               .field("italic",        &self.is_italic)
-               .field("reverse",       &self.is_reverse)
-               .field("strikethrough", &self.is_strikethrough)
-               .field("underline",     &self.is_underline)
-               .finish()
-        }
-        else if self.is_plain() {
-            fmt.write_str("Style {}")
-        }
-        else {
-            fmt.write_str("Style { ")?;
-
-            let mut written_anything = false;
-
-            if let Some(fg) = self.foreground {
-                if written_anything { fmt.write_str(", ")? }
-                written_anything = true;
-                write!(fmt, "fg({:?})", fg)?
-            }
-
-            if let Some(bg) = self.background {
-                if written_anything { fmt.write_str(", ")? }
-                written_anything = true;
-                write!(fmt, "on({:?})", bg)?
-            }
-
-            {
-                let mut write_flag = |name| {
-                    if written_anything { fmt.write_str(", ")? }
-                    written_anything = true;
-                    fmt.write_str(name)
-                };
-
-                if self.is_blink          { write_flag("blink")? }
-                if self.is_bold           { write_flag("bold")? }
-                if self.is_dimmed         { write_flag("dimmed")? }
-                if self.is_hidden         { write_flag("hidden")? }
-                if self.is_italic         { write_flag("italic")? }
-                if self.is_reverse        { write_flag("reverse")? }
-                if self.is_strikethrough  { write_flag("strikethrough")? }
-                if self.is_underline      { write_flag("underline")? }
-            }
-
-            write!(fmt, " }}")
-        }
-    }
-}
-
-
-#[cfg(test)]
-mod test {
-    use style::Colour::*;
-    use style::Style;
-
-    fn style() -> Style {
-        Style::new()
-    }
-
-    macro_rules! test {
-        ($name: ident: $obj: expr => $result: expr) => {
-            #[test]
-            fn $name() {
-                assert_eq!($result, format!("{:?}", $obj));
-            }
-        };
-    }
-
-    test!(empty:   style()                  => "Style {}");
-    test!(bold:    style().bold()           => "Style { bold }");
-    test!(italic:  style().italic()         => "Style { italic }");
-    test!(both:    style().bold().italic()  => "Style { bold, italic }");
-
-    test!(red:     Red.normal()                     => "Style { fg(Red) }");
-    test!(redblue: Red.normal().on(RGB(3, 2, 4))    => "Style { fg(Red), on(RGB(3, 2, 4)) }");
-
-    test!(everything:
-            Red.on(Blue).blink().bold().dimmed().hidden().italic().reverse().strikethrough().underline() =>
-            "Style { fg(Red), on(Blue), blink, bold, dimmed, hidden, italic, reverse, strikethrough, underline }");
-
-    #[test]
-    fn long_and_detailed() {
-        extern crate regex;
-        let expected_debug = "Style { fg(Blue), bold }";
-        let expected_pretty_repat = r##"(?x)
-        Style\s+\{\s+
-            foreground:\s+Some\(\s+
-                Blue,?\s+
-            \),\s+
-            background:\s+None,\s+
-            blink:\s+false,\s+
-            bold:\s+true,\s+
-            dimmed:\s+false,\s+
-            hidden:\s+false,\s+
-            italic:\s+false,\s+
-            reverse:\s+false,\s+
-            strikethrough:\s+
-            false,\s+
-            underline:\s+false,?\s+
-            \}"##;
-        let re = regex::Regex::new(expected_pretty_repat).unwrap();
-
-        let style = Blue.bold();
-        let style_fmt_debug = format!("{:?}", style);
-        let style_fmt_pretty = format!("{:#?}", style);
-        println!("style_fmt_debug:\n{}", style_fmt_debug);
-        println!("style_fmt_pretty:\n{}", style_fmt_pretty);
-
-        assert_eq!(expected_debug, style_fmt_debug);
-        assert!(re.is_match(&style_fmt_pretty));
-    }
-}

zeroidc/vendor/ansi_term/src/difference.rs

@@ -1,179 +0,0 @@
-use super::Style;
-
-
-/// When printing out one coloured string followed by another, use one of
-/// these rules to figure out which *extra* control codes need to be sent.
-#[derive(PartialEq, Clone, Copy, Debug)]
-pub enum Difference {
-
-    /// Print out the control codes specified by this style to end up looking
-    /// like the second string's styles.
-    ExtraStyles(Style),
-
-    /// Converting between these two is impossible, so just send a reset
-    /// command and then the second string's styles.
-    Reset,
-
-    /// The before style is exactly the same as the after style, so no further
-    /// control codes need to be printed.
-    NoDifference,
-}
-
-
-impl Difference {
-
-    /// Compute the 'style difference' required to turn an existing style into
-    /// the given, second style.
-    ///
-    /// For example, to turn green text into green bold text, it's redundant
-    /// to write a reset command then a second green+bold command, instead of
-    /// just writing one bold command. This method should see that both styles
-    /// use the foreground colour green, and reduce it to a single command.
-    ///
-    /// This method returns an enum value because it's not actually always
-    /// possible to turn one style into another: for example, text could be
-    /// made bold and underlined, but you can't remove the bold property
-    /// without also removing the underline property. So when this has to
-    /// happen, this function returns None, meaning that the entire set of
-    /// styles should be reset and begun again.
-    pub fn between(first: &Style, next: &Style) -> Difference {
-        use self::Difference::*;
-
-        // XXX(Havvy): This algorithm is kind of hard to replicate without
-        // having the Plain/Foreground enum variants, so I'm just leaving
-        // it commented out for now, and defaulting to Reset.
-
-        if first == next {
-            return NoDifference;
-        }
-
-        // Cannot un-bold, so must Reset.
-        if first.is_bold && !next.is_bold {
-            return Reset;
-        }
-
-        if first.is_dimmed && !next.is_dimmed {
-            return Reset;
-        }
-
-        if first.is_italic && !next.is_italic {
-            return Reset;
-        }
-
-        // Cannot un-underline, so must Reset.
-        if first.is_underline && !next.is_underline {
-            return Reset;
-        }
-
-        if first.is_blink && !next.is_blink {
-            return Reset;
-        }
-
-        if first.is_reverse && !next.is_reverse {
-            return Reset;
-        }
-
-        if first.is_hidden && !next.is_hidden {
-            return Reset;
-        }
-
-        if first.is_strikethrough && !next.is_strikethrough {
-            return Reset;
-        }
-
-        // Cannot go from foreground to no foreground, so must Reset.
-        if first.foreground.is_some() && next.foreground.is_none() {
-            return Reset;
-        }
-
-        // Cannot go from background to no background, so must Reset.
-        if first.background.is_some() && next.background.is_none() {
-            return Reset;
-        }
-
-        let mut extra_styles = Style::default();
-
-        if first.is_bold != next.is_bold {
-            extra_styles.is_bold = true;
-        }
-
-        if first.is_dimmed != next.is_dimmed {
-            extra_styles.is_dimmed = true;
-        }
-
-        if first.is_italic != next.is_italic {
-            extra_styles.is_italic = true;
-        }
-
-        if first.is_underline != next.is_underline {
-            extra_styles.is_underline = true;
-        }
-
-        if first.is_blink != next.is_blink {
-            extra_styles.is_blink = true;
-        }
-
-        if first.is_reverse != next.is_reverse {
-            extra_styles.is_reverse = true;
-        }
-
-        if first.is_hidden != next.is_hidden {
-            extra_styles.is_hidden = true;
-        }
-
-        if first.is_strikethrough != next.is_strikethrough {
-            extra_styles.is_strikethrough = true;
-        }
-
-        if first.foreground != next.foreground {
-            extra_styles.foreground = next.foreground;
-        }
-
-        if first.background != next.background {
-            extra_styles.background = next.background;
-        }
-
-        ExtraStyles(extra_styles)
-    }
-}
-
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use super::Difference::*;
-    use style::Colour::*;
-    use style::Style;
-
-    fn style() -> Style {
-        Style::new()
-    }
-
-    macro_rules! test {
-        ($name: ident: $first: expr; $next: expr => $result: expr) => {
-            #[test]
-            fn $name() {
-                assert_eq!($result, Difference::between(&$first, &$next));
-            }
-        };
-    }
-
-    test!(nothing:    Green.normal(); Green.normal()  => NoDifference);
-    test!(uppercase:  Green.normal(); Green.bold()    => ExtraStyles(style().bold()));
-    test!(lowercase:  Green.bold();   Green.normal()  => Reset);
-    test!(nothing2:   Green.bold();   Green.bold()    => NoDifference);
-
-    test!(colour_change: Red.normal(); Blue.normal() => ExtraStyles(Blue.normal()));
-
-    test!(addition_of_blink:          style(); style().blink()          => ExtraStyles(style().blink()));
-    test!(addition_of_dimmed:         style(); style().dimmed()         => ExtraStyles(style().dimmed()));
-    test!(addition_of_hidden:         style(); style().hidden()         => ExtraStyles(style().hidden()));
-    test!(addition_of_reverse:        style(); style().reverse()        => ExtraStyles(style().reverse()));
-    test!(addition_of_strikethrough:  style(); style().strikethrough()  => ExtraStyles(style().strikethrough()));
-
-    test!(removal_of_strikethrough:   style().strikethrough(); style()  => Reset);
-    test!(removal_of_reverse:         style().reverse();       style()  => Reset);
-    test!(removal_of_hidden:          style().hidden();        style()  => Reset);
-    test!(removal_of_dimmed:          style().dimmed();        style()  => Reset);
-    test!(removal_of_blink:           style().blink();         style()  => Reset);
-}

zeroidc/vendor/ansi_term/src/display.rs

@@ -1,296 +0,0 @@
-use std::borrow::Cow;
-use std::fmt;
-use std::io;
-use std::ops::Deref;
-
-use ansi::RESET;
-use difference::Difference;
-use style::{Style, Colour};
-use write::AnyWrite;
-
-
-/// An `ANSIGenericString` includes a generic string type and a `Style` to
-/// display that string.  `ANSIString` and `ANSIByteString` are aliases for
-/// this type on `str` and `\[u8]`, respectively.
-#[derive(PartialEq, Debug)]
-pub struct ANSIGenericString<'a, S: 'a + ToOwned + ?Sized>
-where <S as ToOwned>::Owned: fmt::Debug {
-    style: Style,
-    string: Cow<'a, S>,
-}
-
-
-/// Cloning an `ANSIGenericString` will clone its underlying string.
-///
-/// # Examples
-///
-/// ```
-/// use ansi_term::ANSIString;
-///
-/// let plain_string = ANSIString::from("a plain string");
-/// let clone_string = plain_string.clone();
-/// assert_eq!(clone_string, plain_string);
-/// ```
-impl<'a, S: 'a + ToOwned + ?Sized> Clone for ANSIGenericString<'a, S>
-where <S as ToOwned>::Owned: fmt::Debug {
-    fn clone(&self) -> ANSIGenericString<'a, S> {
-        ANSIGenericString {
-            style: self.style,
-            string: self.string.clone(),
-        }
-    }
-}
-
-// You might think that the hand-written Clone impl above is the same as the
-// one that gets generated with #[derive]. But it’s not *quite* the same!
-//
-// `str` is not Clone, and the derived Clone implementation puts a Clone
-// constraint on the S type parameter (generated using --pretty=expanded):
-//
-//                  ↓_________________↓
-//     impl <'a, S: ::std::clone::Clone + 'a + ToOwned + ?Sized> ::std::clone::Clone
-//     for ANSIGenericString<'a, S> where
-//     <S as ToOwned>::Owned: fmt::Debug { ... }
-//
-// This resulted in compile errors when you tried to derive Clone on a type
-// that used it:
-//
-//     #[derive(PartialEq, Debug, Clone, Default)]
-//     pub struct TextCellContents(Vec<ANSIString<'static>>);
-//                                 ^^^^^^^^^^^^^^^^^^^^^^^^^
-//     error[E0277]: the trait `std::clone::Clone` is not implemented for `str`
-//
-// The hand-written impl above can ignore that constraint and still compile.
-
-
-
-/// An ANSI String is a string coupled with the `Style` to display it
-/// in a terminal.
-///
-/// Although not technically a string itself, it can be turned into
-/// one with the `to_string` method.
-///
-/// # Examples
-///
-/// ```
-/// use ansi_term::ANSIString;
-/// use ansi_term::Colour::Red;
-///
-/// let red_string = Red.paint("a red string");
-/// println!("{}", red_string);
-/// ```
-///
-/// ```
-/// use ansi_term::ANSIString;
-///
-/// let plain_string = ANSIString::from("a plain string");
-/// assert_eq!(&*plain_string, "a plain string");
-/// ```
-pub type ANSIString<'a> = ANSIGenericString<'a, str>;
-
-/// An `ANSIByteString` represents a formatted series of bytes.  Use
-/// `ANSIByteString` when styling text with an unknown encoding.
-pub type ANSIByteString<'a> = ANSIGenericString<'a, [u8]>;
-
-impl<'a, I, S: 'a + ToOwned + ?Sized> From<I> for ANSIGenericString<'a, S>
-where I: Into<Cow<'a, S>>,
-      <S as ToOwned>::Owned: fmt::Debug {
-    fn from(input: I) -> ANSIGenericString<'a, S> {
-        ANSIGenericString {
-            string: input.into(),
-            style:  Style::default(),
-        }
-    }
-}
-
-impl<'a, S: 'a + ToOwned + ?Sized> ANSIGenericString<'a, S>
-    where <S as ToOwned>::Owned: fmt::Debug {
-
-    /// Directly access the style
-    pub fn style_ref(&self) -> &Style {
-        &self.style
-    }
-
-    /// Directly access the style mutably
-    pub fn style_ref_mut(&mut self) -> &mut Style {
-        &mut self.style
-    }
-}
-
-impl<'a, S: 'a + ToOwned + ?Sized> Deref for ANSIGenericString<'a, S>
-where <S as ToOwned>::Owned: fmt::Debug {
-    type Target = S;
-
-    fn deref(&self) -> &S {
-        self.string.deref()
-    }
-}
-
-
-/// A set of `ANSIGenericString`s collected together, in order to be
-/// written with a minimum of control characters.
-#[derive(Debug, PartialEq)]
-pub struct ANSIGenericStrings<'a, S: 'a + ToOwned + ?Sized>
-    (pub &'a [ANSIGenericString<'a, S>])
-    where <S as ToOwned>::Owned: fmt::Debug, S: PartialEq;
-
-/// A set of `ANSIString`s collected together, in order to be written with a
-/// minimum of control characters.
-pub type ANSIStrings<'a> = ANSIGenericStrings<'a, str>;
-
-/// A function to construct an `ANSIStrings` instance.
-#[allow(non_snake_case)]
-pub fn ANSIStrings<'a>(arg: &'a [ANSIString<'a>]) -> ANSIStrings<'a> {
-    ANSIGenericStrings(arg)
-}
-
-/// A set of `ANSIByteString`s collected together, in order to be
-/// written with a minimum of control characters.
-pub type ANSIByteStrings<'a> = ANSIGenericStrings<'a, [u8]>;
-
-/// A function to construct an `ANSIByteStrings` instance.
-#[allow(non_snake_case)]
-pub fn ANSIByteStrings<'a>(arg: &'a [ANSIByteString<'a>]) -> ANSIByteStrings<'a> {
-    ANSIGenericStrings(arg)
-}
-
-
-// ---- paint functions ----
-
-impl Style {
-
-    /// Paints the given text with this colour, returning an ANSI string.
-    #[must_use]
-    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> ANSIGenericString<'a, S>
-    where I: Into<Cow<'a, S>>,
-          <S as ToOwned>::Owned: fmt::Debug {
-        ANSIGenericString {
-            string: input.into(),
-            style:  self,
-        }
-    }
-}
-
-
-impl Colour {
-
-    /// Paints the given text with this colour, returning an ANSI string.
-    /// This is a short-cut so you don’t have to use `Blue.normal()` just
-    /// to get blue text.
-    ///
-    /// ```
-    /// use ansi_term::Colour::Blue;
-    /// println!("{}", Blue.paint("da ba dee"));
-    /// ```
-    #[must_use]
-    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> ANSIGenericString<'a, S>
-    where I: Into<Cow<'a, S>>,
-          <S as ToOwned>::Owned: fmt::Debug {
-        ANSIGenericString {
-            string: input.into(),
-            style:  self.normal(),
-        }
-    }
-}
-
-
-// ---- writers for individual ANSI strings ----
-
-impl<'a> fmt::Display for ANSIString<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let w: &mut fmt::Write = f;
-        self.write_to_any(w)
-    }
-}
-
-impl<'a> ANSIByteString<'a> {
-    /// Write an `ANSIByteString` to an `io::Write`.  This writes the escape
-    /// sequences for the associated `Style` around the bytes.
-    pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
-        let w: &mut io::Write = w;
-        self.write_to_any(w)
-    }
-}
-
-impl<'a, S: 'a + ToOwned + ?Sized> ANSIGenericString<'a, S>
-where <S as ToOwned>::Owned: fmt::Debug, &'a S: AsRef<[u8]> {
-    fn write_to_any<W: AnyWrite<wstr=S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> {
-        write!(w, "{}", self.style.prefix())?;
-        w.write_str(self.string.as_ref())?;
-        write!(w, "{}", self.style.suffix())
-    }
-}
-
-
-// ---- writers for combined ANSI strings ----
-
-impl<'a> fmt::Display for ANSIStrings<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let f: &mut fmt::Write = f;
-        self.write_to_any(f)
-    }
-}
-
-impl<'a> ANSIByteStrings<'a> {
-    /// Write `ANSIByteStrings` to an `io::Write`.  This writes the minimal
-    /// escape sequences for the associated `Style`s around each set of
-    /// bytes.
-    pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
-        let w: &mut io::Write = w;
-        self.write_to_any(w)
-    }
-}
-
-impl<'a, S: 'a + ToOwned + ?Sized + PartialEq> ANSIGenericStrings<'a, S>
-where <S as ToOwned>::Owned: fmt::Debug, &'a S: AsRef<[u8]> {
-    fn write_to_any<W: AnyWrite<wstr=S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> {
-        use self::Difference::*;
-
-        let first = match self.0.first() {
-            None => return Ok(()),
-            Some(f) => f,
-        };
-
-        write!(w, "{}", first.style.prefix())?;
-        w.write_str(first.string.as_ref())?;
-
-        for window in self.0.windows(2) {
-            match Difference::between(&window[0].style, &window[1].style) {
-                ExtraStyles(style) => write!(w, "{}", style.prefix())?,
-                Reset              => write!(w, "{}{}", RESET, window[1].style.prefix())?,
-                NoDifference       => {/* Do nothing! */},
-            }
-
-            w.write_str(&window[1].string)?;
-        }
-
-        // Write the final reset string after all of the ANSIStrings have been
-        // written, *except* if the last one has no styles, because it would
-        // have already been written by this point.
-        if let Some(last) = self.0.last() {
-            if !last.style.is_plain() {
-                write!(w, "{}", RESET)?;
-            }
-        }
-
-        Ok(())
-    }
-}
-
-
-// ---- tests ----
-
-#[cfg(test)]
-mod tests {
-    pub use super::super::ANSIStrings;
-    pub use style::Style;
-    pub use style::Colour::*;
-
-    #[test]
-    fn no_control_codes_for_plain() {
-        let one = Style::default().paint("one");
-        let two = Style::default().paint("two");
-        let output = format!("{}", ANSIStrings( &[ one, two ] ));
-        assert_eq!(&*output, "onetwo");
-    }
-}

zeroidc/vendor/ansi_term/src/lib.rs

@@ -1,271 +0,0 @@
-//! This is a library for controlling colours and formatting, such as
-//! red bold text or blue underlined text, on ANSI terminals.
-//!
-//!
-//! ## Basic usage
-//!
-//! There are three main types in this crate that you need to be
-//! concerned with: [`ANSIString`], [`Style`], and [`Colour`].
-//!
-//! A `Style` holds stylistic information: foreground and background colours,
-//! whether the text should be bold, or blinking, or other properties. The
-//! [`Colour`] enum represents the available colours. And an [`ANSIString`] is a
-//! string paired with a [`Style`].
-//!
-//! [`Color`] is also available as an alias to `Colour`.
-//!
-//! To format a string, call the `paint` method on a `Style` or a `Colour`,
-//! passing in the string you want to format as the argument. For example,
-//! here’s how to get some red text:
-//!
-//! ```
-//! use ansi_term::Colour::Red;
-//!
-//! println!("This is in red: {}", Red.paint("a red string"));
-//! ```
-//!
-//! It’s important to note that the `paint` method does *not* actually return a
-//! string with the ANSI control characters surrounding it. Instead, it returns
-//! an [`ANSIString`] value that has a [`Display`] implementation that, when
-//! formatted, returns the characters. This allows strings to be printed with a
-//! minimum of [`String`] allocations being performed behind the scenes.
-//!
-//! If you *do* want to get at the escape codes, then you can convert the
-//! [`ANSIString`] to a string as you would any other `Display` value:
-//!
-//! ```
-//! use ansi_term::Colour::Red;
-//!
-//! let red_string = Red.paint("a red string").to_string();
-//! ```
-//!
-//!
-//! ## Bold, underline, background, and other styles
-//!
-//! For anything more complex than plain foreground colour changes, you need to
-//! construct `Style` values themselves, rather than beginning with a `Colour`.
-//! You can do this by chaining methods based on a new `Style`, created with
-//! [`Style::new()`]. Each method creates a new style that has that specific
-//! property set. For example:
-//!
-//! ```
-//! use ansi_term::Style;
-//!
-//! println!("How about some {} and {}?",
-//!          Style::new().bold().paint("bold"),
-//!          Style::new().underline().paint("underline"));
-//! ```
-//!
-//! For brevity, these methods have also been implemented for `Colour` values,
-//! so you can give your styles a foreground colour without having to begin with
-//! an empty `Style` value:
-//!
-//! ```
-//! use ansi_term::Colour::{Blue, Yellow};
-//!
-//! println!("Demonstrating {} and {}!",
-//!          Blue.bold().paint("blue bold"),
-//!          Yellow.underline().paint("yellow underline"));
-//!
-//! println!("Yellow on blue: {}", Yellow.on(Blue).paint("wow!"));
-//! ```
-//!
-//! The complete list of styles you can use are: [`bold`], [`dimmed`], [`italic`],
-//! [`underline`], [`blink`], [`reverse`], [`hidden`], [`strikethrough`], and [`on`] for
-//! background colours.
-//!
-//! In some cases, you may find it easier to change the foreground on an
-//! existing `Style` rather than starting from the appropriate `Colour`.
-//! You can do this using the [`fg`] method:
-//!
-//! ```
-//! use ansi_term::Style;
-//! use ansi_term::Colour::{Blue, Cyan, Yellow};
-//!
-//! println!("Yellow on blue: {}", Style::new().on(Blue).fg(Yellow).paint("yow!"));
-//! println!("Also yellow on blue: {}", Cyan.on(Blue).fg(Yellow).paint("zow!"));
-//! ```
-//!
-//! You can turn a `Colour` into a `Style` with the [`normal`] method.
-//! This will produce the exact same `ANSIString` as if you just used the
-//! `paint` method on the `Colour` directly, but it’s useful in certain cases:
-//! for example, you may have a method that returns `Styles`, and need to
-//! represent both the “red bold” and “red, but not bold” styles with values of
-//! the same type. The `Style` struct also has a [`Default`] implementation if you
-//! want to have a style with *nothing* set.
-//!
-//! ```
-//! use ansi_term::Style;
-//! use ansi_term::Colour::Red;
-//!
-//! Red.normal().paint("yet another red string");
-//! Style::default().paint("a completely regular string");
-//! ```
-//!
-//!
-//! ## Extended colours
-//!
-//! You can access the extended range of 256 colours by using the `Colour::Fixed`
-//! variant, which takes an argument of the colour number to use. This can be
-//! included wherever you would use a `Colour`:
-//!
-//! ```
-//! use ansi_term::Colour::Fixed;
-//!
-//! Fixed(134).paint("A sort of light purple");
-//! Fixed(221).on(Fixed(124)).paint("Mustard in the ketchup");
-//! ```
-//!
-//! The first sixteen of these values are the same as the normal and bold
-//! standard colour variants. There’s nothing stopping you from using these as
-//! `Fixed` colours instead, but there’s nothing to be gained by doing so
-//! either.
-//!
-//! You can also access full 24-bit colour by using the `Colour::RGB` variant,
-//! which takes separate `u8` arguments for red, green, and blue:
-//!
-//! ```
-//! use ansi_term::Colour::RGB;
-//!
-//! RGB(70, 130, 180).paint("Steel blue");
-//! ```
-//!
-//! ## Combining successive coloured strings
-//!
-//! The benefit of writing ANSI escape codes to the terminal is that they
-//! *stack*: you do not need to end every coloured string with a reset code if
-//! the text that follows it is of a similar style. For example, if you want to
-//! have some blue text followed by some blue bold text, it’s possible to send
-//! the ANSI code for blue, followed by the ANSI code for bold, and finishing
-//! with a reset code without having to have an extra one between the two
-//! strings.
-//!
-//! This crate can optimise the ANSI codes that get printed in situations like
-//! this, making life easier for your terminal renderer. The [`ANSIStrings`]
-//! type takes a slice of several [`ANSIString`] values, and will iterate over
-//! each of them, printing only the codes for the styles that need to be updated
-//! as part of its formatting routine.
-//!
-//! The following code snippet uses this to enclose a binary number displayed in
-//! red bold text inside some red, but not bold, brackets:
-//!
-//! ```
-//! use ansi_term::Colour::Red;
-//! use ansi_term::{ANSIString, ANSIStrings};
-//!
-//! let some_value = format!("{:b}", 42);
-//! let strings: &[ANSIString<'static>] = &[
-//!     Red.paint("["),
-//!     Red.bold().paint(some_value),
-//!     Red.paint("]"),
-//! ];
-//!
-//! println!("Value: {}", ANSIStrings(strings));
-//! ```
-//!
-//! There are several things to note here. Firstly, the [`paint`] method can take
-//! *either* an owned [`String`] or a borrowed [`&str`]. Internally, an [`ANSIString`]
-//! holds a copy-on-write ([`Cow`]) string value to deal with both owned and
-//! borrowed strings at the same time. This is used here to display a `String`,
-//! the result of the `format!` call, using the same mechanism as some
-//! statically-available `&str` slices. Secondly, that the [`ANSIStrings`] value
-//! works in the same way as its singular counterpart, with a [`Display`]
-//! implementation that only performs the formatting when required.
-//!
-//! ## Byte strings
-//!
-//! This library also supports formatting `\[u8]` byte strings; this supports
-//! applications working with text in an unknown encoding.  [`Style`] and
-//! [`Colour`] support painting `\[u8]` values, resulting in an [`ANSIByteString`].
-//! This type does not implement [`Display`], as it may not contain UTF-8, but
-//! it does provide a method [`write_to`] to write the result to any value that
-//! implements [`Write`]:
-//!
-//! ```
-//! use ansi_term::Colour::Green;
-//!
-//! Green.paint("user data".as_bytes()).write_to(&mut std::io::stdout()).unwrap();
-//! ```
-//!
-//! Similarly, the type [`ANSIByteStrings`] supports writing a list of
-//! [`ANSIByteString`] values with minimal escape sequences:
-//!
-//! ```
-//! use ansi_term::Colour::Green;
-//! use ansi_term::ANSIByteStrings;
-//!
-//! ANSIByteStrings(&[
-//!     Green.paint("user data 1\n".as_bytes()),
-//!     Green.bold().paint("user data 2\n".as_bytes()),
-//! ]).write_to(&mut std::io::stdout()).unwrap();
-//! ```
-//!
-//! [`Cow`]: https://doc.rust-lang.org/std/borrow/enum.Cow.html
-//! [`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html
-//! [`Default`]: https://doc.rust-lang.org/std/default/trait.Default.html
-//! [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
-//! [`&str`]: https://doc.rust-lang.org/std/primitive.str.html
-//! [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
-//! [`Style`]: struct.Style.html
-//! [`Style::new()`]: struct.Style.html#method.new
-//! [`Color`]: enum.Color.html
-//! [`Colour`]: enum.Colour.html
-//! [`ANSIString`]: type.ANSIString.html
-//! [`ANSIStrings`]: type.ANSIStrings.html
-//! [`ANSIByteString`]: type.ANSIByteString.html
-//! [`ANSIByteStrings`]: type.ANSIByteStrings.html
-//! [`write_to`]: type.ANSIByteString.html#method.write_to
-//! [`paint`]: type.ANSIByteString.html#method.write_to
-//! [`normal`]: enum.Colour.html#method.normal
-//!
-//! [`bold`]: struct.Style.html#method.bold
-//! [`dimmed`]: struct.Style.html#method.dimmed
-//! [`italic`]: struct.Style.html#method.italic
-//! [`underline`]: struct.Style.html#method.underline
-//! [`blink`]: struct.Style.html#method.blink
-//! [`reverse`]: struct.Style.html#method.reverse
-//! [`hidden`]: struct.Style.html#method.hidden
-//! [`strikethrough`]: struct.Style.html#method.strikethrough
-//! [`fg`]: struct.Style.html#method.fg
-//! [`on`]: struct.Style.html#method.on
-
-#![crate_name = "ansi_term"]
-#![crate_type = "rlib"]
-#![crate_type = "dylib"]
-
-#![warn(missing_copy_implementations)]
-#![warn(missing_docs)]
-#![warn(trivial_casts, trivial_numeric_casts)]
-#![warn(unused_extern_crates, unused_qualifications)]
-
-#[cfg(target_os="windows")]
-extern crate winapi;
-#[cfg(test)]
-#[macro_use]
-extern crate doc_comment;
-
-#[cfg(test)]
-doctest!("../README.md");
-
-mod ansi;
-pub use ansi::{Prefix, Infix, Suffix};
-
-mod style;
-pub use style::{Colour, Style};
-
-/// Color is a type alias for `Colour`.
-pub use Colour as Color;
-
-mod difference;
-mod display;
-pub use display::*;
-
-mod write;
-
-mod windows;
-pub use windows::*;
-
-mod util;
-pub use util::*;
-
-mod debug;

zeroidc/vendor/ansi_term/src/style.rs

@@ -1,521 +0,0 @@
-/// A style is a collection of properties that can format a string
-/// using ANSI escape codes.
-///
-/// # Examples
-///
-/// ```
-/// use ansi_term::{Style, Colour};
-///
-/// let style = Style::new().bold().on(Colour::Black);
-/// println!("{}", style.paint("Bold on black"));
-/// ```
-#[derive(PartialEq, Clone, Copy)]
-#[cfg_attr(feature = "derive_serde_style", derive(serde::Deserialize, serde::Serialize))]
-pub struct Style {
-
-    /// The style's foreground colour, if it has one.
-    pub foreground: Option<Colour>,
-
-    /// The style's background colour, if it has one.
-    pub background: Option<Colour>,
-
-    /// Whether this style is bold.
-    pub is_bold: bool,
-
-    /// Whether this style is dimmed.
-    pub is_dimmed: bool,
-
-    /// Whether this style is italic.
-    pub is_italic: bool,
-
-    /// Whether this style is underlined.
-    pub is_underline: bool,
-
-    /// Whether this style is blinking.
-    pub is_blink: bool,
-
-    /// Whether this style has reverse colours.
-    pub is_reverse: bool,
-
-    /// Whether this style is hidden.
-    pub is_hidden: bool,
-
-    /// Whether this style is struckthrough.
-    pub is_strikethrough: bool
-}
-
-impl Style {
-
-    /// Creates a new Style with no properties set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// let style = Style::new();
-    /// println!("{}", style.paint("hi"));
-    /// ```
-    pub fn new() -> Style {
-        Style::default()
-    }
-
-    /// Returns a `Style` with the bold property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// let style = Style::new().bold();
-    /// println!("{}", style.paint("hey"));
-    /// ```
-    pub fn bold(&self) -> Style {
-        Style { is_bold: true, .. *self }
-    }
-
-    /// Returns a `Style` with the dimmed property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// let style = Style::new().dimmed();
-    /// println!("{}", style.paint("sup"));
-    /// ```
-    pub fn dimmed(&self) -> Style {
-        Style { is_dimmed: true, .. *self }
-    }
-
-    /// Returns a `Style` with the italic property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// let style = Style::new().italic();
-    /// println!("{}", style.paint("greetings"));
-    /// ```
-    pub fn italic(&self) -> Style {
-        Style { is_italic: true, .. *self }
-    }
-
-    /// Returns a `Style` with the underline property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// let style = Style::new().underline();
-    /// println!("{}", style.paint("salutations"));
-    /// ```
-    pub fn underline(&self) -> Style {
-        Style { is_underline: true, .. *self }
-    }
-
-    /// Returns a `Style` with the blink property set.
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// let style = Style::new().blink();
-    /// println!("{}", style.paint("wazzup"));
-    /// ```
-    pub fn blink(&self) -> Style {
-        Style { is_blink: true, .. *self }
-    }
-
-    /// Returns a `Style` with the reverse property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// let style = Style::new().reverse();
-    /// println!("{}", style.paint("aloha"));
-    /// ```
-    pub fn reverse(&self) -> Style {
-        Style { is_reverse: true, .. *self }
-    }
-
-    /// Returns a `Style` with the hidden property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// let style = Style::new().hidden();
-    /// println!("{}", style.paint("ahoy"));
-    /// ```
-    pub fn hidden(&self) -> Style {
-        Style { is_hidden: true, .. *self }
-    }
-
-    /// Returns a `Style` with the strikethrough property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// let style = Style::new().strikethrough();
-    /// println!("{}", style.paint("yo"));
-    /// ```
-    pub fn strikethrough(&self) -> Style {
-        Style { is_strikethrough: true, .. *self }
-    }
-
-    /// Returns a `Style` with the foreground colour property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::{Style, Colour};
-    ///
-    /// let style = Style::new().fg(Colour::Yellow);
-    /// println!("{}", style.paint("hi"));
-    /// ```
-    pub fn fg(&self, foreground: Colour) -> Style {
-        Style { foreground: Some(foreground), .. *self }
-    }
-
-    /// Returns a `Style` with the background colour property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::{Style, Colour};
-    ///
-    /// let style = Style::new().on(Colour::Blue);
-    /// println!("{}", style.paint("eyyyy"));
-    /// ```
-    pub fn on(&self, background: Colour) -> Style {
-        Style { background: Some(background), .. *self }
-    }
-
-    /// Return true if this `Style` has no actual styles, and can be written
-    /// without any control characters.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    ///
-    /// assert_eq!(true,  Style::default().is_plain());
-    /// assert_eq!(false, Style::default().bold().is_plain());
-    /// ```
-    pub fn is_plain(self) -> bool {
-        self == Style::default()
-    }
-}
-
-impl Default for Style {
-
-    /// Returns a style with *no* properties set. Formatting text using this
-    /// style returns the exact same text.
-    ///
-    /// ```
-    /// use ansi_term::Style;
-    /// assert_eq!(None,  Style::default().foreground);
-    /// assert_eq!(None,  Style::default().background);
-    /// assert_eq!(false, Style::default().is_bold);
-    /// assert_eq!("txt", Style::default().paint("txt").to_string());
-    /// ```
-    fn default() -> Style {
-        Style {
-            foreground: None,
-            background: None,
-            is_bold: false,
-            is_dimmed: false,
-            is_italic: false,
-            is_underline: false,
-            is_blink: false,
-            is_reverse: false,
-            is_hidden: false,
-            is_strikethrough: false,
-        }
-    }
-}
-
-
-// ---- colours ----
-
-/// A colour is one specific type of ANSI escape code, and can refer
-/// to either the foreground or background colour.
-///
-/// These use the standard numeric sequences.
-/// See <http://invisible-island.net/xterm/ctlseqs/ctlseqs.html>
-#[derive(PartialEq, Clone, Copy, Debug)]
-#[cfg_attr(feature = "derive_serde_style", derive(serde::Deserialize, serde::Serialize))]
-pub enum Colour {
-
-    /// Colour #0 (foreground code `30`, background code `40`).
-    ///
-    /// This is not necessarily the background colour, and using it as one may
-    /// render the text hard to read on terminals with dark backgrounds.
-    Black,
-
-    /// Colour #1 (foreground code `31`, background code `41`).
-    Red,
-
-    /// Colour #2 (foreground code `32`, background code `42`).
-    Green,
-
-    /// Colour #3 (foreground code `33`, background code `43`).
-    Yellow,
-
-    /// Colour #4 (foreground code `34`, background code `44`).
-    Blue,
-
-    /// Colour #5 (foreground code `35`, background code `45`).
-    Purple,
-
-    /// Colour #6 (foreground code `36`, background code `46`).
-    Cyan,
-
-    /// Colour #7 (foreground code `37`, background code `47`).
-    ///
-    /// As above, this is not necessarily the foreground colour, and may be
-    /// hard to read on terminals with light backgrounds.
-    White,
-
-    /// A colour number from 0 to 255, for use in 256-colour terminal
-    /// environments.
-    ///
-    /// - Colours 0 to 7 are the `Black` to `White` variants respectively.
-    ///   These colours can usually be changed in the terminal emulator.
-    /// - Colours 8 to 15 are brighter versions of the eight colours above.
-    ///   These can also usually be changed in the terminal emulator, or it
-    ///   could be configured to use the original colours and show the text in
-    ///   bold instead. It varies depending on the program.
-    /// - Colours 16 to 231 contain several palettes of bright colours,
-    ///   arranged in six squares measuring six by six each.
-    /// - Colours 232 to 255 are shades of grey from black to white.
-    ///
-    /// It might make more sense to look at a [colour chart][cc].
-    ///
-    /// [cc]: https://upload.wikimedia.org/wikipedia/commons/1/15/Xterm_256color_chart.svg
-    Fixed(u8),
-
-    /// A 24-bit RGB color, as specified by ISO-8613-3.
-    RGB(u8, u8, u8),
-}
-
-
-impl Colour {
-
-    /// Returns a `Style` with the foreground colour set to this colour.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::Red.normal();
-    /// println!("{}", style.paint("hi"));
-    /// ```
-    pub fn normal(self) -> Style {
-        Style { foreground: Some(self), .. Style::default() }
-    }
-
-    /// Returns a `Style` with the foreground colour set to this colour and the
-    /// bold property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::Green.bold();
-    /// println!("{}", style.paint("hey"));
-    /// ```
-    pub fn bold(self) -> Style {
-        Style { foreground: Some(self), is_bold: true, .. Style::default() }
-    }
-
-    /// Returns a `Style` with the foreground colour set to this colour and the
-    /// dimmed property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::Yellow.dimmed();
-    /// println!("{}", style.paint("sup"));
-    /// ```
-    pub fn dimmed(self) -> Style {
-        Style { foreground: Some(self), is_dimmed: true, .. Style::default() }
-    }
-
-    /// Returns a `Style` with the foreground colour set to this colour and the
-    /// italic property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::Blue.italic();
-    /// println!("{}", style.paint("greetings"));
-    /// ```
-    pub fn italic(self) -> Style {
-        Style { foreground: Some(self), is_italic: true, .. Style::default() }
-    }
-
-    /// Returns a `Style` with the foreground colour set to this colour and the
-    /// underline property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::Purple.underline();
-    /// println!("{}", style.paint("salutations"));
-    /// ```
-    pub fn underline(self) -> Style {
-        Style { foreground: Some(self), is_underline: true, .. Style::default() }
-    }
-
-    /// Returns a `Style` with the foreground colour set to this colour and the
-    /// blink property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::Cyan.blink();
-    /// println!("{}", style.paint("wazzup"));
-    /// ```
-    pub fn blink(self) -> Style {
-        Style { foreground: Some(self), is_blink: true, .. Style::default() }
-    }
-
-    /// Returns a `Style` with the foreground colour set to this colour and the
-    /// reverse property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::Black.reverse();
-    /// println!("{}", style.paint("aloha"));
-    /// ```
-    pub fn reverse(self) -> Style {
-        Style { foreground: Some(self), is_reverse: true, .. Style::default() }
-    }
-
-    /// Returns a `Style` with the foreground colour set to this colour and the
-    /// hidden property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::White.hidden();
-    /// println!("{}", style.paint("ahoy"));
-    /// ```
-    pub fn hidden(self) -> Style {
-        Style { foreground: Some(self), is_hidden: true, .. Style::default() }
-    }
-
-    /// Returns a `Style` with the foreground colour set to this colour and the
-    /// strikethrough property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::Fixed(244).strikethrough();
-    /// println!("{}", style.paint("yo"));
-    /// ```
-    pub fn strikethrough(self) -> Style {
-        Style { foreground: Some(self), is_strikethrough: true, .. Style::default() }
-    }
-
-    /// Returns a `Style` with the foreground colour set to this colour and the
-    /// background colour property set to the given colour.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ansi_term::Colour;
-    ///
-    /// let style = Colour::RGB(31, 31, 31).on(Colour::White);
-    /// println!("{}", style.paint("eyyyy"));
-    /// ```
-    pub fn on(self, background: Colour) -> Style {
-        Style { foreground: Some(self), background: Some(background), .. Style::default() }
-    }
-}
-
-impl From<Colour> for Style {
-
-    /// You can turn a `Colour` into a `Style` with the foreground colour set
-    /// with the `From` trait.
-    ///
-    /// ```
-    /// use ansi_term::{Style, Colour};
-    /// let green_foreground = Style::default().fg(Colour::Green);
-    /// assert_eq!(green_foreground, Colour::Green.normal());
-    /// assert_eq!(green_foreground, Colour::Green.into());
-    /// assert_eq!(green_foreground, Style::from(Colour::Green));
-    /// ```
-    fn from(colour: Colour) -> Style {
-        colour.normal()
-    }
-}
-
-#[cfg(test)]
-#[cfg(feature = "derive_serde_style")]
-mod serde_json_tests {
-    use super::{Style, Colour};
-
-    #[test]
-    fn colour_serialization() {
-
-        let colours = &[
-            Colour::Red,
-            Colour::Blue,
-            Colour::RGB(123, 123, 123),
-            Colour::Fixed(255),
-        ];
-
-        assert_eq!(serde_json::to_string(&colours).unwrap(), String::from("[\"Red\",\"Blue\",{\"RGB\":[123,123,123]},{\"Fixed\":255}]"));
-    }
-
-    #[test]
-    fn colour_deserialization() {
-        let colours = &[
-            Colour::Red,
-            Colour::Blue,
-            Colour::RGB(123, 123, 123),
-            Colour::Fixed(255),
-        ];
-
-        for colour in colours.into_iter() {
-            let serialized = serde_json::to_string(&colour).unwrap();
-            let deserialized: Colour = serde_json::from_str(&serialized).unwrap();
-
-            assert_eq!(colour, &deserialized);
-        }
-    }
-
-    #[test]
-    fn style_serialization() {
-        let style = Style::default();
-
-        assert_eq!(serde_json::to_string(&style).unwrap(), "{\"foreground\":null,\"background\":null,\"is_bold\":false,\"is_dimmed\":false,\"is_italic\":false,\"is_underline\":false,\"is_blink\":false,\"is_reverse\":false,\"is_hidden\":false,\"is_strikethrough\":false}".to_string());
-    }
-}

zeroidc/vendor/ansi_term/src/util.rs

@@ -1,81 +0,0 @@
-use display::*;
-use std::ops::Deref;
-
-/// Return a substring of the given ANSIStrings sequence, while keeping the formatting.
-pub fn sub_string<'a>(start: usize, len: usize, strs: &ANSIStrings<'a>) -> Vec<ANSIString<'static>> {
-    let mut vec = Vec::new();
-    let mut pos = start;
-    let mut len_rem = len;
-
-    for i in strs.0.iter() {
-        let fragment = i.deref();
-        let frag_len = fragment.len();
-        if pos >= frag_len {
-            pos -= frag_len;
-            continue;
-        }
-        if len_rem <= 0 {
-            break;
-        }
-
-        let end = pos + len_rem;
-        let pos_end = if end >= frag_len { frag_len } else { end };
-
-        vec.push(i.style_ref().paint(String::from(&fragment[pos..pos_end])));
-
-        if end <= frag_len {
-            break;
-        }
-
-        len_rem -= pos_end - pos;
-        pos = 0;
-    }
-
-    vec
-}
-
-/// Return a concatenated copy of `strs` without the formatting, as an allocated `String`.
-pub fn unstyle(strs: &ANSIStrings) -> String {
-    let mut s = String::new();
-
-    for i in strs.0.iter() {
-        s += &i.deref();
-    }
-
-    s
-}
-
-/// Return the unstyled length of ANSIStrings. This is equaivalent to `unstyle(strs).len()`.
-pub fn unstyled_len(strs: &ANSIStrings) -> usize {
-    let mut l = 0;
-    for i in strs.0.iter() {
-        l += i.deref().len();
-    }
-    l
-}
-
-#[cfg(test)]
-mod test {
-    use Colour::*;
-    use display::*;
-    use super::*;
-
-    #[test]
-    fn test() {
-        let l = [
-            Black.paint("first"),
-            Red.paint("-second"),
-            White.paint("-third"),
-        ];
-        let a = ANSIStrings(&l);
-        assert_eq!(unstyle(&a), "first-second-third");
-        assert_eq!(unstyled_len(&a), 18);
-
-        let l2 = [
-            Black.paint("st"),
-            Red.paint("-second"),
-            White.paint("-t"),
-        ];
-        assert_eq!(sub_string(3, 11, &a).as_slice(), &l2);
-    }
-}

zeroidc/vendor/ansi_term/src/windows.rs

@@ -1,61 +0,0 @@
-/// Enables ANSI code support on Windows 10.
-///
-/// This uses Windows API calls to alter the properties of the console that
-/// the program is running in.
-///
-/// https://msdn.microsoft.com/en-us/library/windows/desktop/mt638032(v=vs.85).aspx
-///
-/// Returns a `Result` with the Windows error code if unsuccessful.
-#[cfg(windows)]
-pub fn enable_ansi_support() -> Result<(), u32> {
-    // ref: https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#EXAMPLE_OF_ENABLING_VIRTUAL_TERMINAL_PROCESSING @@ https://archive.is/L7wRJ#76%
-
-    use std::ffi::OsStr;
-    use std::iter::once;
-    use std::os::windows::ffi::OsStrExt;
-    use std::ptr::null_mut;
-    use winapi::um::consoleapi::{GetConsoleMode, SetConsoleMode};
-    use winapi::um::errhandlingapi::GetLastError;
-    use winapi::um::fileapi::{CreateFileW, OPEN_EXISTING};
-    use winapi::um::handleapi::INVALID_HANDLE_VALUE;
-    use winapi::um::winnt::{FILE_SHARE_WRITE, GENERIC_READ, GENERIC_WRITE};
-
-    const ENABLE_VIRTUAL_TERMINAL_PROCESSING: u32 = 0x0004;
-
-    unsafe {
-        // ref: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
-        // Using `CreateFileW("CONOUT$", ...)` to retrieve the console handle works correctly even if STDOUT and/or STDERR are redirected
-        let console_out_name: Vec<u16> = OsStr::new("CONOUT$").encode_wide().chain(once(0)).collect();
-        let console_handle = CreateFileW(
-            console_out_name.as_ptr(),
-            GENERIC_READ | GENERIC_WRITE,
-            FILE_SHARE_WRITE,
-            null_mut(),
-            OPEN_EXISTING,
-            0,
-            null_mut(),
-        );
-        if console_handle == INVALID_HANDLE_VALUE
-        {
-            return Err(GetLastError());
-        }
-
-        // ref: https://docs.microsoft.com/en-us/windows/console/getconsolemode
-        let mut console_mode: u32 = 0;
-        if 0 == GetConsoleMode(console_handle, &mut console_mode)
-        {
-            return Err(GetLastError());
-        }
-
-        // VT processing not already enabled?
-        if console_mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING == 0 {
-            // https://docs.microsoft.com/en-us/windows/console/setconsolemode
-            if 0 == SetConsoleMode(console_handle, console_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
-            {
-                return Err(GetLastError());
-            }
-        }
-    }
-
-    return Ok(());
-}

zeroidc/vendor/ansi_term/src/write.rs

@@ -1,40 +0,0 @@
-use std::fmt;
-use std::io;
-
-
-pub trait AnyWrite {
-    type wstr: ?Sized;
-    type Error;
-
-    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error>;
-
-    fn write_str(&mut self, s: &Self::wstr) -> Result<(), Self::Error>;
-}
-
-
-impl<'a> AnyWrite for fmt::Write + 'a {
-    type wstr = str;
-    type Error = fmt::Error;
-
-    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error> {
-        fmt::Write::write_fmt(self, fmt)
-    }
-
-    fn write_str(&mut self, s: &Self::wstr) -> Result<(), Self::Error> {
-        fmt::Write::write_str(self, s)
-    }
-}
-
-
-impl<'a> AnyWrite for io::Write + 'a {
-    type wstr = [u8];
-    type Error = io::Error;
-
-    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error> {
-        io::Write::write_fmt(self, fmt)
-    }
-
-    fn write_str(&mut self, s: &Self::wstr) -> Result<(), Self::Error> {
-        io::Write::write_all(self, s)
-    }
-}

zeroidc/vendor/atty/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"CHANGELOG.md":"70db121262d72acc472ad1a90b78c42de570820e65b566c6b9339b62e636d572","Cargo.lock":"6868f02a96413bcba37a06f01c6bf87e6331dea9461681a47a561cec6acd2546","Cargo.toml":"3af88a07af6a4adb84373fc3cd4920884b0b12b338cdb55ef598fd512ee1a790","LICENSE":"99fa95ba4e4cdaf71c27d73260ea069fc4515b3d02fde3020c5b562280006cbc","README.md":"e559a69c0b2bd20bffcede64fd548df6c671b0d1504613c5e3e5d884d759caea","examples/atty.rs":"1551387a71474d9ac1b5153231f884e9e05213badcfaa3494ad2cb7ea958374a","rustfmt.toml":"8e6ea1bcb79c505490034020c98e9b472f4ac4113f245bae90f5e1217b1ec65a","src/lib.rs":"d5abf6a54e8c496c486572bdc91eef10480f6ad126c4287f039df5feff7a9bbb"},"package":"d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"}

zeroidc/vendor/atty/CHANGELOG.md

@@ -1,73 +0,0 @@
-# 0.2.14
-
-* add support for [RustyHermit](https://github.com/hermitcore/libhermit-rs), a Rust-based unikernel [#41](https://github.com/softprops/atty/pull/41)
-
-# 0.2.13
-
-* support older versions of rust that do now support 2018 edition
-
-# 0.2.12
-
-* Redox is now in the unix family so redox cfg is no longer needed [#35](https://github.com/softprops/atty/pull/35)
-
-# 0.2.11
-
-* fix msys detection with `[email protected]` [#28](https://github.com/softprops/atty/pull/28)
-
-# 0.2.10
-
-* fix wasm regression [#27](https://github.com/softprops/atty/pull/27)
-
-# 0.2.9
-
-* Fix fix pty detection [#25](https://github.com/softprops/atty/pull/25)
-
-# 0.2.8
-
-* Fix an inverted condition on MinGW [#22](https://github.com/softprops/atty/pull/22)
-
-# 0.2.7
-
-* Change `||` to `&&` for whether MSYS is a tty [#24](https://github.com/softprops/atty/pull/24/)
-
-# 0.2.6
-
-* updated winapi dependency to [0.3](https://retep998.github.io/blog/winapi-0.3/) [#18](https://github.com/softprops/atty/pull/18)
-
-# 0.2.5
-
-* added support for Wasm compile targets [#17](https://github.com/softprops/atty/pull/17)
-
-# 0.2.4
-
-* added support for Wasm compile targets [#17](https://github.com/softprops/atty/pull/17)
-
-# 0.2.3
-
-* added support for Redox OS [#14](https://github.com/softprops/atty/pull/14)
-
-# 0.2.2
-
-* use target specific dependencies [#11](https://github.com/softprops/atty/pull/11)
-* Add tty detection for MSYS terminals [#12](https://github.com/softprops/atty/pull/12)
-
-# 0.2.1
-
-* fix windows bug
-
-# 0.2.0
-
-* support for various stream types
-
-# 0.1.2
-
-* windows support (with automated testing)
-* automated code coverage
-
-# 0.1.1
-
-* bumped libc dep from `0.1` to `0.2`
-
-# 0.1.0
-
-* initial release

zeroidc/vendor/atty/Cargo.lock

@@ -1,49 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "atty"
-version = "0.2.14"
-dependencies = [
- "hermit-abi 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.66 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.66 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.66"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "winapi"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[metadata]
-"checksum hermit-abi 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "eff2656d88f158ce120947499e971d743c05dbcbed62e5bd2f38f1698bbc3772"
-"checksum libc 0.2.66 (registry+https://github.com/rust-lang/crates.io-index)" = "d515b1f41455adea1313a4a2ac8a8a477634fbae63cc6100e3aebb207ce61558"
-"checksum winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "04e3bd221fcbe8a271359c04f21a76db7d0c6028862d1bb5512d85e1e2eb5bb3"
-"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

zeroidc/vendor/atty/Cargo.toml

@@ -1,34 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "atty"
-version = "0.2.14"
-authors = ["softprops <[email protected]>"]
-exclude = ["/.travis.yml", "/appveyor.yml"]
-description = "A simple interface for querying atty"
-homepage = "https://github.com/softprops/atty"
-documentation = "http://softprops.github.io/atty"
-readme = "README.md"
-keywords = ["terminal", "tty", "isatty"]
-license = "MIT"
-repository = "https://github.com/softprops/atty"
-[target."cfg(target_os = \"hermit\")".dependencies.hermit-abi]
-version = "0.1.6"
-[target."cfg(unix)".dependencies.libc]
-version = "0.2"
-default-features = false
-[target."cfg(windows)".dependencies.winapi]
-version = "0.3"
-features = ["consoleapi", "processenv", "minwinbase", "minwindef", "winbase"]
-[badges.travis-ci]
-repository = "softprops/atty"

zeroidc/vendor/atty/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2015-2019 Doug Tangren
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

zeroidc/vendor/atty/README.md

@@ -1,74 +0,0 @@
-# atty
-
-[![Build Status](https://travis-ci.org/softprops/atty.svg?branch=master)](https://travis-ci.org/softprops/atty) [![Build status](https://ci.appveyor.com/api/projects/status/geggrsnsjsuse8cv?svg=true)](https://ci.appveyor.com/project/softprops/atty) [![Coverage Status](https://coveralls.io/repos/softprops/atty/badge.svg?branch=master&service=github)](https://coveralls.io/github/softprops/atty?branch=master) [![crates.io](https://img.shields.io/crates/v/atty.svg)](https://crates.io/crates/atty) [![Released API docs](https://docs.rs/atty/badge.svg)](http://docs.rs/atty) [![Master API docs](https://img.shields.io/badge/docs-master-green.svg)](https://softprops.github.io/atty)
-
-> are you or are you not a tty?
-
-
-## install
-
-Add the following to your `Cargo.toml`
-
-```toml
-[dependencies]
-atty = "0.2"
-```
-
-## usage
-
-```rust
-use atty::Stream;
-
-fn main() {
-  if atty::is(Stream::Stdout) {
-    println!("I'm a terminal");
-  } else {
-    println!("I'm not");
-  }
-}
-```
-
-## testing
-
-This library has been unit tested on both unix and windows platforms (via appveyor).
-
-
-A simple example program is provided in this repo to test various tty's. By default.
-
-It prints
-
-```bash
-$ cargo run --example atty
-stdout? true
-stderr? true
-stdin? true
-```
-
-To test std in, pipe some text to the program
-
-```bash
-$ echo "test" | cargo run --example atty
-stdout? true
-stderr? true
-stdin? false
-```
-
-To test std out, pipe the program to something
-
-```bash
-$ cargo run --example atty | grep std
-stdout? false
-stderr? true
-stdin? true
-```
-
-To test std err, pipe the program to something redirecting std err
-
-```bash
-$ cargo run --example atty 2>&1 | grep std
-stdout? false
-stderr? false
-stdin? true
-```
-
-Doug Tangren (softprops) 2015-2019

zeroidc/vendor/atty/examples/atty.rs

@@ -1,9 +0,0 @@
-extern crate atty;
-
-use atty::{is, Stream};
-
-fn main() {
-    println!("stdout? {}", is(Stream::Stdout));
-    println!("stderr? {}", is(Stream::Stderr));
-    println!("stdin? {}", is(Stream::Stdin));
-}

zeroidc/vendor/atty/rustfmt.toml

@@ -1,4 +0,0 @@
-# https://github.com/rust-lang/rustfmt/blob/master/Configurations.md#fn_args_layout
-fn_args_layout = "Vertical"
-# https://github.com/rust-lang/rustfmt/blob/master/Configurations.md#merge_imports
-merge_imports = true

zeroidc/vendor/atty/src/lib.rs

@@ -1,210 +0,0 @@
-//! atty is a simple utility that answers one question
-//! > is this a tty?
-//!
-//! usage is just as simple
-//!
-//! ```
-//! if atty::is(atty::Stream::Stdout) {
-//!   println!("i'm a tty")
-//! }
-//! ```
-//!
-//! ```
-//! if atty::isnt(atty::Stream::Stdout) {
-//!   println!("i'm not a tty")
-//! }
-//! ```
-
-#![cfg_attr(unix, no_std)]
-
-#[cfg(unix)]
-extern crate libc;
-#[cfg(windows)]
-extern crate winapi;
-
-#[cfg(windows)]
-use winapi::shared::minwindef::DWORD;
-#[cfg(windows)]
-use winapi::shared::ntdef::WCHAR;
-
-/// possible stream sources
-#[derive(Clone, Copy, Debug)]
-pub enum Stream {
-    Stdout,
-    Stderr,
-    Stdin,
-}
-
-/// returns true if this is a tty
-#[cfg(all(unix, not(target_arch = "wasm32")))]
-pub fn is(stream: Stream) -> bool {
-    extern crate libc;
-
-    let fd = match stream {
-        Stream::Stdout => libc::STDOUT_FILENO,
-        Stream::Stderr => libc::STDERR_FILENO,
-        Stream::Stdin => libc::STDIN_FILENO,
-    };
-    unsafe { libc::isatty(fd) != 0 }
-}
-
-/// returns true if this is a tty
-#[cfg(target_os = "hermit")]
-pub fn is(stream: Stream) -> bool {
-    extern crate hermit_abi;
-
-    let fd = match stream {
-        Stream::Stdout => hermit_abi::STDOUT_FILENO,
-        Stream::Stderr => hermit_abi::STDERR_FILENO,
-        Stream::Stdin => hermit_abi::STDIN_FILENO,
-    };
-    hermit_abi::isatty(fd)
-}
-
-/// returns true if this is a tty
-#[cfg(windows)]
-pub fn is(stream: Stream) -> bool {
-    use winapi::um::winbase::{
-        STD_ERROR_HANDLE as STD_ERROR, STD_INPUT_HANDLE as STD_INPUT,
-        STD_OUTPUT_HANDLE as STD_OUTPUT,
-    };
-
-    let (fd, others) = match stream {
-        Stream::Stdin => (STD_INPUT, [STD_ERROR, STD_OUTPUT]),
-        Stream::Stderr => (STD_ERROR, [STD_INPUT, STD_OUTPUT]),
-        Stream::Stdout => (STD_OUTPUT, [STD_INPUT, STD_ERROR]),
-    };
-    if unsafe { console_on_any(&[fd]) } {
-        // False positives aren't possible. If we got a console then
-        // we definitely have a tty on stdin.
-        return true;
-    }
-
-    // At this point, we *could* have a false negative. We can determine that
-    // this is true negative if we can detect the presence of a console on
-    // any of the other streams. If another stream has a console, then we know
-    // we're in a Windows console and can therefore trust the negative.
-    if unsafe { console_on_any(&others) } {
-        return false;
-    }
-
-    // Otherwise, we fall back to a very strange msys hack to see if we can
-    // sneakily detect the presence of a tty.
-    unsafe { msys_tty_on(fd) }
-}
-
-/// returns true if this is _not_ a tty
-pub fn isnt(stream: Stream) -> bool {
-    !is(stream)
-}
-
-/// Returns true if any of the given fds are on a console.
-#[cfg(windows)]
-unsafe fn console_on_any(fds: &[DWORD]) -> bool {
-    use winapi::um::{consoleapi::GetConsoleMode, processenv::GetStdHandle};
-
-    for &fd in fds {
-        let mut out = 0;
-        let handle = GetStdHandle(fd);
-        if GetConsoleMode(handle, &mut out) != 0 {
-            return true;
-        }
-    }
-    false
-}
-
-/// Returns true if there is an MSYS tty on the given handle.
-#[cfg(windows)]
-unsafe fn msys_tty_on(fd: DWORD) -> bool {
-    use std::{mem, slice};
-
-    use winapi::{
-        ctypes::c_void,
-        shared::minwindef::MAX_PATH,
-        um::{
-            fileapi::FILE_NAME_INFO, minwinbase::FileNameInfo, processenv::GetStdHandle,
-            winbase::GetFileInformationByHandleEx,
-        },
-    };
-
-    let size = mem::size_of::<FILE_NAME_INFO>();
-    let mut name_info_bytes = vec![0u8; size + MAX_PATH * mem::size_of::<WCHAR>()];
-    let res = GetFileInformationByHandleEx(
-        GetStdHandle(fd),
-        FileNameInfo,
-        &mut *name_info_bytes as *mut _ as *mut c_void,
-        name_info_bytes.len() as u32,
-    );
-    if res == 0 {
-        return false;
-    }
-    let name_info: &FILE_NAME_INFO = &*(name_info_bytes.as_ptr() as *const FILE_NAME_INFO);
-    let s = slice::from_raw_parts(
-        name_info.FileName.as_ptr(),
-        name_info.FileNameLength as usize / 2,
-    );
-    let name = String::from_utf16_lossy(s);
-    // This checks whether 'pty' exists in the file name, which indicates that
-    // a pseudo-terminal is attached. To mitigate against false positives
-    // (e.g., an actual file name that contains 'pty'), we also require that
-    // either the strings 'msys-' or 'cygwin-' are in the file name as well.)
-    let is_msys = name.contains("msys-") || name.contains("cygwin-");
-    let is_pty = name.contains("-pty");
-    is_msys && is_pty
-}
-
-/// returns true if this is a tty
-#[cfg(target_arch = "wasm32")]
-pub fn is(_stream: Stream) -> bool {
-    false
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{is, Stream};
-
-    #[test]
-    #[cfg(windows)]
-    fn is_err() {
-        // appveyor pipes its output
-        assert!(!is(Stream::Stderr))
-    }
-
-    #[test]
-    #[cfg(windows)]
-    fn is_out() {
-        // appveyor pipes its output
-        assert!(!is(Stream::Stdout))
-    }
-
-    #[test]
-    #[cfg(windows)]
-    fn is_in() {
-        assert!(is(Stream::Stdin))
-    }
-
-    #[test]
-    #[cfg(unix)]
-    fn is_err() {
-        assert!(is(Stream::Stderr))
-    }
-
-    #[test]
-    #[cfg(unix)]
-    fn is_out() {
-        assert!(is(Stream::Stdout))
-    }
-
-    #[test]
-    #[cfg(target_os = "macos")]
-    fn is_in() {
-        // macos on travis seems to pipe its input
-        assert!(is(Stream::Stdin))
-    }
-
-    #[test]
-    #[cfg(all(not(target_os = "macos"), unix))]
-    fn is_in() {
-        assert!(is(Stream::Stdin))
-    }
-}

zeroidc/vendor/autocfg/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.lock":"3d91565ed13de572a9ebde408a0c98e33f931d6ab52f212b0830a60b4ab26b77","Cargo.toml":"39f627122dceaad42146634719fde802fca3baa1b3908753af723074ae2a6d69","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"27995d58ad5c1145c1a8cd86244ce844886958a35eb2b78c6b772748669999ac","README.md":"4c8f9b5016f2a0c3dbeca5bc41241f57db5568f803e58c1fa480ae2b3638d0a9","examples/integers.rs":"589ff4271566dfa322becddf3e2c7b592e6e0bc97b02892ce75619b7e452e930","examples/paths.rs":"1b30e466b824ce8df7ad0a55334424131d9d2573d6cf9f7d5d50c09c8901d526","examples/traits.rs":"cbee6a3e1f7db60b02ae25b714926517144a77cb492021f492774cf0e1865a9e","examples/versions.rs":"38535e6d9f5bfae0de474a3db79a40e8f5da8ba9334c5ff4c363de9bc99d4d12","src/error.rs":"12de7dafea4a35d1dc2f0fa79bfa038386bbbea72bf083979f4ddf227999eeda","src/lib.rs":"6fa01458e8f9258d84f83ead24fdb0cdf9aec10838b0262f1dfbdf79c530c537","src/tests.rs":"f0e6dc1ad9223c0336c02e215ea3940acb2af6c3bc8fd791e16cd4e786e6a608","src/version.rs":"175727d5f02f2fe2271ddc9b041db2a5b9c6fe0f95afd17c73a4d982612764a3","tests/rustflags.rs":"5c8169b88216055019db61b5d7baf4abdf675e3b14b54f5037bb1e3acd0a5d3f"},"package":"d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"}

zeroidc/vendor/autocfg/Cargo.lock

@@ -1,7 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "autocfg"
-version = "1.1.0"

zeroidc/vendor/autocfg/Cargo.toml

@@ -1,24 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-name = "autocfg"
-version = "1.1.0"
-authors = ["Josh Stone <[email protected]>"]
-exclude = ["/.github/**", "/bors.toml"]
-description = "Automatic cfg for Rust compiler features"
-readme = "README.md"
-keywords = ["rustc", "build", "autoconf"]
-categories = ["development-tools::build-utils"]
-license = "Apache-2.0 OR MIT"
-repository = "https://github.com/cuviper/autocfg"
-
-[dependencies]

zeroidc/vendor/autocfg/LICENSE-APACHE

@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

zeroidc/vendor/autocfg/LICENSE-MIT

@@ -1,25 +0,0 @@
-Copyright (c) 2018 Josh Stone
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

zeroidc/vendor/autocfg/README.md

@@ -1,95 +0,0 @@
-autocfg
-=======
-
-[![autocfg crate](https://img.shields.io/crates/v/autocfg.svg)](https://crates.io/crates/autocfg)
-[![autocfg documentation](https://docs.rs/autocfg/badge.svg)](https://docs.rs/autocfg)
-![minimum rustc 1.0](https://img.shields.io/badge/rustc-1.0+-red.svg)
-![build status](https://github.com/cuviper/autocfg/workflows/master/badge.svg)
-
-A Rust library for build scripts to automatically configure code based on
-compiler support.  Code snippets are dynamically tested to see if the `rustc`
-will accept them, rather than hard-coding specific version support.
-
-
-## Usage
-
-Add this to your `Cargo.toml`:
-
-```toml
-[build-dependencies]
-autocfg = "1"
-```
-
-Then use it in your `build.rs` script to detect compiler features.  For
-example, to test for 128-bit integer support, it might look like:
-
-```rust
-extern crate autocfg;
-
-fn main() {
-    let ac = autocfg::new();
-    ac.emit_has_type("i128");
-
-    // (optional) We don't need to rerun for anything external.
-    autocfg::rerun_path("build.rs");
-}
-```
-
-If the type test succeeds, this will write a `cargo:rustc-cfg=has_i128` line
-for Cargo, which translates to Rust arguments `--cfg has_i128`.  Then in the
-rest of your Rust code, you can add `#[cfg(has_i128)]` conditions on code that
-should only be used when the compiler supports it.
-
-
-## Release Notes
-
-- 1.1.0 (2022-02-07)
-  - Use `CARGO_ENCODED_RUSTFLAGS` when it is set.
-
-- 1.0.1 (2020-08-20)
-  - Apply `RUSTFLAGS` for more `--target` scenarios, by @adamreichold.
-
-- 1.0.0 (2020-01-08)
-  - 🎉 Release 1.0! 🎉 (no breaking changes)
-  - Add `probe_expression` and `emit_expression_cfg` to test arbitrary expressions.
-  - Add `probe_constant` and `emit_constant_cfg` to test arbitrary constant expressions.
-
-- 0.1.7 (2019-10-20)
-  - Apply `RUSTFLAGS` when probing `$TARGET != $HOST`, mainly for sysroot, by @roblabla.
-
-- 0.1.6 (2019-08-19)
-  - Add `probe`/`emit_sysroot_crate`, by @leo60228.
-
-- 0.1.5 (2019-07-16)
-  - Mask some warnings from newer rustc.
-
-- 0.1.4 (2019-05-22)
-  - Relax `std`/`no_std` probing to a warning instead of an error.
-  - Improve `rustc` bootstrap compatibility.
-
-- 0.1.3 (2019-05-21)
-  - Auto-detects if `#![no_std]` is needed for the `$TARGET`.
-
-- 0.1.2 (2019-01-16)
-  - Add `rerun_env(ENV)` to print `cargo:rerun-if-env-changed=ENV`.
-  - Add `rerun_path(PATH)` to print `cargo:rerun-if-changed=PATH`.
-
-
-## Minimum Rust version policy
-
-This crate's minimum supported `rustc` version is `1.0.0`.  Compatibility is
-its entire reason for existence, so this crate will be extremely conservative
-about raising this requirement.  If this is ever deemed necessary, it will be
-treated as a major breaking change for semver purposes.
-
-
-## License
-
-This project is licensed under either of
-
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
-
-at your option.

zeroidc/vendor/autocfg/examples/integers.rs

@@ -1,9 +0,0 @@
-extern crate autocfg;
-
-fn main() {
-    // Normally, cargo will set `OUT_DIR` for build scripts.
-    let ac = autocfg::AutoCfg::with_dir("target").unwrap();
-    for i in 3..8 {
-        ac.emit_has_type(&format!("i{}", 1 << i));
-    }
-}

zeroidc/vendor/autocfg/examples/paths.rs

@@ -1,22 +0,0 @@
-extern crate autocfg;
-
-fn main() {
-    // Normally, cargo will set `OUT_DIR` for build scripts.
-    let ac = autocfg::AutoCfg::with_dir("target").unwrap();
-
-    // since ancient times...
-    ac.emit_has_path("std::vec::Vec");
-    ac.emit_path_cfg("std::vec::Vec", "has_vec");
-
-    // rustc 1.10.0
-    ac.emit_has_path("std::panic::PanicInfo");
-    ac.emit_path_cfg("std::panic::PanicInfo", "has_panic_info");
-
-    // rustc 1.20.0
-    ac.emit_has_path("std::mem::ManuallyDrop");
-    ac.emit_path_cfg("std::mem::ManuallyDrop", "has_manually_drop");
-
-    // rustc 1.25.0
-    ac.emit_has_path("std::ptr::NonNull");
-    ac.emit_path_cfg("std::ptr::NonNull", "has_non_null");
-}

zeroidc/vendor/autocfg/examples/traits.rs

@@ -1,26 +0,0 @@
-extern crate autocfg;
-
-fn main() {
-    // Normally, cargo will set `OUT_DIR` for build scripts.
-    let ac = autocfg::AutoCfg::with_dir("target").unwrap();
-
-    // since ancient times...
-    ac.emit_has_trait("std::ops::Add");
-    ac.emit_trait_cfg("std::ops::Add", "has_ops");
-
-    // trait parameters have to be provided
-    ac.emit_has_trait("std::borrow::Borrow<str>");
-    ac.emit_trait_cfg("std::borrow::Borrow<str>", "has_borrow");
-
-    // rustc 1.8.0
-    ac.emit_has_trait("std::ops::AddAssign");
-    ac.emit_trait_cfg("std::ops::AddAssign", "has_assign_ops");
-
-    // rustc 1.12.0
-    ac.emit_has_trait("std::iter::Sum");
-    ac.emit_trait_cfg("std::iter::Sum", "has_sum");
-
-    // rustc 1.28.0
-    ac.emit_has_trait("std::alloc::GlobalAlloc");
-    ac.emit_trait_cfg("std::alloc::GlobalAlloc", "has_global_alloc");
-}

zeroidc/vendor/autocfg/examples/versions.rs

@@ -1,9 +0,0 @@
-extern crate autocfg;
-
-fn main() {
-    // Normally, cargo will set `OUT_DIR` for build scripts.
-    let ac = autocfg::AutoCfg::with_dir("target").unwrap();
-    for i in 0..100 {
-        ac.emit_rustc_version(1, i);
-    }
-}

zeroidc/vendor/autocfg/src/error.rs

@@ -1,69 +0,0 @@
-use std::error;
-use std::fmt;
-use std::io;
-use std::num;
-use std::str;
-
-/// A common error type for the `autocfg` crate.
-#[derive(Debug)]
-pub struct Error {
-    kind: ErrorKind,
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        "AutoCfg error"
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match self.kind {
-            ErrorKind::Io(ref e) => Some(e),
-            ErrorKind::Num(ref e) => Some(e),
-            ErrorKind::Utf8(ref e) => Some(e),
-            ErrorKind::Other(_) => None,
-        }
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        match self.kind {
-            ErrorKind::Io(ref e) => e.fmt(f),
-            ErrorKind::Num(ref e) => e.fmt(f),
-            ErrorKind::Utf8(ref e) => e.fmt(f),
-            ErrorKind::Other(s) => s.fmt(f),
-        }
-    }
-}
-
-#[derive(Debug)]
-enum ErrorKind {
-    Io(io::Error),
-    Num(num::ParseIntError),
-    Utf8(str::Utf8Error),
-    Other(&'static str),
-}
-
-pub fn from_io(e: io::Error) -> Error {
-    Error {
-        kind: ErrorKind::Io(e),
-    }
-}
-
-pub fn from_num(e: num::ParseIntError) -> Error {
-    Error {
-        kind: ErrorKind::Num(e),
-    }
-}
-
-pub fn from_utf8(e: str::Utf8Error) -> Error {
-    Error {
-        kind: ErrorKind::Utf8(e),
-    }
-}
-
-pub fn from_str(s: &'static str) -> Error {
-    Error {
-        kind: ErrorKind::Other(s),
-    }
-}

zeroidc/vendor/autocfg/src/lib.rs

@@ -1,453 +0,0 @@
-//! A Rust library for build scripts to automatically configure code based on
-//! compiler support.  Code snippets are dynamically tested to see if the `rustc`
-//! will accept them, rather than hard-coding specific version support.
-//!
-//!
-//! ## Usage
-//!
-//! Add this to your `Cargo.toml`:
-//!
-//! ```toml
-//! [build-dependencies]
-//! autocfg = "1"
-//! ```
-//!
-//! Then use it in your `build.rs` script to detect compiler features.  For
-//! example, to test for 128-bit integer support, it might look like:
-//!
-//! ```rust
-//! extern crate autocfg;
-//!
-//! fn main() {
-//! #   // Normally, cargo will set `OUT_DIR` for build scripts.
-//! #   std::env::set_var("OUT_DIR", "target");
-//!     let ac = autocfg::new();
-//!     ac.emit_has_type("i128");
-//!
-//!     // (optional) We don't need to rerun for anything external.
-//!     autocfg::rerun_path("build.rs");
-//! }
-//! ```
-//!
-//! If the type test succeeds, this will write a `cargo:rustc-cfg=has_i128` line
-//! for Cargo, which translates to Rust arguments `--cfg has_i128`.  Then in the
-//! rest of your Rust code, you can add `#[cfg(has_i128)]` conditions on code that
-//! should only be used when the compiler supports it.
-//!
-//! ## Caution
-//!
-//! Many of the probing methods of `AutoCfg` document the particular template they
-//! use, **subject to change**. The inputs are not validated to make sure they are
-//! semantically correct for their expected use, so it's _possible_ to escape and
-//! inject something unintended. However, such abuse is unsupported and will not
-//! be considered when making changes to the templates.
-
-#![deny(missing_debug_implementations)]
-#![deny(missing_docs)]
-// allow future warnings that can't be fixed while keeping 1.0 compatibility
-#![allow(unknown_lints)]
-#![allow(bare_trait_objects)]
-#![allow(ellipsis_inclusive_range_patterns)]
-
-/// Local macro to avoid `std::try!`, deprecated in Rust 1.39.
-macro_rules! try {
-    ($result:expr) => {
-        match $result {
-            Ok(value) => value,
-            Err(error) => return Err(error),
-        }
-    };
-}
-
-use std::env;
-use std::ffi::OsString;
-use std::fs;
-use std::io::{stderr, Write};
-use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
-#[allow(deprecated)]
-use std::sync::atomic::ATOMIC_USIZE_INIT;
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-mod error;
-pub use error::Error;
-
-mod version;
-use version::Version;
-
-#[cfg(test)]
-mod tests;
-
-/// Helper to detect compiler features for `cfg` output in build scripts.
-#[derive(Clone, Debug)]
-pub struct AutoCfg {
-    out_dir: PathBuf,
-    rustc: PathBuf,
-    rustc_version: Version,
-    target: Option<OsString>,
-    no_std: bool,
-    rustflags: Vec<String>,
-}
-
-/// Writes a config flag for rustc on standard out.
-///
-/// This looks like: `cargo:rustc-cfg=CFG`
-///
-/// Cargo will use this in arguments to rustc, like `--cfg CFG`.
-pub fn emit(cfg: &str) {
-    println!("cargo:rustc-cfg={}", cfg);
-}
-
-/// Writes a line telling Cargo to rerun the build script if `path` changes.
-///
-/// This looks like: `cargo:rerun-if-changed=PATH`
-///
-/// This requires at least cargo 0.7.0, corresponding to rustc 1.6.0.  Earlier
-/// versions of cargo will simply ignore the directive.
-pub fn rerun_path(path: &str) {
-    println!("cargo:rerun-if-changed={}", path);
-}
-
-/// Writes a line telling Cargo to rerun the build script if the environment
-/// variable `var` changes.
-///
-/// This looks like: `cargo:rerun-if-env-changed=VAR`
-///
-/// This requires at least cargo 0.21.0, corresponding to rustc 1.20.0.  Earlier
-/// versions of cargo will simply ignore the directive.
-pub fn rerun_env(var: &str) {
-    println!("cargo:rerun-if-env-changed={}", var);
-}
-
-/// Create a new `AutoCfg` instance.
-///
-/// # Panics
-///
-/// Panics if `AutoCfg::new()` returns an error.
-pub fn new() -> AutoCfg {
-    AutoCfg::new().unwrap()
-}
-
-impl AutoCfg {
-    /// Create a new `AutoCfg` instance.
-    ///
-    /// # Common errors
-    ///
-    /// - `rustc` can't be executed, from `RUSTC` or in the `PATH`.
-    /// - The version output from `rustc` can't be parsed.
-    /// - `OUT_DIR` is not set in the environment, or is not a writable directory.
-    ///
-    pub fn new() -> Result<Self, Error> {
-        match env::var_os("OUT_DIR") {
-            Some(d) => Self::with_dir(d),
-            None => Err(error::from_str("no OUT_DIR specified!")),
-        }
-    }
-
-    /// Create a new `AutoCfg` instance with the specified output directory.
-    ///
-    /// # Common errors
-    ///
-    /// - `rustc` can't be executed, from `RUSTC` or in the `PATH`.
-    /// - The version output from `rustc` can't be parsed.
-    /// - `dir` is not a writable directory.
-    ///
-    pub fn with_dir<T: Into<PathBuf>>(dir: T) -> Result<Self, Error> {
-        let rustc = env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
-        let rustc: PathBuf = rustc.into();
-        let rustc_version = try!(Version::from_rustc(&rustc));
-
-        let target = env::var_os("TARGET");
-
-        // Sanity check the output directory
-        let dir = dir.into();
-        let meta = try!(fs::metadata(&dir).map_err(error::from_io));
-        if !meta.is_dir() || meta.permissions().readonly() {
-            return Err(error::from_str("output path is not a writable directory"));
-        }
-
-        let mut ac = AutoCfg {
-            rustflags: rustflags(&target, &dir),
-            out_dir: dir,
-            rustc: rustc,
-            rustc_version: rustc_version,
-            target: target,
-            no_std: false,
-        };
-
-        // Sanity check with and without `std`.
-        if !ac.probe("").unwrap_or(false) {
-            ac.no_std = true;
-            if !ac.probe("").unwrap_or(false) {
-                // Neither worked, so assume nothing...
-                ac.no_std = false;
-                let warning = b"warning: autocfg could not probe for `std`\n";
-                stderr().write_all(warning).ok();
-            }
-        }
-        Ok(ac)
-    }
-
-    /// Test whether the current `rustc` reports a version greater than
-    /// or equal to "`major`.`minor`".
-    pub fn probe_rustc_version(&self, major: usize, minor: usize) -> bool {
-        self.rustc_version >= Version::new(major, minor, 0)
-    }
-
-    /// Sets a `cfg` value of the form `rustc_major_minor`, like `rustc_1_29`,
-    /// if the current `rustc` is at least that version.
-    pub fn emit_rustc_version(&self, major: usize, minor: usize) {
-        if self.probe_rustc_version(major, minor) {
-            emit(&format!("rustc_{}_{}", major, minor));
-        }
-    }
-
-    fn probe<T: AsRef<[u8]>>(&self, code: T) -> Result<bool, Error> {
-        #[allow(deprecated)]
-        static ID: AtomicUsize = ATOMIC_USIZE_INIT;
-
-        let id = ID.fetch_add(1, Ordering::Relaxed);
-        let mut command = Command::new(&self.rustc);
-        command
-            .arg("--crate-name")
-            .arg(format!("probe{}", id))
-            .arg("--crate-type=lib")
-            .arg("--out-dir")
-            .arg(&self.out_dir)
-            .arg("--emit=llvm-ir");
-
-        if let Some(target) = self.target.as_ref() {
-            command.arg("--target").arg(target);
-        }
-
-        command.args(&self.rustflags);
-
-        command.arg("-").stdin(Stdio::piped());
-        let mut child = try!(command.spawn().map_err(error::from_io));
-        let mut stdin = child.stdin.take().expect("rustc stdin");
-
-        if self.no_std {
-            try!(stdin.write_all(b"#![no_std]\n").map_err(error::from_io));
-        }
-        try!(stdin.write_all(code.as_ref()).map_err(error::from_io));
-        drop(stdin);
-
-        let status = try!(child.wait().map_err(error::from_io));
-        Ok(status.success())
-    }
-
-    /// Tests whether the given sysroot crate can be used.
-    ///
-    /// The test code is subject to change, but currently looks like:
-    ///
-    /// ```ignore
-    /// extern crate CRATE as probe;
-    /// ```
-    pub fn probe_sysroot_crate(&self, name: &str) -> bool {
-        self.probe(format!("extern crate {} as probe;", name)) // `as _` wasn't stabilized until Rust 1.33
-            .unwrap_or(false)
-    }
-
-    /// Emits a config value `has_CRATE` if `probe_sysroot_crate` returns true.
-    pub fn emit_sysroot_crate(&self, name: &str) {
-        if self.probe_sysroot_crate(name) {
-            emit(&format!("has_{}", mangle(name)));
-        }
-    }
-
-    /// Tests whether the given path can be used.
-    ///
-    /// The test code is subject to change, but currently looks like:
-    ///
-    /// ```ignore
-    /// pub use PATH;
-    /// ```
-    pub fn probe_path(&self, path: &str) -> bool {
-        self.probe(format!("pub use {};", path)).unwrap_or(false)
-    }
-
-    /// Emits a config value `has_PATH` if `probe_path` returns true.
-    ///
-    /// Any non-identifier characters in the `path` will be replaced with
-    /// `_` in the generated config value.
-    pub fn emit_has_path(&self, path: &str) {
-        if self.probe_path(path) {
-            emit(&format!("has_{}", mangle(path)));
-        }
-    }
-
-    /// Emits the given `cfg` value if `probe_path` returns true.
-    pub fn emit_path_cfg(&self, path: &str, cfg: &str) {
-        if self.probe_path(path) {
-            emit(cfg);
-        }
-    }
-
-    /// Tests whether the given trait can be used.
-    ///
-    /// The test code is subject to change, but currently looks like:
-    ///
-    /// ```ignore
-    /// pub trait Probe: TRAIT + Sized {}
-    /// ```
-    pub fn probe_trait(&self, name: &str) -> bool {
-        self.probe(format!("pub trait Probe: {} + Sized {{}}", name))
-            .unwrap_or(false)
-    }
-
-    /// Emits a config value `has_TRAIT` if `probe_trait` returns true.
-    ///
-    /// Any non-identifier characters in the trait `name` will be replaced with
-    /// `_` in the generated config value.
-    pub fn emit_has_trait(&self, name: &str) {
-        if self.probe_trait(name) {
-            emit(&format!("has_{}", mangle(name)));
-        }
-    }
-
-    /// Emits the given `cfg` value if `probe_trait` returns true.
-    pub fn emit_trait_cfg(&self, name: &str, cfg: &str) {
-        if self.probe_trait(name) {
-            emit(cfg);
-        }
-    }
-
-    /// Tests whether the given type can be used.
-    ///
-    /// The test code is subject to change, but currently looks like:
-    ///
-    /// ```ignore
-    /// pub type Probe = TYPE;
-    /// ```
-    pub fn probe_type(&self, name: &str) -> bool {
-        self.probe(format!("pub type Probe = {};", name))
-            .unwrap_or(false)
-    }
-
-    /// Emits a config value `has_TYPE` if `probe_type` returns true.
-    ///
-    /// Any non-identifier characters in the type `name` will be replaced with
-    /// `_` in the generated config value.
-    pub fn emit_has_type(&self, name: &str) {
-        if self.probe_type(name) {
-            emit(&format!("has_{}", mangle(name)));
-        }
-    }
-
-    /// Emits the given `cfg` value if `probe_type` returns true.
-    pub fn emit_type_cfg(&self, name: &str, cfg: &str) {
-        if self.probe_type(name) {
-            emit(cfg);
-        }
-    }
-
-    /// Tests whether the given expression can be used.
-    ///
-    /// The test code is subject to change, but currently looks like:
-    ///
-    /// ```ignore
-    /// pub fn probe() { let _ = EXPR; }
-    /// ```
-    pub fn probe_expression(&self, expr: &str) -> bool {
-        self.probe(format!("pub fn probe() {{ let _ = {}; }}", expr))
-            .unwrap_or(false)
-    }
-
-    /// Emits the given `cfg` value if `probe_expression` returns true.
-    pub fn emit_expression_cfg(&self, expr: &str, cfg: &str) {
-        if self.probe_expression(expr) {
-            emit(cfg);
-        }
-    }
-
-    /// Tests whether the given constant expression can be used.
-    ///
-    /// The test code is subject to change, but currently looks like:
-    ///
-    /// ```ignore
-    /// pub const PROBE: () = ((), EXPR).0;
-    /// ```
-    pub fn probe_constant(&self, expr: &str) -> bool {
-        self.probe(format!("pub const PROBE: () = ((), {}).0;", expr))
-            .unwrap_or(false)
-    }
-
-    /// Emits the given `cfg` value if `probe_constant` returns true.
-    pub fn emit_constant_cfg(&self, expr: &str, cfg: &str) {
-        if self.probe_constant(expr) {
-            emit(cfg);
-        }
-    }
-}
-
-fn mangle(s: &str) -> String {
-    s.chars()
-        .map(|c| match c {
-            'A'...'Z' | 'a'...'z' | '0'...'9' => c,
-            _ => '_',
-        })
-        .collect()
-}
-
-fn dir_contains_target(
-    target: &Option<OsString>,
-    dir: &Path,
-    cargo_target_dir: Option<OsString>,
-) -> bool {
-    target
-        .as_ref()
-        .and_then(|target| {
-            dir.to_str().and_then(|dir| {
-                let mut cargo_target_dir = cargo_target_dir
-                    .map(PathBuf::from)
-                    .unwrap_or_else(|| PathBuf::from("target"));
-                cargo_target_dir.push(target);
-
-                cargo_target_dir
-                    .to_str()
-                    .map(|cargo_target_dir| dir.contains(&cargo_target_dir))
-            })
-        })
-        .unwrap_or(false)
-}
-
-fn rustflags(target: &Option<OsString>, dir: &Path) -> Vec<String> {
-    // Starting with rust-lang/cargo#9601, shipped in Rust 1.55, Cargo always sets
-    // CARGO_ENCODED_RUSTFLAGS for any host/target build script invocation. This
-    // includes any source of flags, whether from the environment, toml config, or
-    // whatever may come in the future. The value is either an empty string, or a
-    // list of arguments separated by the ASCII unit separator (US), 0x1f.
-    if let Ok(a) = env::var("CARGO_ENCODED_RUSTFLAGS") {
-        return if a.is_empty() {
-            Vec::new()
-        } else {
-            a.split('\x1f').map(str::to_string).collect()
-        };
-    }
-
-    // Otherwise, we have to take a more heuristic approach, and we don't
-    // support values from toml config at all.
-    //
-    // Cargo only applies RUSTFLAGS for building TARGET artifact in
-    // cross-compilation environment. Sadly, we don't have a way to detect
-    // when we're building HOST artifact in a cross-compilation environment,
-    // so for now we only apply RUSTFLAGS when cross-compiling an artifact.
-    //
-    // See https://github.com/cuviper/autocfg/pull/10#issuecomment-527575030.
-    if *target != env::var_os("HOST")
-        || dir_contains_target(target, dir, env::var_os("CARGO_TARGET_DIR"))
-    {
-        if let Ok(rustflags) = env::var("RUSTFLAGS") {
-            // This is meant to match how cargo handles the RUSTFLAGS environment variable.
-            // See https://github.com/rust-lang/cargo/blob/69aea5b6f69add7c51cca939a79644080c0b0ba0/src/cargo/core/compiler/build_context/target_info.rs#L434-L441
-            return rustflags
-                .split(' ')
-                .map(str::trim)
-                .filter(|s| !s.is_empty())
-                .map(str::to_string)
-                .collect();
-        }
-    }
-
-    Vec::new()
-}

zeroidc/vendor/autocfg/src/tests.rs

@@ -1,174 +0,0 @@
-use super::AutoCfg;
-use std::env;
-use std::path::Path;
-
-impl AutoCfg {
-    fn core_std(&self, path: &str) -> String {
-        let krate = if self.no_std { "core" } else { "std" };
-        format!("{}::{}", krate, path)
-    }
-
-    fn assert_std(&self, probe_result: bool) {
-        assert_eq!(!self.no_std, probe_result);
-    }
-
-    fn assert_min(&self, major: usize, minor: usize, probe_result: bool) {
-        assert_eq!(self.probe_rustc_version(major, minor), probe_result);
-    }
-
-    fn for_test() -> Result<Self, super::error::Error> {
-        match env::var_os("TESTS_TARGET_DIR") {
-            Some(d) => Self::with_dir(d),
-            None => Self::with_dir("target"),
-        }
-    }
-}
-
-#[test]
-fn autocfg_version() {
-    let ac = AutoCfg::for_test().unwrap();
-    println!("version: {:?}", ac.rustc_version);
-    assert!(ac.probe_rustc_version(1, 0));
-}
-
-#[test]
-fn version_cmp() {
-    use super::version::Version;
-    let v123 = Version::new(1, 2, 3);
-
-    assert!(Version::new(1, 0, 0) < v123);
-    assert!(Version::new(1, 2, 2) < v123);
-    assert!(Version::new(1, 2, 3) == v123);
-    assert!(Version::new(1, 2, 4) > v123);
-    assert!(Version::new(1, 10, 0) > v123);
-    assert!(Version::new(2, 0, 0) > v123);
-}
-
-#[test]
-fn probe_add() {
-    let ac = AutoCfg::for_test().unwrap();
-    let add = ac.core_std("ops::Add");
-    let add_rhs = add.clone() + "<i32>";
-    let add_rhs_output = add.clone() + "<i32, Output = i32>";
-    let dyn_add_rhs_output = "dyn ".to_string() + &*add_rhs_output;
-    assert!(ac.probe_path(&add));
-    assert!(ac.probe_trait(&add));
-    assert!(ac.probe_trait(&add_rhs));
-    assert!(ac.probe_trait(&add_rhs_output));
-    ac.assert_min(1, 27, ac.probe_type(&dyn_add_rhs_output));
-}
-
-#[test]
-fn probe_as_ref() {
-    let ac = AutoCfg::for_test().unwrap();
-    let as_ref = ac.core_std("convert::AsRef");
-    let as_ref_str = as_ref.clone() + "<str>";
-    let dyn_as_ref_str = "dyn ".to_string() + &*as_ref_str;
-    assert!(ac.probe_path(&as_ref));
-    assert!(ac.probe_trait(&as_ref_str));
-    assert!(ac.probe_type(&as_ref_str));
-    ac.assert_min(1, 27, ac.probe_type(&dyn_as_ref_str));
-}
-
-#[test]
-fn probe_i128() {
-    let ac = AutoCfg::for_test().unwrap();
-    let i128_path = ac.core_std("i128");
-    ac.assert_min(1, 26, ac.probe_path(&i128_path));
-    ac.assert_min(1, 26, ac.probe_type("i128"));
-}
-
-#[test]
-fn probe_sum() {
-    let ac = AutoCfg::for_test().unwrap();
-    let sum = ac.core_std("iter::Sum");
-    let sum_i32 = sum.clone() + "<i32>";
-    let dyn_sum_i32 = "dyn ".to_string() + &*sum_i32;
-    ac.assert_min(1, 12, ac.probe_path(&sum));
-    ac.assert_min(1, 12, ac.probe_trait(&sum));
-    ac.assert_min(1, 12, ac.probe_trait(&sum_i32));
-    ac.assert_min(1, 12, ac.probe_type(&sum_i32));
-    ac.assert_min(1, 27, ac.probe_type(&dyn_sum_i32));
-}
-
-#[test]
-fn probe_std() {
-    let ac = AutoCfg::for_test().unwrap();
-    ac.assert_std(ac.probe_sysroot_crate("std"));
-}
-
-#[test]
-fn probe_alloc() {
-    let ac = AutoCfg::for_test().unwrap();
-    ac.assert_min(1, 36, ac.probe_sysroot_crate("alloc"));
-}
-
-#[test]
-fn probe_bad_sysroot_crate() {
-    let ac = AutoCfg::for_test().unwrap();
-    assert!(!ac.probe_sysroot_crate("doesnt_exist"));
-}
-
-#[test]
-fn probe_no_std() {
-    let ac = AutoCfg::for_test().unwrap();
-    assert!(ac.probe_type("i32"));
-    assert!(ac.probe_type("[i32]"));
-    ac.assert_std(ac.probe_type("Vec<i32>"));
-}
-
-#[test]
-fn probe_expression() {
-    let ac = AutoCfg::for_test().unwrap();
-    assert!(ac.probe_expression(r#""test".trim_left()"#));
-    ac.assert_min(1, 30, ac.probe_expression(r#""test".trim_start()"#));
-    ac.assert_std(ac.probe_expression("[1, 2, 3].to_vec()"));
-}
-
-#[test]
-fn probe_constant() {
-    let ac = AutoCfg::for_test().unwrap();
-    assert!(ac.probe_constant("1 + 2 + 3"));
-    ac.assert_min(1, 33, ac.probe_constant("{ let x = 1 + 2 + 3; x * x }"));
-    ac.assert_min(1, 39, ac.probe_constant(r#""test".len()"#));
-}
-
-#[test]
-fn dir_does_not_contain_target() {
-    assert!(!super::dir_contains_target(
-        &Some("x86_64-unknown-linux-gnu".into()),
-        Path::new("/project/target/debug/build/project-ea75983148559682/out"),
-        None,
-    ));
-}
-
-#[test]
-fn dir_does_contain_target() {
-    assert!(super::dir_contains_target(
-        &Some("x86_64-unknown-linux-gnu".into()),
-        Path::new(
-            "/project/target/x86_64-unknown-linux-gnu/debug/build/project-0147aca016480b9d/out"
-        ),
-        None,
-    ));
-}
-
-#[test]
-fn dir_does_not_contain_target_with_custom_target_dir() {
-    assert!(!super::dir_contains_target(
-        &Some("x86_64-unknown-linux-gnu".into()),
-        Path::new("/project/custom/debug/build/project-ea75983148559682/out"),
-        Some("custom".into()),
-    ));
-}
-
-#[test]
-fn dir_does_contain_target_with_custom_target_dir() {
-    assert!(super::dir_contains_target(
-        &Some("x86_64-unknown-linux-gnu".into()),
-        Path::new(
-            "/project/custom/x86_64-unknown-linux-gnu/debug/build/project-0147aca016480b9d/out"
-        ),
-        Some("custom".into()),
-    ));
-}

zeroidc/vendor/autocfg/src/version.rs

@@ -1,60 +0,0 @@
-use std::path::Path;
-use std::process::Command;
-use std::str;
-
-use super::{error, Error};
-
-/// A version structure for making relative comparisons.
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Version {
-    major: usize,
-    minor: usize,
-    patch: usize,
-}
-
-impl Version {
-    /// Creates a `Version` instance for a specific `major.minor.patch` version.
-    pub fn new(major: usize, minor: usize, patch: usize) -> Self {
-        Version {
-            major: major,
-            minor: minor,
-            patch: patch,
-        }
-    }
-
-    pub fn from_rustc(rustc: &Path) -> Result<Self, Error> {
-        // Get rustc's verbose version
-        let output = try!(Command::new(rustc)
-            .args(&["--version", "--verbose"])
-            .output()
-            .map_err(error::from_io));
-        if !output.status.success() {
-            return Err(error::from_str("could not execute rustc"));
-        }
-        let output = try!(str::from_utf8(&output.stdout).map_err(error::from_utf8));
-
-        // Find the release line in the verbose version output.
-        let release = match output.lines().find(|line| line.starts_with("release: ")) {
-            Some(line) => &line["release: ".len()..],
-            None => return Err(error::from_str("could not find rustc release")),
-        };
-
-        // Strip off any extra channel info, e.g. "-beta.N", "-nightly"
-        let version = match release.find('-') {
-            Some(i) => &release[..i],
-            None => release,
-        };
-
-        // Split the version into semver components.
-        let mut iter = version.splitn(3, '.');
-        let major = try!(iter.next().ok_or(error::from_str("missing major version")));
-        let minor = try!(iter.next().ok_or(error::from_str("missing minor version")));
-        let patch = try!(iter.next().ok_or(error::from_str("missing patch version")));
-
-        Ok(Version::new(
-            try!(major.parse().map_err(error::from_num)),
-            try!(minor.parse().map_err(error::from_num)),
-            try!(patch.parse().map_err(error::from_num)),
-        ))
-    }
-}

zeroidc/vendor/autocfg/tests/rustflags.rs

@@ -1,33 +0,0 @@
-extern crate autocfg;
-
-use std::env;
-
-/// Tests that autocfg uses the RUSTFLAGS or CARGO_ENCODED_RUSTFLAGS
-/// environment variables when running rustc.
-#[test]
-fn test_with_sysroot() {
-    // Use the same path as this test binary.
-    let dir = env::current_exe().unwrap().parent().unwrap().to_path_buf();
-    env::set_var("OUT_DIR", &format!("{}", dir.display()));
-
-    // If we have encoded rustflags, they take precedence, even if empty.
-    env::set_var("CARGO_ENCODED_RUSTFLAGS", "");
-    env::set_var("RUSTFLAGS", &format!("-L {}", dir.display()));
-    let ac = autocfg::AutoCfg::new().unwrap();
-    assert!(ac.probe_sysroot_crate("std"));
-    assert!(!ac.probe_sysroot_crate("autocfg"));
-
-    // Now try again with useful encoded args.
-    env::set_var(
-        "CARGO_ENCODED_RUSTFLAGS",
-        &format!("-L\x1f{}", dir.display()),
-    );
-    let ac = autocfg::AutoCfg::new().unwrap();
-    assert!(ac.probe_sysroot_crate("autocfg"));
-
-    // Try the old-style RUSTFLAGS, ensuring HOST != TARGET.
-    env::remove_var("CARGO_ENCODED_RUSTFLAGS");
-    env::set_var("HOST", "lol");
-    let ac = autocfg::AutoCfg::new().unwrap();
-    assert!(ac.probe_sysroot_crate("autocfg"));
-}

zeroidc/vendor/base64-0.13.0/Cargo.lock

@@ -1,826 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "ansi_term"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "hermit-abi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.74 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "autocfg"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "autocfg"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "base64"
-version = "0.13.0"
-dependencies = [
- "criterion 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "structopt 0.3.17 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "bitflags"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "bstr"
-version = "0.2.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex-automata 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 1.0.114 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "bumpalo"
-version = "3.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "byteorder"
-version = "1.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "cast"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "cfg-if"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "clap"
-version = "2.33.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
- "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "vec_map 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "cloudabi"
-version = "0.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "criterion"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
- "cast 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "clap 2.33.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "criterion-plot 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "csv 1.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "itertools 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
- "oorandom 11.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "plotters 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
- "rayon 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 1.0.114 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde_derive 1.0.114 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde_json 1.0.57 (registry+https://github.com/rust-lang/crates.io-index)",
- "tinytemplate 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "walkdir 2.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "criterion-plot"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "cast 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "itertools 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "crossbeam-epoch 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "memoffset 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "crossbeam-queue"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "csv"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "bstr 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "csv-core 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "ryu 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 1.0.114 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "csv-core"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "either"
-version = "1.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "fuchsia-cprng"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "heck"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-segmentation 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.1.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.74 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "itertools"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "either 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "itoa"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "js-sys"
-version = "0.3.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "wasm-bindgen 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "libc"
-version = "0.2.74"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "log"
-version = "0.4.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "maybe-uninit"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "memchr"
-version = "2.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "memoffset"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "num_cpus"
-version = "1.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "hermit-abi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.74 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "oorandom"
-version = "11.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "plotters"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "js-sys 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
- "num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
- "wasm-bindgen 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)",
- "web-sys 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "proc-macro-error"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro-error-attr 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "proc-macro2 1.0.19 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
- "version_check 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 1.0.19 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "version_check 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 1.0.19 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.74 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_jitter 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "rand_hc"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_isaac"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_jitter"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.74 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_os"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.74 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_pcg"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_xorshift"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rayon"
-version = "1.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "crossbeam-deque 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "either 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "rayon-core 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "crossbeam-deque 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "crossbeam-queue 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rdrand"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "regex"
-version = "1.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "regex-syntax 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "rustc_version"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "same-file"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "scopeguard"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "semver"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "semver-parser"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "serde"
-version = "1.0.114"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "serde_derive"
-version = "1.0.114"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 1.0.19 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.57"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "ryu 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 1.0.114 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "strsim"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "structopt"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "clap 2.33.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "structopt-derive 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "structopt-derive"
-version = "0.4.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "proc-macro-error 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "proc-macro2 1.0.19 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.36"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 1.0.19 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "textwrap"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "tinytemplate"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "serde 1.0.114 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde_json 1.0.57 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "unicode-segmentation"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "vec_map"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "version_check"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "walkdir"
-version = "2.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "same-file 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "wasm-bindgen-macro 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "bumpalo 3.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "proc-macro2 1.0.19 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
- "wasm-bindgen-shared 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "wasm-bindgen-macro-support 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 1.0.19 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
- "wasm-bindgen-backend 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)",
- "wasm-bindgen-shared 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "web-sys"
-version = "0.3.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "js-sys 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
- "wasm-bindgen 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "winapi-util"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[metadata]
-"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
-"checksum atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-"checksum autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1d49d90015b3c36167a20fe2810c5cd875ad504b39cff3d4eae7977e6b7c1cb2"
-"checksum autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
-"checksum bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
-"checksum bstr 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)" = "31accafdb70df7871592c058eca3985b71104e15ac32f64706022c58867da931"
-"checksum bumpalo 3.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2e8c087f005730276d1096a652e92a8bacee2e2472bcc9715a74d2bec38b5820"
-"checksum byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
-"checksum cast 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4b9434b9a5aa1450faa3f9cb14ea0e8c53bb5d2b3c1bfd1ab4fc03e9f33fbfb0"
-"checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
-"checksum clap 2.33.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bdfa80d47f954d53a35a64987ca1422f495b8d6483c0fe9f7117b36c2a792129"
-"checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
-"checksum criterion 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "63f696897c88b57f4ffe3c69d8e1a0613c7d0e6c4833363c8560fbde9c47b966"
-"checksum criterion-plot 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e022feadec601fba1649cfa83586381a4ad31c6bf3a9ab7d408118b05dd9889d"
-"checksum crossbeam-deque 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "9f02af974daeee82218205558e51ec8768b48cf524bd01d550abe5573a608285"
-"checksum crossbeam-epoch 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
-"checksum crossbeam-queue 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "774ba60a54c213d409d5353bda12d49cd68d14e45036a285234c8d6f91f92570"
-"checksum crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
-"checksum csv 1.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "00affe7f6ab566df61b4be3ce8cf16bc2576bca0963ceb0955e45d514bf9a279"
-"checksum csv-core 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
-"checksum either 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "bb1f6b1ce1c140482ea30ddd3335fc0024ac7ee112895426e0a629a6c20adfe3"
-"checksum fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
-"checksum heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205"
-"checksum hermit-abi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "3deed196b6e7f9e44a2ae8d94225d80302d81208b1bb673fd21fe634645c85a9"
-"checksum itertools 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
-"checksum itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
-"checksum js-sys 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)" = "85a7e2c92a4804dd459b86c339278d0fe87cf93757fae222c3fa3ae75458bc73"
-"checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-"checksum libc 0.2.74 (registry+https://github.com/rust-lang/crates.io-index)" = "a2f02823cf78b754822df5f7f268fb59822e7296276d3e069d8e8cb26a14bd10"
-"checksum log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
-"checksum maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
-"checksum memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
-"checksum memoffset 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c198b026e1bbf08a937e94c6c60f9ec4a2267f5b0d2eec9c1b21b061ce2be55f"
-"checksum num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611"
-"checksum num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
-"checksum oorandom 11.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a170cebd8021a008ea92e4db85a72f80b35df514ec664b296fdcbb654eac0b2c"
-"checksum plotters 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)" = "0d1685fbe7beba33de0330629da9d955ac75bd54f33d7b79f9a895590124f6bb"
-"checksum proc-macro-error 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
-"checksum proc-macro-error-attr 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
-"checksum proc-macro2 1.0.19 (registry+https://github.com/rust-lang/crates.io-index)" = "04f5f085b5d71e2188cb8271e5da0161ad52c3f227a661a3c135fdf28e258b12"
-"checksum quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
-"checksum rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca"
-"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
-"checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
-"checksum rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
-"checksum rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b40677c7be09ae76218dc623efbf7b18e34bced3f38883af07bb75630a21bc4"
-"checksum rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ded997c9d5f13925be2a6fd7e66bf1872597f759fd9dd93513dd7e92e5a5ee08"
-"checksum rand_jitter 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b"
-"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
-"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
-"checksum rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c"
-"checksum rayon 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "62f02856753d04e03e26929f820d0a0a337ebe71f849801eea335d464b349080"
-"checksum rayon-core 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e92e15d89083484e11353891f1af602cc661426deb9564c298b270c726973280"
-"checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
-"checksum regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "9c3780fcf44b193bc4d09f36d2a3c87b251da4a046c87795a0d35f4f927ad8e6"
-"checksum regex-automata 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "ae1ded71d66a4a97f5e961fd0cb25a5f366a42a41570d16a763a69c092c26ae4"
-"checksum regex-syntax 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)" = "26412eb97c6b088a6997e05f69403a802a92d520de2f8e63c2b65f9e0f47c4e8"
-"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-"checksum ryu 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
-"checksum same-file 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
-"checksum scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
-"checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-"checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-"checksum serde 1.0.114 (registry+https://github.com/rust-lang/crates.io-index)" = "5317f7588f0a5078ee60ef675ef96735a1442132dc645eb1d12c018620ed8cd3"
-"checksum serde_derive 1.0.114 (registry+https://github.com/rust-lang/crates.io-index)" = "2a0be94b04690fbaed37cddffc5c134bf537c8e3329d53e982fe04c374978f8e"
-"checksum serde_json 1.0.57 (registry+https://github.com/rust-lang/crates.io-index)" = "164eacbdb13512ec2745fb09d51fd5b22b0d65ed294a1dcf7285a360c80a675c"
-"checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
-"checksum structopt 0.3.17 (registry+https://github.com/rust-lang/crates.io-index)" = "6cc388d94ffabf39b5ed5fadddc40147cb21e605f53db6f8f36a625d27489ac5"
-"checksum structopt-derive 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "5e2513111825077552a6751dfad9e11ce0fba07d7276a3943a037d7e93e64c5f"
-"checksum syn 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)" = "4cdb98bcb1f9d81d07b536179c269ea15999b5d14ea958196413869445bb5250"
-"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
-"checksum tinytemplate 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6d3dc76004a03cec1c5932bca4cdc2e39aaa798e3f82363dd94f9adf6098c12f"
-"checksum unicode-segmentation 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0"
-"checksum unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
-"checksum unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
-"checksum vec_map 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
-"checksum version_check 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"
-"checksum walkdir 2.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "777182bc735b6424e1a57516d35ed72cb8019d85c8c9bf536dccb3445c1a2f7d"
-"checksum wasm-bindgen 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)" = "f0563a9a4b071746dd5aedbc3a28c6fe9be4586fb3fbadb67c400d4f53c6b16c"
-"checksum wasm-bindgen-backend 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)" = "bc71e4c5efa60fb9e74160e89b93353bc24059999c0ae0fb03affc39770310b0"
-"checksum wasm-bindgen-macro 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)" = "97c57cefa5fa80e2ba15641578b44d36e7a64279bc5ed43c6dbaf329457a2ed2"
-"checksum wasm-bindgen-macro-support 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)" = "841a6d1c35c6f596ccea1f82504a192a60378f64b3bb0261904ad8f2f5657556"
-"checksum wasm-bindgen-shared 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)" = "93b162580e34310e5931c4b792560108b10fd14d64915d7fff8ff00180e70092"
-"checksum web-sys 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)" = "dda38f4e5ca63eda02c059d243aa25b5f35ab98451e518c51612cd0f1bd19a47"
-"checksum winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-"checksum winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
-"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

zeroidc/vendor/base64-0.13.0/Cargo.toml

@@ -1,43 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-edition = "2018"
-name = "base64"
-version = "0.13.0"
-authors = ["Alice Maz <[email protected]>", "Marshall Pierce <[email protected]>"]
-description = "encodes and decodes base64 as bytes or utf8"
-documentation = "https://docs.rs/base64"
-readme = "README.md"
-keywords = ["base64", "utf8", "encode", "decode", "no_std"]
-categories = ["encoding"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/marshallpierce/rust-base64"
-[profile.bench]
-debug = true
-
-[[bench]]
-name = "benchmarks"
-harness = false
-[dev-dependencies.criterion]
-version = "=0.3.2"
-
-[dev-dependencies.rand]
-version = "0.6.1"
-
-[dev-dependencies.structopt]
-version = "0.3"
-
-[features]
-alloc = []
-default = ["std"]
-std = []

zeroidc/vendor/base64-0.13.0/LICENSE-APACHE

@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

zeroidc/vendor/base64-0.13.0/LICENSE-MIT

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Alice Maz
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.