A bunch of little warning removal and format fix things.

This reverts commit 8f1e6a2fde.

.dockerignore

@@ -0,0 +1,3 @@
+.git/
+build/
+!build/zerotier

.gitignore

@@ -1,60 +1,23 @@
-# Main binaries created in *nix builds
-/zerotier-one
-/zerotier-idtool
-/zerotier-cli
-/zerotier-selftest
-/zerotier
-/nltest
-
-# OS-created garbage files from various platforms
+/build
+/cmake-build-debug
+/cmake-build-release
+/core/version.h
+/.idea
+/.ide-*
 .DS_Store
+.Trashes
+*.swp
+._*
+*~
+*~.nib
+*.secret
 .Apple*
 Thumbs.db
 @eaDir
-._*
-
-# Windows build droppings
-/windows/ZeroTierOne.sdf
-/windows/ZeroTierOne.v11.suo
-/windows/x64
-/windows/Win32
-/windows/*/x64
-/windows/*/Win32
-/windows/ZeroTierOne/Release
-/windows/ZeroTierOneService/obj
-/windows/ZeroTierOneService/bin
-/windows/Build
-/windows/Debug
-/windows/Release
-/windows/WebUIWrapper/bin
-/windows/WebUIWrapper/obj
-/windows/lib
-/ext/installfiles/windows/ZeroTier One-SetupFiles
-/ext/installfiles/windows/Prerequisites
-/ext/installfiles/windows/*-cache
-/ZeroTier One.msi
-/windows/.vs
-*.vcxproj.backup
-/windows/TapDriver6/Win7Debug
-/windows/TapDriver6/win7Release
-/windows/*.db
-/windows/*.opendb
-enc_temp_folder
-/windows/copyutil/bin
-/windows/copyutil/obj
-
-# *nix/Mac build droppings
-/build-*
-/ZeroTierOneInstaller-*
-/examples/docker/zerotier-one
-/examples/docker/test-*.env
-/world/mkworld
-/world/*.c25519
-zt1-src.tar.gz
-/MacEthernetTapAgent
-
-# Miscellaneous temporaries, build files, etc.
+.vscode
+__pycache__
 *.log
+*.bak
 *.opensdf
 *.user
 *.cache
@@ -63,10 +26,6 @@ zt1-src.tar.gz
 *.pid
 *.pkg
 *.o
-/*.a
-*.dylib
-*.so
-*.so.*
 *.o-*
 *.core
 *.deb
@@ -75,49 +34,6 @@ zt1-src.tar.gz
 *.tmp
 .depend
 node_modules
-zt1_update_*
-debian/files
-debian/zerotier-one
-debian/zerotier-one*.debhelper
-debian/*.log
-debian/zerotier-one.substvars
-root-watcher/config.json
-
-# Java/Android/JNI build droppings
-java/obj/
-java/libs/
-java/bin/
-java/classes/
-java/doc/
-java/build_win64/
-java/build_win32/
-/java/mac32_64/
-windows/WinUI/obj/
-windows/WinUI/bin/
-windows/ZeroTierOne/Debug/
-/ext/installfiles/windows/chocolatey/zerotier-one/*.nupkg
-
-# Miscellaneous mac/Xcode droppings
-.DS_Store
-.Trashes
-*.swp
-*~.nib
-DerivedData/
-build/
-*.pbxuser
-*.mode1v3
-*.mode2v3
-*.perspectivev3
-!default.pbxuser
-!default.mode1v3
-!default.mode2v3
-!default.perspectivev3
-*.xccheckout
-xcuserdata/
-ext/librethinkdbxx/build
-.vscode
-__pycache__
-*~
-attic/world/*.c25519
-attic/world/mkworld
-workspace/
+*.vcxproj.backup
+/*.db
+/*.opendb

AUTHORS.md

@@ -9,7 +9,7 @@
  * Java JNI Interface to enable Android application development, and Android app itself (code for that is elsewhere)<br>
    Grant Limberg / glimberg@gmail.com
 
- * ZeroTier SDK (formerly known as Network Containers)<br>
+ * ZeroTier SDK / libzt<br>
    Joseph Henry / joseph.henry@zerotier.com
 
 ## Third Party Contributors
@@ -32,44 +32,30 @@ ZeroTier includes the following third party code, either in ext/ or incorporated
 
  * LZ4 compression algorithm by Yann Collet
 
-   * Files: node/Packet.cpp (bundled within anonymous namespace)
+   * Files: node/LZ4.cpp
    * Home page: http://code.google.com/p/lz4/
-   * License grant: BSD 2-clause
-
- * http-parser by Joyent, Inc. (many authors)
-
-   * Files: ext/http-parser/*
-   * Home page: https://github.com/joyent/http-parser/
-   * License grant: MIT/Expat
+   * License: BSD 2-clause
 
  * C++11 json (nlohmann/json) by Niels Lohmann
 
    * Files: ext/json/*
    * Home page: https://github.com/nlohmann/json
-   * License grant: MIT
+   * License: MIT
 
  * tap-windows6 by the OpenVPN project
 
    * Files: windows/TapDriver6/*
    * Home page: https://github.com/OpenVPN/tap-windows6/
-   * License grant: GNU GPL v2
-   * ZeroTier Modifications: change name of driver to ZeroTier, add ioctl() to get L2 multicast memberships (source is in ext/ and modifications inherit GPL)
+   * License: GNU GPL v2
 
  * Salsa20 stream cipher, Curve25519 elliptic curve cipher, Ed25519 digital signature algorithm, and Poly1305 MAC algorithm, all by Daniel J. Bernstein
 
    * Files: node/Salsa20.* node/C25519.* node/Poly1305.*
    * Home page: http://cr.yp.to/
-   * License grant: public domain
-   * ZeroTier Modifications: slight cryptographically-irrelevant modifications for inclusion into ZeroTier core
-
- * MiniUPNPC and libnatpmp by Thomas Bernard
-
-   * Files: ext/libnatpmp/* ext/miniupnpc/*
-   * Home page: http://miniupnp.free.fr/
-   * License grant: BSD attribution no-endorsement
+   * License: public domain
 
  * cpp-httplib by yhirose
 
    * Files: ext/cpp-httplib/*
    * Home page: https://github.com/yhirose/cpp-httplib
-   * License grant: MIT
+   * License: MIT

CMakeLists.txt

@@ -1,12 +1,346 @@
-# CMake build script for libzerotiercore.a
+cmake_minimum_required (VERSION 3.8)
 
-cmake_minimum_required (VERSION 2.8)
-project (zerotiercore)
+cmake_policy(SET CMP0048 NEW)
 
-set (PROJ_DIR ${PROJECT_SOURCE_DIR})
-set (ZT_DEFS -std=c++11)
+if(${CMAKE_VERSION} VERSION_LESS 3.15)
+	cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+else()
+	cmake_policy(VERSION 3.15)
+endif()
 
-file(GLOB core_src_glob ${PROJ_DIR}/node/*.cpp)
-add_library(zerotiercore STATIC ${core_src_glob})
+set(ZEROTIER_VERSION_MAJOR 1 CACHE INTERNAL "")
+set(ZEROTIER_VERSION_MINOR 9 CACHE INTERNAL "")
+set(ZEROTIER_VERSION_REVISION 0 CACHE INTERNAL "")
+set(ZEROTIER_VERSION_BUILD 0 CACHE INTERNAL "")
 
-target_compile_options(zerotiercore PRIVATE ${ZT_DEFS})
+project(zerotier
+	VERSION ${ZEROTIER_VERSION_MAJOR}.${ZEROTIER_VERSION_MINOR}.${ZEROTIER_VERSION_REVISION}.${ZEROTIER_VERSION_BUILD}
+	DESCRIPTION "ZeroTier Network Hypervisor"
+	LANGUAGES CXX C)
+
+if(NOT PACKAGE_STATIC)
+
+	find_program(
+		GO go
+		HINTS "/usr/local/go/bin" "/usr/bin" "/usr/local/bin" "C:/go/bin"
+	)
+	if(NOT GO)
+		message(FATAL_ERROR "Golang not found")
+	else(NOT GO)
+		message(STATUS "Found Golang at ${GO}")
+	endif(NOT GO)
+
+	set(default_build_type "Release")
+
+	if(WIN32)
+		set(CMAKE_CXX_STANDARD 17)
+		set(CMAKE_SYSTEM_VERSION "7" CACHE STRING INTERNAL FORCE)
+	else(WIN32)
+		if(APPLE)
+			set(CMAKE_CXX_STANDARD 17)
+		else(APPLE)
+			set(CMAKE_CXX_STANDARD 11)
+		endif(APPLE)
+	endif(WIN32)
+
+	if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+		message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
+		set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE STRING "Choose the type of build." FORCE)
+		set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+	endif()
+
+	option(BUILD_CENTRAL_CONTROLLER "Build ZeroTier Central Controller" OFF)
+	if(BUILD_CENTRAL_CONTROLLER)
+		find_package(PkgConfig REQUIRED)
+		if(APPLE)
+			set(CMAKE_PREFIX_PATH
+				${CMAKE_PREFIX_PATH}
+				/usr/local/opt/libpq
+				/usr/local/lib
+			)
+		endif(APPLE)
+		find_package(PostgreSQL REQUIRED)
+
+		pkg_check_modules(hiredis REQUIRED IMPORTED_TARGET hiredis)
+
+		add_subdirectory(controller/thirdparty/redis-plus-plus-1.1.1)
+		set(redispp_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/controller/thirdparty/redis-plus-plus-1.1.1/src/sw)
+		set(redispp_STATIC_LIB redispp_static)
+	endif(BUILD_CENTRAL_CONTROLLER)
+
+	if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+		add_definitions(-DZT_DEBUG)
+	endif(CMAKE_BUILD_TYPE STREQUAL "Debug")
+
+	if(WIN32)
+
+		message("++ Setting Windows Compiler Flags ${CMAKE_BUILD_TYPE}")
+
+		add_definitions(-DNOMINMAX)
+		add_compile_options(
+			-Wall
+			-Wno-deprecated
+			-Wno-unused-function
+			-Wno-format
+			$<$<CONFIG:DEBUG>:-g>
+			$<$<CONFIG:DEBUG>:-O0>
+			$<$<CONFIG:RELEASE>:-O3>
+			$<$<CONFIG:RELEASE>:-ffast-math>
+			$<$<CONFIG:RELWITHDEBINFO>:-O3>
+			$<$<CONFIG:RELWITHDEBINFO>:-g>
+		)
+
+		set(GOFLAGS
+			-a
+			-trimpath
+		)
+
+		if(BUILD_32BIT)
+			set(CMAKE_SYSTEM_PROCESSOR "x86" CACHE STRING "system processor")
+			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32" CACHE STRING "c++ flags")
+			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32" CACHE STRING "c flags")
+			set(GOARCH "GOARCH=386" CACHE STRING "go architecture")
+			add_compile_options(
+				-m32
+			)
+			add_link_options(
+				-m32
+			)
+		endif(BUILD_32BIT)
+
+	else(WIN32)
+
+		set(GOFLAGS
+			-trimpath
+			-buildmode=pie
+		)
+
+		if(APPLE)
+
+			message("++ Setting MacOS Compiler Flags ${CMAKE_BUILD_TYPE}")
+
+			set(MACOS_VERSION_MIN "10.12")
+
+			add_compile_options(
+				-Wall
+				-Wno-deprecated
+				-Wno-unused-function
+				-mmacosx-version-min=${MACOS_VERSION_MIN}
+				$<$<CONFIG:DEBUG>:-g>
+				$<$<CONFIG:DEBUG>:-O0>
+				$<$<CONFIG:RELEASE>:-Ofast>
+				$<$<CONFIG:RELEASE>:-ffast-math>
+				$<$<CONFIG:RELEASE>:-fPIE>
+				$<$<CONFIG:RELEASE>:-flto>
+				$<$<CONFIG:RELWITHDEBINFO>:-O1>
+				$<$<CONFIG:RELWITHDEBINFO>:-fPIE>
+				$<$<CONFIG:RELWITHDEBINFO>:-g>
+			)
+
+			add_link_options(
+				-mmacosx-version-min=${MACOS_VERSION_MIN}
+				$<$<CONFIG:RELEASE>:-flto>
+			)
+
+			set(GOFLAGS
+				${GOFLAGS}
+				-a
+				-ldflags '-w -extldflags \"-Wl,-undefined -Wl,dynamic_lookup\"'
+			)
+
+		else(APPLE)
+
+			message("++ Setting Linux/BSD/Posix Compiler Flags (${CMAKE_BUILD_TYPE})")
+
+			add_compile_options(
+				-Wall
+				-Wno-deprecated
+				-Wno-unused-function
+				-Wno-format
+				$<$<CONFIG:DEBUG>:-g>
+				$<$<CONFIG:DEBUG>:-O0>
+				$<$<CONFIG:RELEASE>:-O3>
+				$<$<CONFIG:RELEASE>:-ffast-math>
+				$<$<CONFIG:RELEASE>:-fPIE>
+				$<$<CONFIG:RELWITHDEBINFO>:-O3>
+				$<$<CONFIG:RELWITHDEBINFO>:-fPIE>
+				$<$<CONFIG:RELWITHDEBINFO>:-g>
+			)
+
+			option(BUILD_32BIT "Force building as 32-bit binary" OFF)
+			option(BUILD_STATIC "Build statically linked executable" OFF)
+			option(BUILD_ARM_V5 "Build ARMv5" OFF)
+			option(BUILD_ARM_V6 "Build ARMv6" OFF)
+
+			if(BUILD_ARM_V5 AND BUILD_ARM_V6)
+				message(FATAL_ERROR "BUILD_ARM_V5 and BUILD_ARM_V6 are mutually exclusive!")
+			endif(BUILD_ARM_V5 AND BUILD_ARM_V6)
+
+			if(BUILD_32BIT)
+				set(CMAKE_SYSTEM_PROCESSOR "x86" CACHE STRING "system processor")
+				set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32" CACHE STRING "c++ flags")
+				set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32" CACHE STRING "c flags")
+				set(GOARCH "GOARCH=386" CACHE STRING "go architecture")
+				add_compile_options(
+					-m32
+				)
+			endif(BUILD_32BIT)
+
+			if(BUILD_STATIC)
+				add_link_options(
+					-static
+				)
+				set(CMAKE_EXE_LINKER_FLAGS "-static ${CMAKE_EXE_LINKER_FLAGS}")
+				set(GOFLAGS
+					${GOFLAGS}
+					-a
+					-tags osusergo,netgo
+					-ldflags '-w -extldflags \"-static -Wl,-unresolved-symbols=ignore-all\"'
+				)
+			else(BUILD_STATIC)
+				set(GOFLAGS
+					${GOFLAGS}
+					-a
+					-ldflags '-w -extldflags \"-Wl,-unresolved-symbols=ignore-all\"'
+				)
+			endif(BUILD_STATIC)
+
+			if(BUILD_ARM_V5)
+				set(GOARM "GOARM=5")
+			endif(BUILD_ARM_V5)
+
+			if(BUILD_ARM_V6)
+				set(GOARM "GOARM=6")
+			endif(BUILD_ARM_V6)
+
+		endif(APPLE)
+	endif(WIN32)
+
+	if (
+		CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR
+		CMAKE_SYSTEM_PROCESSOR MATCHES "amd64" OR
+		CMAKE_SYSTEM_PROCESSOR MATCHES "AMD64" OR
+		CMAKE_SYSTEM_PROCESSOR MATCHES "X86_64" OR
+		CMAKE_SYSTEM_PROCESSOR MATCHES "x64" OR
+		CMAKE_SYSTEM_PROCESSOR MATCHES "X64"
+	)
+		message("++ Adding flags for processor ${CMAKE_SYSTEM_PROCESSOR}")
+		add_compile_options(-maes -mrdrnd -mpclmul -msse -msse2)
+	endif()
+
+	if (
+		CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64" OR
+		CMAKE_SYSTEM_PROCESSOR MATCHES "arm64" OR
+		CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64" OR
+		CMAKE_SYSTEM_PROCESSOR MATCHES "AARCH64"
+	)
+		message("++ Adding flags for processor ${CMAKE_SYSTEM_PROCESSOR}")
+		add_compile_options(-march=armv8-a+aes+crypto -mtune=generic -mstrict-align)
+	endif()
+
+	set(GO_BUILD_TAGS)
+
+	if(BUILD_CENTRAL_CONTROLLER)
+		add_definitions(-DZT_CONTROLLER_USE_LIBPQ=1)
+		set(GO_BUILD_TAGS -tags central)
+	endif(BUILD_CENTRAL_CONTROLLER)
+
+	add_subdirectory(core)
+	add_subdirectory(controller)
+	add_subdirectory(osdep)
+	add_subdirectory(serviceiocore)
+
+	file(GLOB go_src
+		${CMAKE_SOURCE_DIR}/cmd/*.go
+		${CMAKE_SOURCE_DIR}/cmd/cmd/*.go
+		${CMAKE_SOURCE_DIR}/pkg/zerotier/*.go
+	)
+	file(GLOB go_zt_service_tests_cmd_src
+		${CMAKE_SOURCE_DIR}/cmd/zt_service_tests/*.go
+	)
+
+	if(WIN32)
+		set(GO_EXE_NAME "zerotier.exe")
+		set(GO_SERVICE_TESTS_EXE_NAME "zt_service_tests.exe")
+		set(GO_EXTRA_LIBRARIES "-lstdc++ -lwsock32 -lws2_32 -liphlpapi -lole32 -loleaut32 -lrpcrt4 -luuid")
+	else(WIN32)
+		set(GO_EXE_NAME "zerotier")
+		set(GO_SERVICE_TESTS_EXE_NAME "zt_service_tests")
+		if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+			set(GO_EXTRA_LIBRARIES "-lstdc++")
+			if(BUILD_ARM_V5)
+				set(GO_EXTRA_LIBRARIES
+					${GO_EXTRA_LIBRARIES}
+					"-latomic"
+				)
+			endif(BUILD_ARM_V5)
+		else()
+			set(GO_EXTRA_LIBRARIES "-lc++" "-lm")
+		endif()
+	endif(WIN32)
+
+	add_custom_target(
+		zt_service_tests ALL
+		BYPRODUCTS ${CMAKE_BINARY_DIR}/zt_service_tests
+		SOURCES ${go_src} ${go_zt_service_tests_cmd_src}
+		COMMAND ${CMAKE_COMMAND} -E env ${GOARCH} ${GOARM} CGO_ENABLED=1 CGO_CFLAGS=\"-O3\" CGO_LDFLAGS=\"$<TARGET_FILE:zt_core> $<TARGET_FILE:zt_controller> $<TARGET_FILE:zt_service_io_core> $<TARGET_FILE:zt_osdep> ${GO_EXTRA_LIBRARIES}\" ${GO} build -mod=vendor ${GOFLAGS} -o ${CMAKE_BINARY_DIR}/${GO_SERVICE_TESTS_EXE_NAME} ${go_zt_service_tests_cmd_src}
+		COMMENT "Compiling zt_service_tests (Go/cgo self-tests)..."
+	)
+	add_dependencies(zt_service_tests zt_osdep zt_core zt_controller zt_service_io_core)
+
+	add_custom_target(
+		zerotier ALL
+		BYPRODUCTS ${CMAKE_BINARY_DIR}/zerotier
+		SOURCES ${go_src}
+		COMMAND ${CMAKE_COMMAND} -E env ${GOARCH} ${GOARM} CGO_ENABLED=1 CGO_CFLAGS=\"-O3\" CGO_LDFLAGS=\"$<TARGET_FILE:zt_core> $<TARGET_FILE:zt_controller> $<TARGET_FILE:zt_service_io_core> $<TARGET_FILE:zt_osdep> ${GO_EXTRA_LIBRARIES}\" ${GO} build -mod=vendor ${GOFLAGS} -o ${CMAKE_BINARY_DIR}/${GO_EXE_NAME} ${CMAKE_SOURCE_DIR}/cmd/zerotier/zerotier.go
+		COMMENT "Compiling Go Code..."
+	)
+	add_dependencies(zerotier zt_osdep zt_core zt_controller zt_service_io_core)
+
+	install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/zerotier DESTINATION bin)
+
+else(NOT PACKAGE_STATIC)
+
+	if(BUILD_32BIT)
+		set(CMAKE_SYSTEM_PROCESSOR "x86" CACHE STRING "system processor")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32" CACHE STRING "c++ flags")
+		set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -m32" CACHE STRING "c flags")
+		add_compile_options(
+			-m32
+		)
+	endif(BUILD_32BIT)
+
+	set(STATIC_BINARY ${CMAKE_BINARY_DIR}/zerotier)
+	set(IMPORTED_LOCATION ${CMAKE_BINARY_DIR})
+	add_executable(zerotier IMPORTED GLOBAL)
+	install(PROGRAMS ${STATIC_BINARY} DESTINATION bin)
+
+endif(NOT PACKAGE_STATIC)
+
+# Linux packaging
+
+if("${CMAKE_SYSTEM_NAME}" EQUAL "Linux")
+	if(IS_DIRECTORY /lib/systemd/system)
+		install(
+			FILES ${CMAKE_CURRENT_SOURCE_DIR}/packaging/debian/zerotier.service
+			DESTINATION /lib/systemd/system
+		)
+	elseif(IS_DIRECTORY /usr/lib/systemd/system)
+		install(
+			FILES ${CMAKE_CURRENT_SOURCE_DIR}/packaging/debian/zerotier.service
+			DESTINATION /usr/lib/systemd/system
+		)
+	else()
+		install(
+			FILES ${CMAKE_CURRENT_SOURCE_DIR}/packaging/debian/zerotier.init
+			DESTINATION /etc/init.d
+		)
+	endif()
+endif()
+
+if("${ZT_PACKAGE_FORMAT}" MATCHES "DEB")
+	include(packaging/debian.cmake)
+elseif("${ZT_PACKAGE_FORMAT}" MATCHES "RPM")
+	include(packaging/rpm.cmake)
+else()
+endif()

COPYING

@@ -1,5 +1,5 @@
 ZeroTier One, an endpoint server for the ZeroTier virtual network layer.
-Copyright © 2011–2019 ZeroTier, Inc.
+Copyright © 2013–2020 ZeroTier, Inc.
 
 ZeroTier is released under the terms of the BSL version 1.1. See the
 file LICENSE.txt for details.

Jenkinsfile

@@ -7,6 +7,9 @@ pipeline {
     parameters {
         booleanParam(name: "BUILD_ALL", defaultValue: false, description: "Build all supported platform/architecture combos.  Defaults to x86/x64 only")
     }
+    environment {
+        PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
+    }
     
     agent none
     
@@ -18,7 +21,10 @@ pipeline {
                     tasks << buildStaticBinaries()
                     tasks << buildDebianNative()
                     tasks << buildCentosNative()
-                    
+                    tasks << buildMacOS()
+                    tasks << buildWindows()
+                    tasks << buildFreeBSD()
+
                     parallel tasks
                 }
             }
@@ -33,12 +39,81 @@ pipeline {
     }
 }
 
+def buildMacOS() {
+    def tasks = [:]
+    tasks << getTasks(['mac'],['amd64'], {unused1, unused2 ->
+        def myNode = {
+            env.PATH = env.PATH + ":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
+            node ('mac') {
+                dir("build") {
+                    checkout scm
+                    sh 'make'
+                }
+                cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
+            }
+        }
+        return myNode
+    })
+    return tasks
+}
+
+def buildWindows() {
+    def tasks = [:]
+    tasks << getTasks(['windows'], ['amd64', 'i386'], { unused1, platform ->
+        def myNode = {
+            node ('windows') {
+                env.SHELL = 'C:/Windows/System32/cmd.exe'
+                dir ("build") {
+                    checkout scm
+                    
+                    dir ("build") {
+                        withEnv(["PATH=C:\\TDM-GCC-64\\bin;C:\\WINDOWS;C:\\Windows\\system32;C:\\CMake\\bin;C:\\Go\\bin"]) {
+                            def cmakeFlags = ""
+                            if (platform == "i386") {
+                                cmakeFlags = '-DBUILD_32BIT=1'
+                            }
+                            bat """
+                            cmake -G"MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release ${cmakeFlags} ..
+                            mingw32-make -j8
+                            """
+                        }
+                    }
+                    cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
+                }
+            }
+        }
+        return myNode
+    })
+
+    return tasks
+}
+
+def buildFreeBSD() {
+    def tasks = [:]
+    tasks << getTasks(['freebsd12'], ['amd64'], { unused1, unused2 ->
+        def myNode = {
+            node ('freebsd12') {
+                dir('build') {
+                    checkout scm
+                    sh 'make setup'
+                    dir('build') {
+                        sh 'make -j4'
+                    }
+                }
+                cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
+            }
+        }
+        return myNode
+    })
+    return tasks
+}
+
 def buildStaticBinaries() {
     def tasks = [:]
     def dist = ["alpine"]
     def archs = []
     if (params.BUILD_ALL == true) {
-        archs = ["arm64", "amd64", "i386", "armhf", "armel", "ppc64le", "s390x"]
+        archs = ["arm64", "amd64", "i386", "armhf", "ppc64le", "s390x"]
     } else {
         archs = ["amd64", "i386"]
     }
@@ -46,17 +121,26 @@ def buildStaticBinaries() {
     tasks << getTasks(dist, archs, { distro, platform -> 
         def myNode = {
             node ('linux-build') {
+                env.PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
                 dir ("build") {
                     checkout scm
                 }
-                sh "echo ${distro}-${platform}"
                 def runtime = docker.image("ztbuild/${distro}-${platform}:latest")
                 runtime.inside {
                     dir("build") {
-                        sh 'make -j8 ZT_STATIC=1 all'
-                        sh "file ./zerotier-one"
-                        sh "mv zerotier-one zerotier-one-static-${platform}"
-                        stash includes: 'zerotier-one-static-*', name: "static-${platform}"
+
+                        def cmakeFlags = 'CMAKE_ARGS="-DBUILD_STATIC=1"'
+                        if (platform == "i386") {
+                            cmakeFlags = 'CMAKE_ARGS="-DBUILD_STATIC=1"'
+                        } else if (platform == "armhf") {
+                            cmakeFlags = 'CMAKE_ARGS="-DBUILD_STATIC=1 -DBUILD_ARM_V6=1"'
+                        }
+                   
+                        sh "${cmakeFlags} make"
+                        dir("build") {
+                            sh "mv zerotier zerotier-static-${platform}"
+                            stash includes: 'zerotier-static-*', name: "static-${platform}"
+                        }
                     }
                     cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
                 }
@@ -82,37 +166,13 @@ def getTasks(axisDistro, axisPlatform, task) {
 
 def packageStatic() {
     def tasks = [:]
-    
-    def centos6 = ["centos6"]
-    def centos6Arch = ["i386", "amd64"]
-    tasks << getTasks(centos6, centos6Arch, { distro, arch -> 
-        def myNode = {
-            node ('linux-build') {
-                dir ("build") {
-                    checkout scm
-                }
-                def runtime = docker.image("ztbuild/${distro}-${arch}:latest")
-                runtime.inside {
-                    dir("build") {
-                        unstash "static-${arch}"
-                        sh "mv zerotier-one-static-${arch} zerotier-one && chmod +x zerotier-one" 
-                        sh "make redhat"
-                        sh "mkdir -p ${distro}"
-                        sh "cp -av `find ~/rpmbuild/ -type f -name \"*.rpm\"` ${distro}/"
-                        archiveArtifacts artifacts: "${distro}/*.rpm", onlyIfSuccessful: true
-                    }
-                }
-                cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
-            }
-        }
-        return myNode
-    })
-    
+        
     def centos7 = ["centos7"]
     def centos7Arch = ["i386"]
     tasks << getTasks(centos7, centos7Arch, { distro, arch -> 
         def myNode = {
             node ('linux-build') {
+                env.PATH = env.PATH + ":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
                 dir ("build") {
                     checkout scm
                 }
@@ -120,10 +180,14 @@ def packageStatic() {
                 runtime.inside {
                     dir("build") {
                         unstash "static-${arch}"
-                        sh "mv zerotier-one-static-${arch} zerotier-one && chmod +x zerotier-one" 
-                        sh "make redhat"
+                        sh "mkdir -p build"
+                        sh "mv zerotier-static-${arch} build/zerotier && chmod +x build/zerotier" 
+                        sh 'CMAKE_ARGS="-DBUILD_32BIT=1 -DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=RPM" make setup'
+                        dir("build") {
+                            sh 'make package -j4 VERBOSE=1'
+                        }
                         sh "mkdir -p ${distro}"
-                        sh "cp -av `find ~/rpmbuild/ -type f -name \"*.rpm\"` ${distro}/"
+                        sh "cp -av build/*.rpm ${distro}/"
                         archiveArtifacts artifacts: "${distro}/*.rpm", onlyIfSuccessful: true
                     }
                 }
@@ -134,22 +198,31 @@ def packageStatic() {
     })
     
     if (params.BUILD_ALL == true) {
-        def clefos7 = ["clefos"]
-        def clefos7Arch = ["s390x"]
-        tasks << getTasks(clefos7, clefos7Arch, { distro, arch -> 
+        def s390xStatics = ["clefos", "debian-buster", "debian-sid", "debian-bullseye", "debian-stretch", "ubuntu-bionic", "ubuntu-eoan", "ubuntu-focal"]
+        def s390x = ["s390x"]
+        tasks << getTasks(s390xStatics, s390x , { distro, arch -> 
             def myNode = {
                 node ('linux-build') {
+                    env.PATH = env.PATH + ":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
                     dir ("build") {
                         checkout scm
                     }
                     def runtime = docker.image("ztbuild/${distro}-${arch}:latest")
+                    def pkgFormat = "DEB"
+                    if (distro == "clefos") {
+                        pkgFormat = "RPM"
+                    }
                     runtime.inside {
                         dir("build/") {
                             unstash "static-${arch}"
-                            sh "mv zerotier-one-static-${arch} zerotier-one && chmod +x zerotier-one" 
-                            sh "make redhat"
+                            sh "mkdir -p build"
+                            sh "mv zerotier-static-${arch} build/zerotier && chmod +x build/zerotier" 
+                            sh "CMAKE_ARGS=\"-DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=${pkgFormat}\" make setup"
+                            dir("build") {
+                                sh 'make package -j4 VERBOSE=1'
+                            }
                             sh "mkdir -p ${distro}"
-                            sh "cp -av `find ~/rpmbuild/ -type f -name \"*.rpm\"` ${distro}/"
+                            sh "cp -av build/*.rpm ${distro}/"
                             archiveArtifacts artifacts: "${distro}/*.rpm", onlyIfSuccessful: true
                         }
                     }
@@ -163,30 +236,40 @@ def packageStatic() {
     def debianJessie = ["debian-jessie"]
     def debianJessieArchs = []
     if (params.BUILD_ALL == true) {
-        debianJessieArch = ["armhf", "armel", "amd64", "i386"]
+        debianJessieArch = ["armhf", "amd64", "i386"]
     } else {
         debianJessieArch = ["amd64", "i386"]
     }
     tasks << getTasks(debianJessie, debianJessieArch, { distro, arch -> 
         def myNode = {
             node ('linux-build') {
+                env.PATH = env.PATH + ":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
                 dir ("build") {
                     checkout scm
                 }
                 def runtime = docker.image("ztbuild/${distro}-${arch}:latest")
                 runtime.inside {
-                    sh "ls -la ."
                     dir('build/') {
-                        sh "ls -la ."
+                        def cmakeFlags = 'CMAKE_ARGS="-DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB"'
+                        if (arch == "i386") {
+                            cmakeFlags = 'CMAKE_ARGS="-DBUILD_32BIT=1 -DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB"'
+                        } else if (arch == "armel") {
+                            cmakeFlags = 'CMAKE_ARGS="-DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB -DBUILD_ARM_V5=1"'
+                        } else if (arch == "armhf") {
+                            cmakeFlags = 'CMAKE_ARGS="-DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB -DBUILD_ARM_V6=1"'
+                        }
+                   
                         unstash "static-${arch}"
-                        sh "pwd"
-                        sh "mv zerotier-one-static-${arch} zerotier-one && chmod +x zerotier-one && file ./zerotier-one" 
-                        sh "mv -f debian/rules.static debian/rules"
-                        sh "make debian"
+                        sh "mkdir -p build"
+                        sh "mv zerotier-static-${arch} build/zerotier && chmod +x build/zerotier" 
+                        sh "${cmakeFlags} make setup"
+                        dir("build") {
+                            sh 'make package -j4 VERBOSE=1'
+                        }
+                        sh "mkdir -p ${distro}"
+                        sh "cp -av build/*.deb ${distro}/"
+                        archiveArtifacts artifacts: "${distro}/*.deb", onlyIfSuccessful: true
                     }
-                    sh "mkdir -p ${distro}"
-                    sh "mv *.deb ${distro}"
-                    archiveArtifacts artifacts: "${distro}/*.deb", onlyIfSuccessful: true
                 }
                 cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
             }
@@ -197,30 +280,40 @@ def packageStatic() {
     def ubuntuTrusty = ["ubuntu-trusty"]
     def ubuntuTrustyArch = []
     if (params.BUILD_ALL == true) {
-        ubuntuTrustyArch = ["i386", "amd64", "armhf", "arm64", "ppc64le"]
+        ubuntuTrustyArch = ["i386", "amd64", "arm64", "ppc64le"]
     } else {
         ubuntuTrustyArch = ["i386", "amd64"]
     }
     tasks << getTasks(ubuntuTrusty, ubuntuTrustyArch, { distro, arch -> 
         def myNode = {
             node ('linux-build') {
+                env.PATH = env.PATH + ":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
                 dir ("build") {
                     checkout scm
                 }
                 def runtime = docker.image("ztbuild/${distro}-${arch}:latest")
                 runtime.inside {
-                    sh "ls -la ."
                     dir('build/') {
-                        sh "ls -la ."
+                        def cmakeFlags = 'CMAKE_ARGS="-DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB"'
+                        if (arch == "i386") {
+                            cmakeFlags = 'CMAKE_ARGS="-DBUILD_32BIT=1 -DBUILD_STATIC=1 -DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB"'
+                        } else if (arch == "armel") {
+                            cmakeFlags = 'CMAKE_ARGS="-DBUILD_STATIC=1 -DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB -DBUILD_ARM_V5=1"'
+                        } else if (arch == "armhf") {
+                            cmakeFlags = 'CMAKE_ARGS="-DBUILD_STATIC=1 -DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB -DBUILD_ARM_V6=1"'
+                        }
+
                         unstash "static-${arch}"
-                        sh "pwd"
-                        sh "mv zerotier-one-static-${arch} zerotier-one && chmod +x zerotier-one && file ./zerotier-one" 
-                        sh "mv -f debian/rules.static debian/rules"
-                        sh "make debian"
+                        sh "mkdir -p build"
+                        sh "mv zerotier-static-${arch} build/zerotier && chmod +x build/zerotier" 
+                        sh "${cmakeFlags} make setup"
+                        dir("build") {
+                            sh 'make package -j4 VERBOSE=1'
+                        }
+                        sh "mkdir -p ${distro}"
+                        sh "cp -av build/*.deb ${distro}/"
+                        archiveArtifacts artifacts: "${distro}/*.deb", onlyIfSuccessful: true
                     }
-                    sh "mkdir -p ${distro}"
-                    sh "mv *.deb ${distro}"
-                    archiveArtifacts artifacts: "${distro}/*.deb", onlyIfSuccessful: true
                 }
                 cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
             }
@@ -231,28 +324,39 @@ def packageStatic() {
     def debianWheezy = ["debian-wheezy"]
     def debianWheezyArchs = []
     if (params.BUILD_ALL == true) {
-        debianWheezyArchs = ["armhf", "armel", "amd64", "i386"]
+        debianWheezyArchs = ["armhf", "amd64", "i386"]
     } else {
         debianWheezyArchs = ["amd64", "i386"]
     }
     tasks << getTasks(debianJessie, debianJessieArch, { distro, arch -> 
         def myNode = {
             node ('linux-build') {
+                env.PATH = env.PATH + ":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
                 dir ("build") {
                     checkout scm
                 }
                 def runtime = docker.image("ztbuild/${distro}-${arch}:latest")
                 runtime.inside {
                     dir('build/') {
+                        def cmakeFlags = 'CMAKE_ARGS="-DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB"'
+                        if (arch == "i386") {
+                            cmakeFlags = 'CMAKE_ARGS="-DBUILD_32BIT=1 -DBUILD_STATIC=1 -DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB"'
+                        } else if (arch == "armel") {
+                            cmakeFlags = 'CMAKE_ARGS="-DBUILD_STATIC=1 -DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB -DBUILD_ARM_V5=1"'
+                        } else if (arch == "armhf") {
+                            cmakeFlags = 'CMAKE_ARGS="-DBUILD_STATIC=1 -DPACKAGE_STATIC=1 -DZT_PACKAGE_FORMAT=DEB -DBUILD_ARM_V6=1"'
+                        }
                         unstash "static-${arch}"
-                        sh "mv zerotier-one-static-${arch} zerotier-one && chmod +x zerotier-one && file ./zerotier-one" 
-                        sh "mv -f debian/rules.wheezy.static debian/rules"
-                        sh "mv -f debian/control.wheezy debian/control"
-                        sh "make debian"
+                        sh "mkdir -p build"
+                        sh "mv zerotier-static-${arch} build/zerotier && chmod +x build/zerotier" 
+                        sh "${cmakeFlags} make setup"
+                        dir("build") {
+                            sh 'make package -j4 VERBOSE=1'
+                        }
+                        sh "mkdir -p ${distro}"
+                        sh "cp -av build/*.deb ${distro}/"
+                        archiveArtifacts artifacts: "${distro}/*.deb", onlyIfSuccessful: true
                     }
-                    sh "mkdir -p ${distro}"
-                    sh "mv *.deb ${distro}"
-                    archiveArtifacts artifacts: "${distro}/*.deb", onlyIfSuccessful: true
                 }
                 cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
             }
@@ -265,27 +369,40 @@ def packageStatic() {
 
 def buildDebianNative() {
     def tasks = [:]
-    def buster = ["debian-buster", "debian-stretch", "debian-bullseye", "debian-sid"]
-    def busterArchs = []
+    def debian = ["debian-buster" , "debian-stretch", "debian-sid", "debian-bullseye"]
+    def debianArchs = []
     if (params.BUILD_ALL) {
-        busterArchs = ["s390x", "ppc64le", "i386", "armhf", "armel", "arm64", "amd64"]
+        debianArchs = ["ppc64le", "i386", "armhf", "armel", "arm64", "amd64"]
     } else {
-        busterArchs = ["amd64", "i386"]
+        debianArchs = ["amd64", "i386"]
     }
     
     def build = { distro, arch -> 
         def myNode = {
             node ('linux-build') {
+                env.PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
                 dir ("build") {
                     checkout scm
                 }
                 def runtime = docker.image("ztbuild/${distro}-${arch}:latest")
                 runtime.inside {
+                    def cmakeFlags = 'CMAKE_ARGS="-DZT_PACKAGE_FORMAT=DEB"'
+                    if (arch == "i386") {
+                        cmakeFlags = 'CMAKE_ARGS="-DBUILD_32BIT=1 -DZT_PACKAGE_FORMAT=DEB"'
+                    } else if (arch == "armel") {
+                        cmakeFlags = 'CMAKE_ARGS="-DZT_PACKAGE_FORMAT=DEB -DBUILD_ARM_V5=1"'
+                    } else if (arch == "armhf") {
+                        cmakeFlags = 'CMAKE_ARGS="-DZT_PACKAGE_FORMAT=DEB -DBUILD_ARM_V6=1"'
+                    }
+                   
                     dir("build") {
-                        sh 'make debian'
+                        sh "${cmakeFlags} make setup"
+                        dir("build") {
+                            sh "make package -j4 VERBOSE=1"
+                        }
                     }
                     sh "mkdir -p ${distro}"
-                    sh "mv *.deb ${distro}"
+                    sh "mv build/build/*.deb ${distro}"
                     archiveArtifacts artifacts: "${distro}/*.deb", onlyIfSuccessful: true
                     cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
                 }
@@ -294,8 +411,8 @@ def buildDebianNative() {
         return myNode
     }
     
-    tasks << getTasks(buster, busterArchs, build)
-    
+    tasks << getTasks(debian, debianArchs, build)
+ 
     // bash is broken when running under QEMU-s390x on Xenial
     def xenial = ["ubuntu-xenial"]
     def xenialArchs = []
@@ -309,12 +426,21 @@ def buildDebianNative() {
     def ubuntu = ["ubuntu-bionic", "ubuntu-eoan"]
     def ubuntuArchs = []
     if (params.BUILD_ALL == true) {
-        ubuntuArchs = ["i386", "amd64", "armhf", "arm64", "ppc64le", "s390x"]
+        ubuntuArchs = ["i386", "amd64", "armhf", "arm64", "ppc64le"]
     } else {
         ubuntuArchs = ["i386", "amd64"]
     }
     tasks << getTasks(ubuntu, ubuntuArchs, build)
     
+    def ubuntuFocal = ["ubuntu-focal"]
+    def ubuntuFocalArchs = []
+    if (params.BUILD_ALL == true) {
+        ubuntuFocalArchs = ["amd64", "arm64", "ppc64le"]
+    } else {
+        ubuntuFocalArchs = ["amd64"]
+    }
+    tasks << getTasks(ubuntuFocal, ubuntuFocalArchs, build)
+
     def kali = ["kali-rolling"]
     def kaliArchs = ["amd64"]
     tasks << getTasks(kali, kaliArchs, build)
@@ -328,18 +454,29 @@ def buildCentosNative() {
     def build = { distro, arch -> 
         def myNode = {
             node ('linux-build') {
+                env.PATH = env.PATH + ":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/home/jenkins-build/go/bin"
                 dir ("build") {
                     checkout scm
                 }
                 def runtime = docker.image("ztbuild/${distro}-${arch}:latest")
                 runtime.inside {
                     dir("build") {
-                        sh 'make -j4'
-                        sh 'make redhat'
-                        sh "mkdir -p ${distro}"
-                        sh "cp -av `find ~/rpmbuild/ -type f -name \"*.rpm\"` ${distro}/"
-                        archiveArtifacts artifacts: "${distro}/*.rpm", onlyIfSuccessful: true
+                        if (distro == 'centos7' && arch == 'amd64') {
+                            sh 'source scl_source enable devtoolset-8 llvm-toolset-7 && CMAKE_ARGS="-DZT_PACKAGE_FORMAT=RPM" make setup'
+                        } else {
+                            sh 'CMAKE_ARGS="-DZT_PACKAGE_FORMAT=RPM" make setup'
+                        }
+                        dir ("build") {
+                            if (distro == 'centos7' && arch == 'amd64') {
+                                sh 'source scl_source enable devtoolset-8 llvm-toolset-7 && make package -j4 VERBOSE=1'
+                            } else {
+                                sh 'make package -j4 VERBOSE=1'
+                            }
+                        }
                     }
+                    sh "mkdir -p ${distro}"
+                    sh "cp -av build/build/*.rpm ${distro}/"
+                    archiveArtifacts artifacts: "${distro}/*.rpm", onlyIfSuccessful: true
                     
                     cleanWs deleteDirs: true, disableDeferredWipeout: true, notFailBuild: true
                 }

LICENSE.txt

@@ -10,8 +10,8 @@ License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
 Parameters
 
 Licensor:             ZeroTier, Inc.
-Licensed Work:        ZeroTier Network Virtualization Engine 1.4.4
-                      The Licensed Work is (c)2019 ZeroTier, Inc.
+Licensed Work:        ZeroTier Network Virtualization Engine
+                      The Licensed Work is (c)2013-2020 ZeroTier, Inc.
 Additional Use Grant: You may make use of the Licensed Work, provided you
                       do not use it in any of the following ways:
 
@@ -26,7 +26,7 @@ Additional Use Grant: You may make use of the Licensed Work, provided you
                       ZeroTier behind the scenes to operate a service not
                       related to ZeroTier network administration.
 
-                      * Create Non-Open-Source Commercial Derviative Works
+                      * Create Non-Open-Source Commercial Derivative Works
 
                       (2) Link or directly include the Licensed Work in a
                       commercial or for-profit application or other product
@@ -47,7 +47,7 @@ Additional Use Grant: You may make use of the Licensed Work, provided you
                       services, social welfare, senior care, child care, and
                       the care of persons with disabilities.
 
-Change Date:          2023-01-01
+Change Date:          2025-01-01
 
 Change License:       Apache License version 2.0 as published by the Apache
                       Software Foundation

Makefile

@@ -1,28 +1,31 @@
-# Common makefile -- loads make rules for each platform
+BUILDDIR := build
+TIMESTAMP=$(shell date +"%Y%m%d%H%M")
 
-OSTYPE=$(shell uname -s)
+.PHONY: all
 
-ifeq ($(OSTYPE),Darwin)
-	include make-mac.mk
-endif
+all:	setup
+	cd ${BUILDDIR} && $(MAKE) -j4 VERBOSE=1
 
-ifeq ($(OSTYPE),Linux)
-	include make-linux.mk
-endif
+setup:
+	mkdir -p ${BUILDDIR} && cd ${BUILDDIR} && cmake .. -DCMAKE_BUILD_TYPE=Release ${CMAKE_ARGS}
 
-ifeq ($(OSTYPE),FreeBSD)
-	CC=clang
-	CXX=clang++
-	ZT_BUILD_PLATFORM=7
-	include make-bsd.mk
-endif
-ifeq ($(OSTYPE),OpenBSD)
-	CC=egcc
-	CXX=eg++
-	ZT_BUILD_PLATFORM=9
-	include make-bsd.mk
-endif
+setup-debug:
+	mkdir -p ${BUILDDIR} && cd ${BUILDDIR} && cmake .. -DCMAKE_BUILD_TYPE=Debug ${CMAKE_ARGS}
 
-ifeq ($(OSTYPE),NetBSD)
-	include make-netbsd.mk
-endif
+debug:
+	mkdir -p ${BUILDDIR} && cd ${BUILDDIR} && cmake .. -DCMAKE_BUILD_TYPE=Debug ${CMAKE_ARGS} && $(MAKE)
+
+central-controller:
+	mkdir -p ${BUILDDIR} && cd ${BUILDDIR} && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_CENTRAL_CONTROLLER=1 ${CMAKE_ARGS} && $(MAKE) -j4
+
+central-controller-debug:
+	mkdir -p ${BUILDDIR} && cd ${BUILDDIR} && cmake .. -DCMAKE_BUILD_TYPE=Debug -DBUILD_CENTRAL_CONTROLLER=1 ${CMAKE_ARGS}  && $(MAKE) -j4
+
+central-controller-docker:
+	docker build -t registry.zerotier.com/zerotier-central/ztcentral-controller:${TIMESTAMP} -f controller/central-docker/Dockerfile .
+
+clean:
+	rm -rf ${BUILDDIR}
+
+distclean:
+	rm -rf ${BUILDDIR}

RELEASE-NOTES.md

@@ -1,6 +1,43 @@
 ZeroTier Release Notes
 ======
 
+# Version 1.9.0 (2.0 beta)
+
+Version 2.0 is a very significant release with many changes. It remains backward compatibility to version 1.4.0 (and possibly earlier versions but this is not guaranteed) but makes numerous local and behavioral changes that should be reviewed before upgrading production systems.
+
+After this release we're going to be working to get to a more frequent, less extreme, more "agile" release cadence.
+
+Protocol changes:
+
+ * Trusted paths have been completely removed. The new AES mode is so fast on CPUs with AES acceleration that much of the rationale for this is gone, and this feature was never used much to begin with due to inconvenience and obvious security concerns. Environments using trusted paths will need to upgrade all nodes at once.
+ * The symmetric encryption algorithm and mode is now AES-GMAC-SIV, a variation of AES-GCM using the same primitives but offering superior security bounds and behavior under non-ideal conditions. It's also a lot faster than Salsa20/12 and Poly1305 on CPUs with AES acceleration (almost all desktops, laptops, and newer routers and phones). Salsa20/12 with Poly1305 is still supported for communication with older versions and small devices that lack AES acceleration.
+ * A new identity type (1) has been introduced that contains both Curve25519 and NIST P-384 public key types, but classic type 0 remains the default for new identities for now. ECDH key agreement between V1 identities uses both keys and hashes the resulting secrets to yield security equal to the best of the two, but V1 identities can also agree with V0 identities using only their Curve25519 component.
+ * Roots can now be joined and left like networks in a much more convenient way, and the old "moon" and "planet" terminology is deprecated.
+ * A new peer to peer multicast algorithm has been introduced that offers much better scalability and better performance, especially when the physical network itself is hub-and-spoke with many low latency peers connected by higher latency WAN links.
+ * Forward secrecy is finally supported via periodic re-keying using ephemeral asymmetric keys. Both Curve25519 and NIST P-384 keys are used with secrets being hashed to provide security equal to the stronger of the two curves.
+ * As part of forward secrecy implementation peers now always exchange HELLO messages even if they don't have a direct path.
+ * Compression is only enabled for control packets as almost all data packets are largely un-compressable.
+ * New NAT traversal tricks have been added, such as (ab)use of port 500.
+
+Code changes:
+
+ * Migrated from GNU make to cmake for easier cross platform builds and simplified build files.
+ * The core network hypervisor has been significantly refactored, almost amounting to a partial rewrite.
+ * Critical packet handling paths have been streamlined with unnecessary memcpy() steps removed.
+ * Host service code has been completely rewritten in Go. Packet handling code remains in C++, but Go offers superior developer productivity when it comes to implementing more complex local service and local API features. Go imposes a little bit more memory overhead but not much and has been tuned to minimize memory use.
+
+User interface:
+
+ * Command line interface has been redesigned and rewritten. Old commands names are supported but their output will be different.
+
+Other things:
+
+ * The V2 design, protocol, and cryptographic primitives (AES-GMAC-SIV) have been security audited by [Trail of Bits](https://www.trailofbits.com), and the code is being audited as well prior to full 2.0 release.
+
+---
+
+# Older version release notes
+
 # 2019-08-30 -- Version 1.4.6
 
  * Update default root list to latest

attic/PeerList.hpp

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c)2013-2020 ZeroTier, Inc.
+ *
+ * Use of this software is governed by the Business Source License included
+ * in the LICENSE.TXT file in the project's root directory.
+ *
+ * Change Date: 2025-01-01
+ *
+ * On the date above, in accordance with the Business Source License, use
+ * of this software will be governed by version 2.0 of the Apache License.
+ */
+/****/
+
+#ifndef ZT_PEERLIST_HPP
+#define ZT_PEERLIST_HPP
+
+#include "Constants.hpp"
+#include "SharedPtr.hpp"
+#include "Peer.hpp"
+
+namespace ZeroTier {
+
+/**
+ * A list of peers
+ *
+ * This is a simple vector optimized for the case where there will almost always
+ * be zero or one element. In that case it doesn't allocate. If there's more than
+ * one element, it will grow to include all elements.
+ *
+ * It's used to return lookups in Topology where there will almost always be zero
+ * or one peers returned but where there technically (but very rarely) can be more.
+ */
+class PeerList
+{
+public:
+	ZT_INLINE PeerList() noexcept:
+		m_onePeer(),
+		m_peers(&m_onePeer),
+		m_peerCount(0)
+	{}
+
+	ZT_INLINE PeerList(const PeerList &pl)
+	{
+		const unsigned int pc = pl.m_peerCount;
+		if (likely(pc <= 1)) {
+			m_onePeer = pl.m_onePeer;
+			m_peers = &m_onePeer;
+		} else {
+			m_peers = new SharedPtr<Peer>[pc];
+			for (unsigned int i = 0;i < pc;++i)
+				m_peers[i] = pl.m_peers[i];
+		}
+		m_peerCount = pc;
+	}
+
+	ZT_INLINE ~PeerList()
+	{
+		if (unlikely(m_peers != &m_onePeer))
+			delete[] m_peers;
+	}
+
+	ZT_INLINE PeerList &operator=(const PeerList &pl)
+	{
+		if (&pl != this) {
+			if (unlikely(m_peers != &m_onePeer))
+				delete[] m_peers;
+			if (likely(pl.m_peerCount <= 1)) {
+				m_onePeer = pl.m_onePeer;
+				m_peers = &m_onePeer;
+			} else {
+				m_onePeer.zero();
+				m_peers = new SharedPtr<Peer>[pl.m_peerCount];
+				for (unsigned int i = 0;i < pl.m_peerCount;++i)
+					m_peers[i] = pl.m_peers[i];
+			}
+			m_peerCount = pl.m_peerCount;
+		}
+		return *this;
+	}
+
+	/**
+	 * Resize the peer list to store a given number of members
+	 *
+	 * To populate the list, this must be called first followed by each member
+	 * being set with the [] operator. List content after this call is undefined
+	 * and may contain old data if the object is being re-used.
+	 *
+	 * @param s New size of list
+	 */
+	ZT_INLINE void resize(const unsigned int s)
+	{
+		if (unlikely(m_peers != &m_onePeer))
+			delete[] m_peers;
+		m_peerCount = s;
+		if (likely(s <= 1)) {
+			m_peers = &m_onePeer;
+		} else {
+			m_peers = new SharedPtr<Peer>[s];
+		}
+	}
+
+	ZT_INLINE SharedPtr <Peer> &operator[](const unsigned int i) noexcept
+	{ return m_peers[i]; }
+
+	ZT_INLINE const SharedPtr <Peer> &operator[](const unsigned int i) const noexcept
+	{ return m_peers[i]; }
+
+	ZT_INLINE unsigned int size() const noexcept
+	{ return m_peerCount; }
+
+private:
+	SharedPtr <Peer> m_onePeer;
+	SharedPtr <Peer> *m_peers;
+	unsigned int m_peerCount;
+};
+
+} // namespace ZeroTier
+
+#endif