Merge pull request #290 from Faless/fix/disable_zlib_detection

ssh2: Disable zlib detection

.gitattributes

@@ -1,14 +1,2 @@
 # Normalize EOL for all files that Git considers text files.
 * text=auto eol=lf
-
-# Ignore some files when exporting to a ZIP.
-/.github/           			export-ignore
-/godot-cpp/           			export-ignore
-/godot-git-plugin/           	export-ignore
-/thirdparty/           			export-ignore
-/.gitattributes     			export-ignore
-/.gitignore         			export-ignore
-/.gitmodules         			export-ignore
-/api.ci.json         			export-ignore
-/build_openssl_universal_oxs.sh	export-ignore
-/SConstruct						export-ignore

.github/workflows/build.yml

@@ -2,59 +2,93 @@ name: C/C++ CI
 
 on: [push, pull_request]
 
+env:
+  # Only used for the cache key. Increment version to force clean build.
+  GODOT_BASE_BRANCH: master
+  SCONS_CACHE: ${{ github.workspace }}/.scons-cache/
+
 jobs:
   linux-x64:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v2
-      - name: build-linux-editor-x64
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Setup Godot build cache
+        uses: ./godot-cpp/.github/actions/godot-cache
+        with:
+          cache-name: linux-x86_64
+        continue-on-error: true
+      - name: Build for Linux editor x86_64
         run: |
-          git submodule update --init --recursive
-          pip3 install --user scons
-          scons platform=linux target=editor generate_bindings=yes -j $(nproc)
-          ldd demo/addons/godot-git-plugin/linux/*.so
-      - uses: actions/upload-artifact@v2
+          pip3 install scons
+          scons platform=linux arch=x86_64 target=editor generate_bindings=yes
+          ldd addons/godot-git-plugin/linux/*.so
+      - name: Prepare artifact
+        run: |
+          mkdir out
+          mv addons out/
+      - uses: actions/upload-artifact@v4
         with:
           name: libgit_plugin.linux.x86_64.editor.so-${{ github.sha }}
           if-no-files-found: error
           path: |
-            demo/
+            out/
 
   windows-x64:
-    runs-on: windows-2019
+    runs-on: windows-2022
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - uses: actions/checkout@v4
         with:
-          python-version: "3.x"
-          architecture: "x64"
-      - uses: ilammy/msvc-dev-cmd@v1
-      - name: build-windows-editor-x64
+          submodules: recursive
+      - name: Setup Godot build cache
+        uses: ./godot-cpp/.github/actions/godot-cache
+        with:
+          cache-name: windows-x86_64
+      - uses: ilammy/msvc-dev-cmd@v1  # For dumpbin.
+      - uses: ilammy/setup-nasm@v1
+      - name: Build for Windows editor x86_64
+        shell: powershell
         run: |
-          git submodule update --init --recursive
-          pip3 install --user scons
-          scons platform=windows target=editor generate_bindings=yes -j $env:NUMBER_OF_PROCESSORS
-          dumpbin /dependents .\demo\addons\godot-git-plugin\win64\*.dll
-      - uses: actions/upload-artifact@v2
+          pip3 install scons
+          scons platform=windows arch=x86_64 target=editor generate_bindings=yes
+          dumpbin /dependents .\addons\godot-git-plugin\windows\*.dll
+      - name: Prepare artifact
+        shell: bash
+        run: |
+          # Not needed to use the plugin.
+          rm -f addons/godot-git-plugin/windows/*.{exp,lib}
+          mkdir out
+          mv addons out/
+      - uses: actions/upload-artifact@v4
         with:
           name: libgit_plugin.windows.x86_64.editor.dll-${{ github.sha }}
           if-no-files-found: error
           path: |
-            demo/
+            out/
 
   macos-universal:
-    runs-on: macos-11
+    runs-on: macos-15
     steps:
-      - uses: actions/checkout@v2
-      - name: build-macos-editor-universal
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Setup Godot build cache
+        uses: ./godot-cpp/.github/actions/godot-cache
+        with:
+          cache-name: macos-universal
+      - name: Build for macOS editor universal
         run: |
-          git submodule update --init --recursive
-          brew install scons
-          scons platform=macos target=editor generate_bindings=yes macos_arch=universal use_llvm=yes macos_deployment_target=10.13 -j $(sysctl -n hw.logicalcpu)
-          otool -L demo/addons/godot-git-plugin/macos/*.dylib
-      - uses: actions/upload-artifact@v2
+          pip install scons
+          scons platform=macos arch=universal target=editor generate_bindings=yes macos_deployment_target=10.13
+          otool -L addons/godot-git-plugin/macos/*.dylib
+      - name: Prepare artifact
+        run: |
+          mkdir out
+          mv addons out/
+      - uses: actions/upload-artifact@v4
         with:
           name: libgit_plugin.macos.universal.editor.dylib-${{ github.sha }}
           if-no-files-found: error
           path: |
-            demo/
+            out/

.github/workflows/clang-format.yml

@@ -7,9 +7,9 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
-      - uses: DoozyX/clang-format-lint-action@v0.11
+      - uses: actions/checkout@v4
+      - uses: DoozyX/clang-format-lint-action@v0.18.2
         with:
           source: "godot-git-plugin/src"
           extensions: "h,cpp"
-          clangFormatVersion: 11
+          clangFormatVersion: 18

.gitignore

@@ -1,9 +1,6 @@
 # SConstruct db
 *.dblite
 
-# Godot ignores
-demo/.godot/
-
 # Godot Serialisations
 extension_api.json
 !/ci/extension_api.json
@@ -17,7 +14,11 @@ extension_api.json
 # Mac stuff
 .DS_Store
 
+# Vim
+*.swp
+
 # Binaries
+__pycache__/
 build/
 bin/
 macos/
@@ -29,4 +30,8 @@ win64/
 *.os
 *.ilk
 *.pdb
-!thirdparty/openssl/*
+*.pyc
+*.zip
+
+# Misc
+*.log

.gitmodules

@@ -2,9 +2,13 @@
 	path = godot-cpp
 	url = https://github.com/godotengine/godot-cpp
 	branch = 3.x
-[submodule "libgit2"]
+[submodule "thirdparty/git2/libgit2"]
 	path = thirdparty/git2/libgit2
 	url = https://github.com/libgit2/libgit2
+	ignore = untracked
 [submodule "thirdparty/ssh2/libssh2"]
 	path = thirdparty/ssh2/libssh2
 	url = https://github.com/libssh2/libssh2
+[submodule "thirdparty/openssl"]
+	path = thirdparty/openssl
+	url = https://github.com/openssl/openssl

README.md

@@ -6,37 +6,28 @@
 
 Git implementation of the Godot Engine VCS interface in Godot. We use [libgit2](https://libgit2.org) as our backend to simulate Git in code.
 
-> Planned for the upcoming version of Godot. Look for other branches for support in other Godot releases.
+## Installation
 
-## Installation Instructions
-
-1.  Grab the platform binaries here: <https://github.com/godotengine/godot-git-plugin/releases>
+1.  Grab the platform binaries here: https://github.com/godotengine/godot-git-plugin/releases
 2.  Then read the installation instructions: https://github.com/godotengine/godot-git-plugin/wiki
 
-## Build Instructions
+## Build
 
 This section onwards is only meant to be used if you intend to compile the plugin from source.
 
-### Required Tools
+### Required tools
 
-- Full copy of the source code. Remember to use `git clone --recursive`.
-- [SCons](https://scons.org/pages/download.html) (v3.0.1+)
+- Full copy of the source code. Remember to use `git clone --recursive`, or initialize submodules with `git submodule update --init`.
+- [SCons](https://scons.org/pages/download.html) (v3.1.2+), CMake, and Perl.
 - C++17 and C90 compilers detectable by SCons and present in `PATH`.
-- Platforms Specific Setup
-  - Windows
-    - No extra steps required other than setting up the compilers.
-  - MacOS
-    - For making universal builds targeting both Apple Silicon and x86_64, you can optionally run `build_openssl_universal_macos.sh` to build OpenSSL yourself and replace the already prebuilt libraries provided inside `thirdparty/openssl/`, otherwise, just run `brew install openssl@1.1` to use the prebuilt libraries provided in this repository.
-  - Linux
-    - Run `sudo apt-get install libssl-dev`, or your local package manager's equivalent.
 
-### Release Build
+### Release build
 
 ```
-scons platform=<platform> target=editor -j 6
+scons platform=<platform> target=editor
 ```
 
-> You may get the gdextension dump yourself from Godot using the instructions in the next section, or use the ones provided in `godot-cpp/gdextension` or `ci/`.
+> You may get the GDExtension dump yourself from Godot using the instructions in the next section, or use the ones provided in `godot-cpp`.
 
 For more build options, run `scons platform=<platform> -h`
 
@@ -49,19 +40,18 @@ If you need to use a custom GDExtension API:
 1. Dump the new bindings from the custom Godot build.
 
 ```shell
-cd local/copy/of/godot/source
-.\bin\godot.xxx --headless --dump-gdextension-interface --dump-extension-api
+./path/to/godot/bin/godot.<platform>.editor.<arch> --headless --dump-gdextension-interface --dump-extension-api
 ```
 
 2. Build the plugin along with the godot-cpp library.
 
 ```
-scons platform=<platform> target=editor generate_bindings=yes dev_build=yes -j 6
+scons platform=<platform> target=editor generate_bindings=yes dev_build=yes
 ```
 
 > You only need to build godot-cpp once every change in the GDExtension API, hence, `generate_bindings=yes` should only be passed in during the first time after generating a new GDExtension API dump.
 
-3. Open the project provided inside `demo/` in the custom Godot build.
+3. To test the plugin, set up a testing project with Godot, and copy or symlink the `addons` folder.
 
 To view more options available while recompiling godot-git-plugin, run `scons platform=<platform> -h`.
 

SConstruct

@@ -2,8 +2,8 @@
 
 import os
 
-EnsureSConsVersion(3, 0, 0)
-EnsurePythonVersion(3, 5)
+EnsureSConsVersion(3, 1, 2)
+EnsurePythonVersion(3, 6)
 
 opts = Variables([], ARGUMENTS)
 
@@ -11,19 +11,9 @@ env = Environment(ENV=os.environ)
 
 # Define our options
 opts.Add(PathVariable("target_path",
-         "The path where the lib is installed.", "demo/addons/godot-git-plugin/"))
+         "The path where the lib is installed.", "addons/godot-git-plugin/"))
 opts.Add(PathVariable("target_name", "The library name.",
          "libgit_plugin", PathVariable.PathAccept))
-opts.Add(PathVariable("macos_openssl", "Path to OpenSSL library root - only used in macOS builds.",
-                      "/usr/local/opt/openssl@1.1/", PathVariable.PathAccept))  # TODO: Find a way to configure this to use the cloned OpenSSL source code, based on `macos_arch`.
-opts.Add(PathVariable("macos_openssl_static_ssl", "Path to OpenSSL libssl.a library - only used in macOS builds.",
-         os.path.join(os.path.abspath(os.getcwd()), "thirdparty/openssl/libssl.a"), PathVariable.PathAccept))
-opts.Add(PathVariable("macos_openssl_static_crypto", "Path to OpenSSL libcrypto.a library - only used in macOS builds.",
-         os.path.join(os.path.abspath(os.getcwd()), "thirdparty/openssl/libcrypto.a"), PathVariable.PathAccept))
-opts.Add(PathVariable("linux_openssl_static_ssl", "Path to OpenSSL libssl.a library - only used in Linux builds.",
-         "/usr/lib/x86_64-linux-gnu/libssl.a", PathVariable.PathAccept))
-opts.Add(PathVariable("linux_openssl_static_crypto", "Path to OpenSSL libcrypto.a library - only used in Linux builds.",
-         "/usr/lib/x86_64-linux-gnu/libcrypto.a", PathVariable.PathAccept))
 
 # Updates the environment with the option variables.
 opts.Update(env)
@@ -33,11 +23,29 @@ if ARGUMENTS.get("custom_api_file", "") != "":
 
 ARGUMENTS["target"] = "editor"
 env = SConscript("godot-cpp/SConstruct").Clone()
+env.PrependENVPath("PATH", os.getenv("PATH"))  # Prepend PATH, done upstream in recent godot-cpp verions.
+
+# Force linking with LTO on windows MSVC, silence the linker complaining that libgit uses LTO but we are not linking with it.
+if env["platform"] == "windows" and env.get("is_msvc", False):
+    env.AppendUnique(LINKFLAGS=["/LTCG"])
+
+# OpenSSL Builder
+env.Tool("openssl", toolpath=["tools"])
+
+# SSH2 Builder
+env.Tool("cmake", toolpath=["tools"])
+env.Tool("ssh2", toolpath=["tools"])
+env.Tool("git2", toolpath=["tools"])
+
 opts.Update(env)
 
-Export("env")
+ssl = env.OpenSSL()
+ssh2 = env.BuildSSH2(ssl)
+ssl += ssh2
+git2 = env.BuildGIT2(ssl)
 
-SConscript("thirdparty/SCsub")
+Export("ssl")
+Export("env")
 
 SConscript("godot-git-plugin/SCsub")
 

THIRDPARTY.md

@@ -5,10 +5,7 @@ The Godot Git Plugin source code uses the following third-party source code:
 1. godotengine/godot-cpp - MIT License - https://github.com/godotengine/godot-cpp/tree/02336831735fd6affbe0a6fa252ec98d3e78120c
 2. libgit2/libgit2 - GPLv2 with a special Linking Exception - https://github.com/libgit2/libgit2/tree/b7bad55e4bb0a285b073ba5e02b01d3f522fc95d
 3. libssh2/libssh2 - BSD-3-Clause License - https://github.com/libssh2/libssh2/tree/635caa90787220ac3773c1d5ba11f1236c22eae8
-
-We also link to these third-party libraries (only in the compiled binary form):
-
-1. OpenSSL - Only on Linux and MacOS - OpenSSL License - http://www.openssl.org/source/openssl-1.1.1s.tar.gz
+4. openssl - OpenSSL License - https://github.com/openssl/openssl/tree/26baecb28ce461696966dac9ac889629db0b3b96
 
 ## License Texts
 

addons/godot-git-plugin/git_plugin.gdextension

@@ -1,11 +1,10 @@
 [configuration]
 
 entry_symbol = "git_plugin_init"
+compatibility_minimum = "4.2.0"
 
 [libraries]
 
-macos.editor = "macos/libgit_plugin.macos.editor.universal.dylib"
-windows.editor.x86_64 = "win64/libgit_plugin.windows.editor.x86_64.dll"
 linux.editor.x86_64 = "linux/libgit_plugin.linux.editor.x86_64.so"
-linux.editor.arm64 = "linux/libgit_plugin.linux.editor.arm64.so"
-linux.editor.rv64 = ""
+macos.editor = "macos/libgit_plugin.macos.editor.universal.dylib"
+windows.editor.x86_64 = "windows/libgit_plugin.windows.editor.x86_64.dll"

build_openssl_universal_macos.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-OPENSSL_VERSION="1.1.1s"
-
-curl -OL http://www.openssl.org/source/openssl-$OPENSSL_VERSION.tar.gz
-tar -xzvf openssl-$OPENSSL_VERSION.tar.gz
-mv openssl-$OPENSSL_VERSION openssl_arm64
-tar -xzvf openssl-$OPENSSL_VERSION.tar.gz
-mv openssl-$OPENSSL_VERSION openssl_x86_64
-cd openssl_arm64
-./Configure darwin64-arm64-cc
-make
-cd ../
-cd openssl_x86_64
-./Configure darwin64-x86_64-cc -mmacosx-version-min=10.13
-make
-cd ../
-lipo -create openssl_arm64/libcrypto.a openssl_x86_64/libcrypto.a -output thirdparty/openssl/libcrypto.a
-lipo -create openssl_arm64/libssl.a openssl_x86_64/libssl.a -output thirdparty/openssl/libssl.a
-rm openssl-$OPENSSL_VERSION.tar.gz

demo/.gitattributes

@@ -1,2 +0,0 @@
-# Normalize EOL for all files that Git considers text files.
-* text=auto eol=lf

demo/.gitignore

@@ -1,2 +0,0 @@
-# Godot 4+ specific ignores
-.godot/

demo/addons/godot-git-plugin/plugin.cfg

@@ -1,7 +0,0 @@
-[plugin]
-
-name="Godot Git Plugin"
-description="This plugin lets you interact with Git without leaving the Godot editor. More information can be found at https://github.com/godotengine/godot-git-plugin/wiki"
-author="twaritwaikar"
-version="v3.0.0-beta1"
-script="godot-git-plugin.gd"

demo/demo.tscn

@@ -1,3 +0,0 @@
-[gd_scene format=3 uid="uid://cr5ci1iwmxnlb"]
-
-[node name="Node3D" type="Node3D"]

demo/new_script.gd

@@ -1,12 +0,0 @@
-extends Node
-
-
-# Called when the node enters the scene tree for the first time.
-func _ready():
-	print("Hello world!")
-	pass # Replace with function body.
-
-
-# Called every frame. 'delta' is the elapsed time since the previous frame.
-func _process(delta):
-	pass

demo/project.godot

@@ -1,22 +0,0 @@
-; Engine configuration file.
-; It's best edited using the editor UI and not directly,
-; since the parameters that go here are not all obvious.
-;
-; Format:
-;   [section] ; section goes between []
-;   param=value ; assign values to parameters
-
-config_version=5
-
-[application]
-
-config/features=PackedStringArray("4.0")
-
-[editor]
-
-version_control/plugin_name="GitPlugin"
-version_control/autoload_on_startup=true
-
-[editor_plugins]
-
-enabled=PackedStringArray()

godot-git-plugin/SCsub

@@ -4,15 +4,7 @@ import os
 
 env = {}
 Import("env")
-
-# Process some arguments
-if env["use_llvm"]:
-    env["CC"] = "clang"
-    env["CXX"] = "clang++"
-
-if env["platform"] == "":
-    print("No valid target platform selected.")
-    quit()
+Import("ssl")
 
 env["target_path"] = "../" + env["target_path"]
 
@@ -20,39 +12,27 @@ if not os.path.isdir(env["target_path"]):
     os.mkdir(env["target_path"])
 
 # Check our platform specifics
+env["target_path"] += env["platform"] + "/"
+
 if env["platform"] == "macos":
-    env["target_path"] += "macos/"
-
-    # Force static linkage (https://stackoverflow.com/a/2995999/7370948)
-    env.Append(LIBS=[File(env["macos_openssl_static_ssl"]),
-                     File(env["macos_openssl_static_crypto"])])
-
     if env["macos_deployment_target"] != "default":
         env.Append(CCFLAGS=["-mmacosx-version-min=" +
                             env["macos_deployment_target"]])
         env.Append(LINKFLAGS=["-mmacosx-version-min=" +
                               env["macos_deployment_target"]])
-
-elif env["platform"] == "linux":
-    env["target_path"] += "linux/"
-    env.Append(LIBS=[File(env["linux_openssl_static_ssl"]),
-                     File(env["linux_openssl_static_crypto"])])
-
 elif env["platform"] == "windows":
-    env["target_path"] += "win64/"
-
     env.Append(LIBS=["advapi32", "winhttp", "rpcrt4", "crypt32",
                "ole32", "user32", "wsock32", "ws2_32", "bcrypt"])
 
 env.Append(CPPPATH=[".", "src/"])
 
-env.Append(CPPPATH=["../thirdparty/git2/libgit2/include/"])
-env.Append(LIBPATH=["../thirdparty/bin/"])
-env.Prepend(LIBS=["git2", "ssh2"])
+env.Append(CPPPATH=["#thirdparty/git2/libgit2/include/"])
 
+lib_sources = Glob("src/*.cpp")
+env.Depends(lib_sources, ssl)
 library = env.SharedLibrary(
     target=env["target_path"] +
     "{}{}{}".format(env["target_name"], env["suffix"], env["SHLIBSUFFIX"]),
-    source=Glob("src/*.cpp")
+    source=lib_sources
 )
 Default(library)

godot-git-plugin/src/gdlibrary.cpp

@@ -19,8 +19,8 @@ void uninitialize_git_plugin_module(godot::ModuleInitializationLevel p_level) {
 
 extern "C" {
 
-GDExtensionBool GDE_EXPORT git_plugin_init(const GDExtensionInterface *p_interface, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
-	godot::GDExtensionBinding::InitObject init_obj(p_interface, p_library, r_initialization);
+GDExtensionBool GDE_EXPORT git_plugin_init(const GDExtensionInterfaceGetProcAddress p_address, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
+	godot::GDExtensionBinding::InitObject init_obj(p_address, p_library, r_initialization);
 
 	init_obj.register_initializer(initialize_git_plugin_module);
 	init_obj.register_terminator(uninitialize_git_plugin_module);

godot-git-plugin/src/git_callbacks.cpp

@@ -10,11 +10,7 @@
 extern "C" int progress_cb(const char *str, int len, void *data) {
 	(void)data;
 
-	char *progress_str = new char[len + 1];
-	std::memcpy(progress_str, str, len);
-	progress_str[len] = '\0';
-	godot::UtilityFunctions::push_warning("remote: ", CString(godot::String(progress_str).strip_edges()).data);
-	delete[] progress_str;
+	godot::UtilityFunctions::print("remote: ", godot::String::utf8(str, len).strip_edges());
 
 	return 0;
 }
@@ -27,10 +23,10 @@ extern "C" int update_cb(const char *refname, const git_oid *a, const git_oid *b
 
 	git_oid_tostr(b_str, short_commit_length, b);
 	if (git_oid_is_zero(a)) {
-		godot::UtilityFunctions::print("* [new] ", CString(godot::String(b_str)).data, " ", CString(godot::String(refname)).data);
+		godot::UtilityFunctions::print("* [new] ", godot::String::utf8(b_str), " ", godot::String::utf8(refname));
 	} else {
 		git_oid_tostr(a_str, short_commit_length, a);
-		godot::UtilityFunctions::print("[updated] ", CString(godot::String(a_str)).data, "...", CString(godot::String(b_str)).data, " ", CString(godot::String(refname)).data);
+		godot::UtilityFunctions::print("[updated] ", godot::String::utf8(a_str), "...", godot::String::utf8(b_str), " ", godot::String::utf8(refname));
 	}
 
 	return 0;
@@ -63,16 +59,16 @@ extern "C" int push_transfer_progress_cb(unsigned int current, unsigned int tota
 		progress = (current * 100) / total;
 	}
 
-	godot::UtilityFunctions::print("Writing Objects: ", uint32_t(progress), "% (", uint32_t(current), "/", uint32_t(total), ", ", uint32_t(bytes), " bytes done.");
+	godot::UtilityFunctions::print("Writing Objects: ", uint32_t(progress), "% (", uint32_t(current), "/", uint32_t(total), ", ", uint32_t(bytes), " bytes done.)");
 	return 0;
 }
 
 extern "C" int push_update_reference_cb(const char *refname, const char *status, void *data) {
-	godot::String status_str = status;
-	if (status_str == "") {
-		godot::UtilityFunctions::print("[rejected] ", CString(godot::String(refname)).data, " ", CString(status_str).data);
+	if (status != NULL) {
+		godot::String status_str = godot::String::utf8(status);
+		godot::UtilityFunctions::print("[rejected] ", godot::String::utf8(refname), " ", status_str);
 	} else {
-		godot::UtilityFunctions::print("[updated] ", CString(godot::String(refname)).data);
+		godot::UtilityFunctions::print("[updated] ", godot::String::utf8(refname));
 	}
 	return 0;
 }
@@ -82,16 +78,18 @@ extern "C" int credentials_cb(git_cred **out, const char *url, const char *usern
 
 	godot::String proper_username = username_from_url ? username_from_url : creds->username;
 
-	if (allowed_types & GIT_CREDENTIAL_USERPASS_PLAINTEXT) {
-		return git_cred_userpass_plaintext_new(out, CString(proper_username).data, CString(creds->password).data);
+	if (!creds->ssh_public_key_path.is_empty()) {
+		if (allowed_types & GIT_CREDENTIAL_SSH_KEY) {
+			return git_credential_ssh_key_new(out,
+					CString(proper_username).data,
+					CString(creds->ssh_public_key_path).data,
+					CString(creds->ssh_private_key_path).data,
+					CString(creds->ssh_passphrase).data);
+		}
 	}
 
-	if (allowed_types & GIT_CREDENTIAL_SSH_KEY) {
-		return git_credential_ssh_key_new(out,
-				CString(proper_username).data,
-				CString(creds->ssh_public_key_path).data,
-				CString(creds->ssh_private_key_path).data,
-				CString(creds->ssh_passphrase).data);
+	if (allowed_types & GIT_CREDENTIAL_USERPASS_PLAINTEXT) {
+		return git_cred_userpass_plaintext_new(out, CString(proper_username).data, CString(creds->password).data);
 	}
 
 	if (allowed_types & GIT_CREDENTIAL_USERNAME) {

godot-git-plugin/src/git_plugin.cpp

@@ -63,10 +63,10 @@ bool GitPlugin::check_errors(int error, godot::String function, godot::String fi
 	message = message + ".";
 	if ((lg2err = git_error_last()) != nullptr && lg2err->message != nullptr) {
 		message = message + " Error " + godot::String::num_int64(error) + ": ";
-		message = message + godot::String(lg2err->message);
+		message = message + godot::String::utf8(lg2err->message);
 	}
 
-	godot::UtilityFunctions::push_error("GitPlugin: ", CString(message).data, " in ", CString(file).data, ":", CString(function).data, "#L", line);
+	godot::UtilityFunctions::push_error("GitPlugin: ", message, " in ", file, ":", function, "#L", line);
 	return true;
 }
 
@@ -232,9 +232,9 @@ godot::TypedArray<godot::Dictionary> GitPlugin::_get_modified_files_data() {
 		const git_status_entry *entry = git_status_byindex(statuses.get(), i);
 		godot::String path;
 		if (entry->index_to_workdir) {
-			path = entry->index_to_workdir->new_file.path;
+			path = godot::String::utf8(entry->index_to_workdir->new_file.path);
 		} else {
-			path = entry->head_to_index->new_file.path;
+			path = godot::String::utf8(entry->head_to_index->new_file.path);
 		}
 
 		const static int git_status_wt = GIT_STATUS_WT_NEW | GIT_STATUS_WT_MODIFIED | GIT_STATUS_WT_DELETED | GIT_STATUS_WT_TYPECHANGE | GIT_STATUS_WT_RENAMED | GIT_STATUS_CONFLICTED;
@@ -245,8 +245,8 @@ godot::TypedArray<godot::Dictionary> GitPlugin::_get_modified_files_data() {
 		}
 
 		if (entry->status & git_status_index) {
-			if (entry->status == GIT_STATUS_INDEX_RENAMED) {
-				godot::String old_path = entry->head_to_index->old_file.path;
+			if (entry->status & GIT_STATUS_INDEX_RENAMED) {
+				godot::String old_path = godot::String::utf8(entry->head_to_index->old_file.path);
 				stats_files.push_back(create_status_file(old_path, map_changes.at(GIT_STATUS_INDEX_DELETED), TREE_AREA_STAGED));
 				stats_files.push_back(create_status_file(path, map_changes.at(GIT_STATUS_INDEX_NEW), TREE_AREA_STAGED));
 			} else {
@@ -273,9 +273,9 @@ godot::TypedArray<godot::String> GitPlugin::_get_branch_list() {
 
 		if (git_branch_is_head(ref.get())) {
 			// Always send the current branch as the first branch in list
-			branch_names.push_front(name);
+			branch_names.push_front(godot::String::utf8(name));
 		} else {
-			branch_names.push_back(godot::String(name));
+			branch_names.push_back(godot::String::utf8(name));
 		}
 	}
 
@@ -352,7 +352,7 @@ godot::String GitPlugin::_get_current_branch_name() {
 	const char *name = "";
 	GIT2_CALL_R(git_branch_name(&name, branch.get()), "Could not get branch name from current branch reference", "");
 
-	return name;
+	return godot::String::utf8(name);
 }
 
 godot::TypedArray<godot::String> GitPlugin::_get_remotes() {
@@ -361,7 +361,7 @@ godot::TypedArray<godot::String> GitPlugin::_get_remotes() {
 
 	godot::TypedArray<godot::String> remotes;
 	for (int i = 0; i < remote_array.count; i++) {
-		remotes.push_back(remote_array.strings[i]);
+		remotes.push_back(godot::String::utf8(remote_array.strings[i]));
 	}
 
 	return remotes;
@@ -382,10 +382,10 @@ godot::TypedArray<godot::Dictionary> GitPlugin::_get_previous_commits(int32_t ma
 		GIT2_CALL_R(git_commit_lookup(Capture(commit), repo.get(), &oid), "Failed to lookup the commit", commits);
 
 		git_oid_tostr(commit_id, GIT_OID_HEXSZ + 1, git_commit_id(commit.get()));
-		godot::String msg = git_commit_message(commit.get());
+		godot::String msg = godot::String::utf8(git_commit_message(commit.get()));
 
 		const git_signature *sig = git_commit_author(commit.get());
-		godot::String author = godot::String() + sig->name + " <" + sig->email + ">";
+		godot::String author = godot::String::utf8(sig->name) + " <" + godot::String::utf8(sig->email) + ">";
 
 		commits.push_back(create_commit(msg, author, commit_id, sig->when.time, sig->when.offset));
 	}
@@ -394,7 +394,7 @@ godot::TypedArray<godot::Dictionary> GitPlugin::_get_previous_commits(int32_t ma
 }
 
 void GitPlugin::_fetch(const godot::String &remote) {
-	godot::UtilityFunctions::print("GitPlugin: Performing fetch from ", CString(remote).data);
+	godot::UtilityFunctions::print("GitPlugin: Performing fetch from ", remote);
 
 	git_remote_ptr remote_object;
 	GIT2_CALL(git_remote_lookup(Capture(remote_object), repo.get(), CString(remote).data), "Could not lookup remote \"" + remote + "\"");
@@ -418,7 +418,7 @@ void GitPlugin::_fetch(const godot::String &remote) {
 }
 
 void GitPlugin::_pull(const godot::String &remote) {
-	godot::UtilityFunctions::print("GitPlugin: Performing pull from ", CString(remote).data);
+	godot::UtilityFunctions::print("GitPlugin: Performing pull from ", remote);
 
 	git_remote_ptr remote_object;
 	GIT2_CALL(git_remote_lookup(Capture(remote_object), repo.get(), CString(remote).data), "Could not lookup remote \"" + remote + "\"");
@@ -515,7 +515,7 @@ void GitPlugin::_pull(const godot::String &remote) {
 }
 
 void GitPlugin::_push(const godot::String &remote, bool force) {
-	godot::UtilityFunctions::print("GitPlugin: Performing push to ", CString(remote).data);
+	godot::UtilityFunctions::print("GitPlugin: Performing push to ", remote);
 
 	git_remote_ptr remote_object;
 	GIT2_CALL(git_remote_lookup(Capture(remote_object), repo.get(), CString(remote).data), "Could not lookup remote \"" + remote + "\"");
@@ -529,7 +529,8 @@ void GitPlugin::_push(const godot::String &remote, bool force) {
 	remote_cbs.push_transfer_progress = &push_transfer_progress_cb;
 	remote_cbs.push_update_reference = &push_update_reference_cb;
 
-	GIT2_CALL(git_remote_connect(remote_object.get(), GIT_DIRECTION_PUSH, &remote_cbs, nullptr, nullptr), "Could not connect to remote \"" + remote + "\". Are your credentials correct? Try using a PAT token (in case you are using Github) as your password");
+	godot::String msg = "Could not connect to remote \"" + remote + "\". Are your credentials correct? Try using a PAT token (in case you are using Github) as your password";
+	GIT2_CALL(git_remote_connect(remote_object.get(), GIT_DIRECTION_PUSH, &remote_cbs, nullptr, nullptr), msg);
 
 	godot::String branch_name = _get_current_branch_name();
 
@@ -629,7 +630,7 @@ godot::TypedArray<godot::Dictionary> GitPlugin::_parse_diff(git_diff *diff) {
 		git_patch_ptr patch;
 		GIT2_CALL_R(git_patch_from_diff(Capture(patch), diff, i), "Could not create patch from diff", godot::TypedArray<godot::Dictionary>());
 
-		godot::Dictionary diff_file = create_diff_file(delta->new_file.path, delta->old_file.path);
+		godot::Dictionary diff_file = create_diff_file(godot::String::utf8(delta->new_file.path), godot::String::utf8(delta->old_file.path));
 
 		godot::TypedArray<godot::Dictionary> diff_hunks;
 		for (int j = 0; j < git_patch_num_hunks(patch.get()); j++) {
@@ -650,7 +651,7 @@ godot::TypedArray<godot::Dictionary> GitPlugin::_parse_diff(git_diff *diff) {
 
 				godot::String status = " "; // We reserve 1 null terminated space to fill the + or the - character at git_diff_line->origin
 				status[0] = git_diff_line->origin;
-				diff_lines.push_back(create_diff_line(git_diff_line->new_lineno, git_diff_line->old_lineno, godot::String(content), status));
+				diff_lines.push_back(create_diff_line(git_diff_line->new_lineno, git_diff_line->old_lineno, godot::String::utf8(content), status));
 
 				delete[] content;
 			}
@@ -680,9 +681,9 @@ bool GitPlugin::_initialize(const godot::String &project_path) {
 
 	git_buf discovered_repo_path = {};
 	if (git_repository_discover(&discovered_repo_path, CString(project_path).data, 1, nullptr) == 0) {
-		repo_project_path = godot::String(discovered_repo_path.ptr);
+		repo_project_path = godot::String::utf8(discovered_repo_path.ptr);
 
-		godot::UtilityFunctions::print("Found a repository at " + godot::String(discovered_repo_path.ptr) + ".");
+		godot::UtilityFunctions::print("Found a repository at " + repo_project_path + ".");
 		git_buf_dispose(&discovered_repo_path);
 	} else {
 		repo_project_path = project_path;
@@ -690,7 +691,7 @@ bool GitPlugin::_initialize(const godot::String &project_path) {
 		godot::UtilityFunctions::push_warning("Could not find any higher level repositories.");
 	}
 
-	godot::UtilityFunctions::print("Selected repository path: " + godot::String(repo_project_path) + ".");
+	godot::UtilityFunctions::print("Selected repository path: " + repo_project_path + ".");
 	GIT2_CALL_R(git_repository_init(Capture(repo), CString(repo_project_path).data, 0), "Could not initialize repository", false);
 
 	git_reference_ptr head;

release.sh

@@ -5,19 +5,21 @@
 echo "Enter the new version number (e.g. 1.2.1):"
 read version
 
-echo "Enter the Windows x64 release ZIP URL:"
-read windowsZIPURL
+echo "Enter the Windows x64 release ZIP artifact ID or URL:"
+read windowsArtifactID
 
-echo "Enter the Linux x64 release ZIP URL:"
-read linuxZIPURL
+echo "Enter the Linux x64 release ZIP artifact ID or URL:"
+read linuxArtifactID
 
-echo "Enter the MacOS universal release ZIP URL:"
-read macZIPURL
+echo "Enter the MacOS universal release ZIP artifact ID or URL:"
+read macArtifactID
 
 # wget-ing the github.com URL gives a 404, so we use the method proposed here - https://github.com/actions/upload-artifact/issues/51#issuecomment-735989475
-windowsZIPURL=${windowsZIPURL/github.com/nightly.link}
-linuxZIPURL=${linuxZIPURL/github.com/nightly.link}
-macZIPURL=${macZIPURL/github.com/nightly.link}
+# The ${foo##*/} syntax extracts the string after the last '/' in case it's a full artifact URL.
+baseURL=https://nightly.link/godotengine/godot-git-plugin/actions/artifacts/
+windowsZIPURL=${baseURL}${windowsArtifactID##*/}.zip
+linuxZIPURL=${baseURL}${linuxArtifactID##*/}.zip
+macZIPURL=${baseURL}${macArtifactID##*/}.zip
 
 wget -O windows.zip $windowsZIPURL
 wget -O linux.zip $linuxZIPURL
@@ -43,7 +45,7 @@ sed -i "s/version=\"[^\"]*\"/version=\"v${version}\"/g" $pluginPath/plugin.cfg
 cp LICENSE $pluginPath/LICENSE
 cp THIRDPARTY.md $pluginPath/THIRDPARTY.md
 
-zip -r $releasePath.zip $addonsPath 
+zip -r $releasePath.zip $addonsPath
 
 rm -rf $releasePath
 rm -rf windows

thirdparty/SCsub

@@ -1,6 +0,0 @@
-#!/usr/bin/env python
-
-Import("env")
-
-SConscript("ssh2/SCsub")
-SConscript("git2/SCsub")

thirdparty/git2/SCsub

@@ -1,135 +0,0 @@
-#!/usr/bin/env python
-
-# Adopted from https://github.com/goostengine/goost/blob/20d8ce4c7d74c26832d69283305b25a72165784a/modules/git/SCsub
-
-Import("env")
-
-env_git = env.Clone()
-
-# Thirdparty source files.
-libgit2_sources = []
-libgit2_sources += Glob("libgit2/src/" + "*.c")
-libgit2_sources += Glob("libgit2/src/allocators/" + "*.c")
-libgit2_sources += Glob("libgit2/src/hash/sha1/sha1dc/sha1.c")
-libgit2_sources += Glob("libgit2/src/hash/sha1/sha1dc/ubc_check.c")
-libgit2_sources += Glob("libgit2/src/hash/sha1/collisiondetect.c")
-libgit2_sources += Glob("libgit2/src/transports/" + "*.c")
-libgit2_sources += Glob("libgit2/src/hash/transports/" + "*.c")
-libgit2_sources += Glob("libgit2/src/hash/xdiff/" + "*.c")
-libgit2_sources += Glob("libgit2/src/xdiff/" + "*.c")
-libgit2_sources += Glob("libgit2/src/streams/" + "*.c")
-
-libgit2_sources += Glob("libgit2/deps/http-parser/" + "*.c")
-libgit2_sources += Glob("libgit2/deps/pcre/" + "*.c")
-libgit2_sources += Glob("libgit2/deps/zlib/" + "*.c")
-
-if "32" in env["arch"]:
-    env_git.Prepend(CPPDEFINES=["GIT_ARCH_32"])
-else:
-    env_git.Prepend(CPPDEFINES=["GIT_ARCH_64"])
-
-env_git.Prepend(
-    CPPPATH=[
-        "libgit2/include/",
-        "libgit2/src/",
-        "libgit2/deps/http-parser/",
-        "libgit2/deps/pcre/",
-        "libgit2/deps/zlib/",
-        "libgit2/deps/ntlmclient/",
-        "../ssh2/libssh2/include/",
-    ]
-)
-
-env_git.Prepend(
-    CPPDEFINES=[
-        "GIT_THREADS",
-        "GIT_SSH",
-        "GIT_SSH_MEMORY_CREDENTIALS",
-        "LIBGIT2_NO_FEATURES_H",
-        "GIT_SHA1_COLLISIONDETECT",
-        "GIT_HTTPS",
-        "SRC_UTIL_H_",
-        "GIT_REGEX_BUILTIN",
-    ]
-)
-
-if env_git["platform"] == "windows":
-    libgit2_sources += Glob("libgit2/src/win32/" + "*.c")
-    env_git.Prepend(
-        CPPDEFINES=[
-            "GIT_WINHTTP",
-            "HAVE_SYS_STAT_H",
-            "HAVE_SYS_TYPES_H",
-            "HAVE_WINDOWS_H",
-            "HAVE_STDINT_H",
-            "HAVE_INTTYPES_H",
-            "HAVE_MEMMOVE",
-            "HAVE_STRERROR",
-            "HAVE_STRTOLL",
-            "HAVE__STRTOI64",
-            "SUPPORT_PCRE8",
-            "NO_RECURSE",
-            "HAVE_LONG_LONG",
-            "HAVE_UNSIGNED_LONG_LONG",
-            ("NEWLINE", "10"),
-            ("POSIX_MALLOC_THRESHOLD", "10"),
-            ("LINK_SIZE", "2"),
-            ("PARENS_NEST_LIMIT", "250"),
-            ("MATCH_LIMIT", "10000000"),
-            ("MATCH_LIMIT_RECURSION", "10000000"),
-            "PCREGREP_BUFSIZE",
-            ("MAX_NAME_SIZE", "32"),
-            ("MAX_NAME_COUNT", "10000"),
-            "HAVE_WINCNG",
-            "LIBSSH2_WINCNG"
-        ]
-    )
-
-if env_git["platform"] in ["linux", "macos"]:
-    env_git.Append(CCFLAGS="-fPIC")
-    libgit2_sources += Glob("libgit2/src/unix/" + "*.c")
-    libgit2_sources += [
-        "libgit2/deps/ntlmclient/crypt_openssl.c",
-        "libgit2/deps/ntlmclient/unicode_builtin.c"
-    ]
-    env_git.Prepend(
-        CPPDEFINES=[
-            "HAVE_DIRENT_H",
-            "HAVE_SYS_STAT_H",
-            "HAVE_SYS_TYPES_H",
-            "HAVE_UNISTD_H",
-            "HAVE_STDINT_H",
-            "HAVE_INTTYPES_H",
-            "HAVE_BCOPY",
-            "HAVE_MEMMOVE",
-            "HAVE_STRERROR",
-            "HAVE_STRTOLL",
-            "HAVE_STRTOQ",
-            "SUPPORT_PCRE8",
-            "NO_RECURSE",
-            "HAVE_LONG_LONG",
-            "HAVE_UNSIGNED_LONG_LONG",
-            ("NEWLINE", "10"),
-            ("POSIX_MALLOC_THRESHOLD", "10"),
-            ("LINK_SIZE", "2"),
-            ("PARENS_NEST_LIMIT", "250"),
-            ("MATCH_LIMIT", "10000000"),
-            ("MATCH_LIMIT_RECURSION", "10000000"),
-            "PCREGREP_BUFSIZE",
-            ("MAX_NAME_SIZE", "32"),
-            ("MAX_NAME_COUNT", "10000"),
-            "GIT_OPENSSL",
-            "GIT_USE_FUTIMENS",
-            "GIT_USE_STAT_MTIM",
-            "CRYPT_OPENSSL",
-            "UNICODE_BUILTIN"
-        ]
-    )
-
-if env_git["platform"] == "macos":
-    env_git.Prepend(CPPPATH=[env_git["macos_openssl"] + "include/"])
-    static_ssl = File(env_git["macos_openssl_static_ssl"])
-    static_crypto = File(env_git["macos_openssl_static_crypto"])
-    env_git.Append(LIBS=[static_ssl, static_crypto])
-
-env_git.StaticLibrary(target="../bin/" + "git2", source=libgit2_sources)

thirdparty/ssh2/SCsub

@@ -1,113 +0,0 @@
-#!/usr/bin/env python
-
-# Adopted from https://github.com/nodegit/nodegit/blob/4561dcb7c120474a4553baa27e4c4c2f4be23a2b/vendor/libgit2.gyp
-
-Import("env")
-
-env_ssh2 = env.Clone()
-
-# Thirdparty source files.
-libssh2_sources = [
-    "libssh2/src/agent.c",
-    "libssh2/src/bcrypt_pbkdf.c",
-    "libssh2/src/blowfish.c",
-    "libssh2/src/crypt.c",
-    "libssh2/src/keepalive.c",
-    "libssh2/src/libgcrypt.c",
-    "libssh2/src/openssl.c",
-    "libssh2/src/publickey.c",
-    "libssh2/src/sftp.c",
-    "libssh2/src/version.c",
-    "libssh2/src/channel.c",
-    "libssh2/src/global.c",
-    "libssh2/src/kex.c",
-    "libssh2/src/mac.c",
-    "libssh2/src/packet.c",
-    "libssh2/src/scp.c",
-    "libssh2/src/transport.c",
-    "libssh2/src/comp.c",
-    "libssh2/src/hostkey.c",
-    "libssh2/src/knownhost.c",
-    "libssh2/src/misc.c",
-    "libssh2/src/pem.c",
-    "libssh2/src/session.c",
-    "libssh2/src/userauth.c",
-]
-
-env_ssh2.Prepend(
-    CPPPATH=[
-        "libssh2/include/"
-        "libssh2/src/"
-    ]
-)
-
-if env_ssh2["platform"] == "windows":
-    env_ssh2.Append(
-        CPPPATH=[
-            "libssh2/include/",
-            "libssh2/win32/"
-        ]
-    )
-    libssh2_sources += ["libssh2/src/agent_win.c", "libssh2/src/wincng.c"]
-    env_ssh2.Append(
-        CPPDEFINES=[
-            "LIBSSH2_WINCNG",
-            "HAVE_WINCNG"
-        ]
-    )
-    env_ssh2.Append(LIBS=["crypt32", "user32"])
-
-if env_ssh2["platform"] in ["linux", "macos"]:
-    env_ssh2.Append(CCFLAGS="-fPIC")
-    env_ssh2.Append(
-        CPPPATH=[
-            ".",
-            "libssh2/include/",
-        ]
-    )
-    libssh2_sources += ["libssh2/src/openssl.c"]
-    env_ssh2.Append(
-        CPPDEFINES=[
-            "LIBSSH2_CONFIG_H",
-            "HAVE_SYS_UIO_H",
-            ("HAVE_ALLOCA", 1),
-            ("HAVE_ALLOCA_H", 1),
-            ("HAVE_ARPA_INET_H", 1),
-            ("HAVE_ERRNO_H", 1),
-            ("HAVE_FCNTL_H", 1),
-            ("HAVE_GETTIMEOFDAY", 1),
-            ("HAVE_GETTIMEOFDAY", 1),
-            ("HAVE_INTTYPES_H", 1),
-            ("HAVE_LONGLONG", 1),
-            ("HAVE_NETINET_IN_H", 1),
-            ("HAVE_O_NONBLOCK", 1),
-            ("HAVE_SELECT", 1),
-            ("HAVE_STDINT_H", 1),
-            ("HAVE_STDIO_H", 1),
-            ("HAVE_STDLIB_H", 1),
-            ("HAVE_STRINGS_H", 1),
-            ("HAVE_STRING_H", 1),
-            ("HAVE_STRTOLL", 1),
-            ("HAVE_SYS_IOCTL_H", 1),
-            ("HAVE_SYS_SOCKET_H", 1),
-            ("HAVE_SYS_STAT_H", 1),
-            ("HAVE_SYS_TIME_H", 1),
-            ("HAVE_SYS_TYPES_H", 1),
-            ("HAVE_SYS_UIO_H", 1),
-            ("HAVE_SYS_UN_H", 1),
-            ("HAVE_UNISTD_H", 1),
-            ("LIBSSH2_CLEAR_MEMORY", 1),
-            ("LIBSSH2_DH_GEX_NEW", 1),
-            ("LIBSSH2_OPENSSL", 1),
-            ("LT_OBJDIR", ".libs/"),
-            ("STDC_HEADERS", 1)
-        ]
-    )
-
-if env_ssh2["platform"] == "macos":
-    env_ssh2.Append(CPPPATH=[env_ssh2["macos_openssl"] + "include/"])
-    static_ssl = File(env_ssh2["macos_openssl_static_ssl"])
-    static_crypto = File(env_ssh2["macos_openssl_static_crypto"])
-    env_ssh2.Append(LIBS=[static_ssl, static_crypto])
-
-env_ssh2.StaticLibrary(target="../bin/" + "ssh2", source=libssh2_sources)

tools/cmake.py

@@ -0,0 +1,177 @@
+import os
+import shlex
+import sys
+
+import SCons.Action
+import SCons.Builder
+import SCons.Util
+
+
+# This must be kept in sync with the value in https://github.com/godotengine/godot/blob/master/platform/android/detect.py#L58.
+def get_ndk_version():
+    return "23.2.8568313"
+
+
+def cmake_default_flags(env):
+    if env.get("cmake_default_flags", ""):
+        return shlex.split(env["cmake_default_flags"])
+
+    config = {}
+
+    if "CC" in env:
+        config["CMAKE_C_COMPILER"] = env["CC"]
+    if "CXX" in env:
+        config["CMAKE_CXX_COMPILER"] = env["CXX"]
+
+    if env["platform"] == "android":
+        api = env["android_api_level"]
+        abi = {
+            "arm64": "arm64-v8a",
+            "arm32": "armeabi-v7a",
+            "x86_32": "x86",
+            "x86_64": "x86_64",
+        }[env["arch"]]
+        config["CMAKE_SYSTEM_NAME"] = "Android"
+        config["CMAKE_SYSTEM_VERSION"] = api
+        config["CMAKE_ANDROID_ARCH_ABI"] = abi
+        config["ANDROID_ABI"] = abi
+        ndk_root = os.environ.get("ANDROID_NDK_ROOT", env.get("ANDROID_HOME", "") + "/ndk/" + get_ndk_version())
+        config["CMAKE_TOOLCHAIN_FILE"] = "%s/build/cmake/android.toolchain.cmake" % ndk_root
+        config["CMAKE_ANDROID_STL_TYPE"] = "c++_static"
+
+    elif env["platform"] == "linux":
+        linux_flags = {
+            "x86_64": "-m64",
+            "x86_32": "-m32",
+            "arm32": "-march=armv7-a",
+            "arm64": "-march=armv8-a",
+        }.get(env["arch"], "")
+        if linux_flags:
+            config["CMAKE_C_FLAGS"] = linux_flags
+            config["CMAKE_CXX_FLAGS"] = linux_flags
+
+    elif env["platform"] == "macos":
+        if env["arch"] == "universal":
+            config["CMAKE_OSX_ARCHITECTURES"] = '"x86_64;arm64"'
+        else:
+            config["CMAKE_OSX_ARCHITECTURES"] = env["arch"]
+        if env.get("macos_deployment_target", "default") != "default":
+            config["CMAKE_OSX_DEPLOYMENT_TARGET"] = env["macos_deployment_target"]
+        if sys.platform != "darwin" and "OSXCROSS_ROOT" in os.environ:
+            config["CMAKE_AR"] = env["AR"]
+            config["CMAKE_RANLIB"] = env["RANLIB"]
+            if env["arch"] == "universal":
+                flags = "-arch x86_64 -arch arm64"
+            else:
+                flags = "-arch " + env["arch"]
+            if env["macos_deployment_target"] != "default":
+                flags += " -mmacosx-version-min=" + env["macos_deployment_target"]
+            config["CMAKE_C_FLAGS"] = flags
+            config["CMAKE_CXX_FLAGS"] = flags
+
+    elif env["platform"] == "ios":
+        if env["arch"] == "universal":
+            raise ValueError("iOS architecture not supported: %s" % env["arch"])
+        config["CMAKE_SYSTEM_NAME"] = "iOS"
+        config["CMAKE_OSX_ARCHITECTURES"] = env["arch"]
+        if env.get("ios_min_version", "default") != "default":
+            config["CMAKE_OSX_DEPLOYMENT_TARGET"] = env["ios_min_version"]
+        if env["ios_simulator"]:
+            config["CMAKE_OSX_SYSROOT"] = "iphonesimulator"
+
+    elif env["platform"] == "windows":
+        config["CMAKE_SYSTEM_NAME"] = "Windows"
+        if env.get("is_msvc", False):
+            config["CMAKE_POLICY_DEFAULT_CMP0091"] = "NEW"
+            if env.get("debug_crt", False):
+                config["CMAKE_MSVC_RUNTIME_LIBRARY"] = "MultiThreadedDebugDLL"
+            else:
+                if env.get("use_static_cpp", False):
+                    config["CMAKE_MSVC_RUNTIME_LIBRARY"] = "MultiThreaded"
+                else:
+                    config["CMAKE_MSVC_RUNTIME_LIBRARY"] = "MultiThreadedDLL"
+
+    return ["-D%s=%s" % it for it in config.items()]
+
+
+def cmake_emitter(target, source, env):
+    return [str(target[0]) + "/CMakeCache.txt"] + target[1:], [str(source[0]) + "/CMakeLists.txt"] + source[1:]
+
+
+def cmake_generator(target, source, env, for_signature):
+    # Strip the -j option for signature to avoid rebuilding when num_jobs changes.
+    build = env["CMAKEBUILDCOM"].replace("-j$CMAKEBUILDJOBS", "") if for_signature else env["CMAKEBUILDCOM"]
+    actions = [
+        SCons.Action.Action("$CMAKECONFCOM", "$CMAKECONFCOMSTR"),
+        SCons.Action.Action(build, "$CMAKEBUILDCOMSTR"),
+    ]
+    if env["CMAKE_INSTALL"]:
+        actions.append(
+            SCons.Action.Action("$CMAKEINSTALLCOM", "$CMAKEINSTALLCOMSTR"),
+        )
+    return actions
+
+
+def cmake_build(
+    env, target_dir, source_dir, cmake_outputs=[], cmake_targets=[], cmake_options=[], dependencies=[], install=False
+):
+    cmake_env = env.Clone()
+    target = env.Dir("{}/{}/{}".format(target_dir, env["platform"], env["arch"]))
+    source = env.Dir(source_dir)
+    builder_targets = [target] + [str(target) + "/" + f for f in cmake_outputs]
+    builder_sources = [source] + dependencies
+    default_flags = cmake_default_flags(env)
+
+    # Merge flags
+    flags = []
+    for df in default_flags:
+        if not df.startswith("-D"):
+            flags.append(df)
+        else:
+            f = df[2:].split("=")[0]
+            if f in cmake_options:
+                df += " " + cmake_options[f]
+                cmake_options.pop(f)
+            flags.append(df)
+    for opt in cmake_options:
+        flags.append("-D%s=%s" % (opt, cmake_options[opt]))
+
+    # Select generator
+    if env["cmake_generator"]:
+        flags.extend(["-G", env["cmake_generator"]])
+    elif env["platform"] == "windows":
+        if env.get("is_msvc", False):
+            flags.extend(["-G", "NMake Makefiles"])
+        elif sys.platform in ["win32", "msys", "cygwin"]:
+            flags.extend(["-G", "Ninja"])
+        else:
+            flags.extend(["-G", "Unix Makefiles"])
+
+    cmake_env.Append(CMAKECONFFLAGS=flags)
+    if len(cmake_targets) > 0:
+        cmake_env.Append(CMAKEBUILDFLAGS=["-t"] + [t for t in cmake_targets])
+    cmake_env["CMAKE_INSTALL"] = install
+    return cmake_env.CMake(builder_targets, builder_sources)
+
+
+def options(opts):
+    opts.Add("cmake_default_flags", "Default CMake platform flags override, will be autodetected if not specified.", "")
+    opts.Add("cmake_generator", "CMake generator override, will be autodetected from platform if not specified.", "")
+    opts.Add("cmake", "CMake binary to use", "cmake")
+
+
+def exists(env):
+    return True
+
+
+def generate(env):
+    env["CMAKE"] = env["cmake"]
+    env["CMAKECONFFLAGS"] = SCons.Util.CLVar("")
+    env["CMAKECONFCOM"] = "$CMAKE -B ${TARGET.dir} $CMAKECONFFLAGS ${SOURCE.dir}"
+    env["CMAKEBUILDJOBS"] = "${__env__.GetOption('num_jobs')}"
+    env["CMAKEBUILDFLAGS"] = SCons.Util.CLVar("")
+    env["CMAKEINSTALLFLAGS"] = SCons.Util.CLVar("")
+    env["CMAKEBUILDCOM"] = "$CMAKE --build ${TARGET.dir} $CMAKEBUILDFLAGS -j$CMAKEBUILDJOBS"
+    env["CMAKEINSTALLCOM"] = "$CMAKE --install ${TARGET.dir} $CMAKEINSTALLFLAGS"
+    env["BUILDERS"]["CMake"] = SCons.Builder.Builder(generator=cmake_generator, emitter=cmake_emitter)
+    env.AddMethod(cmake_build, "CMakeBuild")

tools/git2.py

@@ -0,0 +1,69 @@
+import os
+
+
+def build_library(env, deps):
+    config = {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo" if env["debug_symbols"] else "Release",
+        "OPENSSL_USE_STATIC_LIBS": 1,
+        "OPENSSL_INCLUDE_DIR": env["SSL_INCLUDE"],
+        "OPENSSL_SSL_LIBRARY": env["SSL_LIBRARY"],
+        "OPENSSL_CRYPTO_LIBRARY": env["SSL_CRYPTO_LIBRARY"],
+        "OPENSSL_ROOT_DIR": env["SSL_INSTALL"],
+        "BUILD_TESTS": 0,
+        "BUILD_CLI": 0,
+        "BUILD_EXAMPLES": 0,
+        "BUILD_FUZZERS": 0,
+        "USE_SSH": 1,
+        "USE_HTTPS": 1,
+        "USE_SHA1": 1,
+        "USE_BUNDLED_ZLIB": 1,
+        "USE_HTTP_PARSER": "builtin",
+        "REGEX_BACKEND": "builtin",
+        "USE_HTTPS": "OpenSSL",
+        "USE_SHA1": "OpenSSL",
+        "BUILD_SHARED_LIBS": 0,
+        "LINK_WITH_STATIC_LIBRARIES": 1,
+        "LIBSSH2_INCLUDE_DIR": env.Dir("#thirdparty/ssh2/libssh2/include").abspath,
+        "LIBSSH2_LIBRARY": deps[-1],
+        "USE_WINHTTP": 0,
+        "STATIC_CRT": env.get("use_static_cpp", True),
+        "CMAKE_DISABLE_FIND_PACKAGE_ZLIB": 1,
+        "CMAKE_DISABLE_FIND_PACKAGE_OPENSSL": 1,
+    }
+
+    if env["platform"] != "windows":
+        config["CMAKE_C_FLAGS"] = "-fPIC"
+    else:
+        config["OPENSSL_ROOT_DIR"] = env["SSL_BUILD"]
+
+    is_msvc = env.get("is_msvc", False)
+    lib_ext = ".lib" if is_msvc else ".a"
+    lib_prefix = "" if is_msvc else "lib"
+    libs = ["{}git2{}".format(lib_prefix, lib_ext)]
+
+    source = env.Dir("#thirdparty/git2/libgit2").abspath
+    target = env.Dir("#bin/thirdparty/libgit2").abspath
+
+    git2 = env.CMakeBuild(
+        "#bin/thirdparty/git2/",
+        "#thirdparty/git2/libgit2",
+        cmake_options=config,
+        cmake_outputs=libs,
+        cmake_targets=[],
+        dependencies=deps,
+    )
+
+    env.Append(CPPPATH=["#thirdparty/git2/libgit2/include"])
+    env.Prepend(LIBS=git2[1:])
+    if env["platform"] == "windows":
+        env.PrependUnique(LIBS=["secur32"])
+
+    return git2
+
+
+def exists(env):
+    return "CMake" in env
+
+
+def generate(env):
+    env.AddMethod(build_library, "BuildGIT2")

tools/openssl.py

@@ -0,0 +1,288 @@
+import os, sys
+import SCons.Util
+import SCons.Builder
+import SCons.Action
+from SCons.Defaults import Mkdir
+from SCons.Variables import PathVariable, BoolVariable
+
+
+def ssl_platform_target(env):
+    targets = {}
+    platform = env["platform"]
+    if platform == "linux":
+        targets = {
+            "x86_32": "linux-x86",
+            "x86_64": "linux-x86_64",
+            "arm64": "linux-aarch64",
+            "arm32": "linux-armv4",
+            "rv64": "linux64-riscv64",
+        }
+    elif platform == "android":
+        targets = {
+            "arm64": "android-arm64",
+            "arm32": "android-arm",
+            "x86_32": "android-x86",
+            "x86_64": "android-x86_64",
+        }
+    elif platform == "macos":
+        targets = {
+            "x86_64": "darwin64-x86_64",
+            "arm64": "darwin64-arm64",
+        }
+    elif platform == "ios":
+        if env["ios_simulator"]:
+            targets = {
+                "x86_64": "iossimulator-xcrun",
+                "arm64": "iossimulator-xcrun",
+            }
+        else:
+            targets = {
+                "arm64": "ios64-xcrun",
+                "arm32": "ios-xcrun",
+            }
+    elif platform == "windows":
+        if env.get("is_msvc", False):
+            targets = {
+                "x86_32": "VC-WIN32",
+                "x86_64": "VC-WIN64A",
+            }
+        else:
+            targets = {
+                "x86_32": "mingw",
+                "x86_64": "mingw64",
+            }
+
+    arch = env["arch"]
+    target = targets.get(arch, "")
+    if target == "":
+        raise ValueError("Architecture '%s' not supported for platform: '%s'" % (arch, platform))
+    return target
+
+
+def ssl_platform_options(env):
+    ssl_config_options = [
+        "no-ssl2",
+        "no-ssl3",
+        "no-weak-ssl-ciphers",
+        "no-legacy",
+        "no-shared",
+        "no-tests",
+    ]
+    if env["platform"] == "windows":
+        ssl_config_options.append("enable-capieng")
+    return ssl_config_options
+
+
+def ssl_platform_flags(env):
+    args = []
+    if env["platform"] == "android":
+        if env.get("android_api_level", ""):
+            api = int(env["android_api_level"])
+            args.append("-D__ANDROID_API__=%s" % api)
+    elif env["platform"] == "macos":
+        if env["macos_deployment_target"] != "default":
+            args.append("-mmacosx-version-min=%s" % env["macos_deployment_target"])
+        # OSXCross toolchain setup.
+        if sys.platform != "darwin" and "OSXCROSS_ROOT" in os.environ:
+            for k in ["CC", "CXX", "AR", "AS", "RANLIB"]:
+                args.append("%s=%s" % (k, env[k]))
+    elif env["platform"] == "windows":
+        is_win_host = sys.platform in ["win32", "msys", "cygwin"]
+        if not (is_win_host or env.get("is_msvc", False)):
+            mingw_prefixes = {
+                "x86_32": "--cross-compile-prefix=i686-w64-mingw32-",
+                "x86_64": "--cross-compile-prefix=x86_64-w64-mingw32-",
+            }
+            args.append(mingw_prefixes[env["arch"]])
+    return args
+
+
+def ssl_configure_args(env):
+    if env.get("openssl_configure_options", ""):
+        opts = SCons.Util.CLVar(env["openssl_configure_options"])
+    else:
+        opts = ssl_platform_options(env)
+
+    if env.get("openssl_configure_target", ""):
+        target = [env["openssl_configure_target"]]
+    else:
+        target = [ssl_platform_target(env)]
+
+    if env.get("openssl_configure_flags", ""):
+        flags = SCons.Util.CLVar(env["openssl_configure_flags"])
+    else:
+        flags = ssl_platform_flags(env)
+
+    return opts + target + flags
+
+
+def ssl_emitter(target, source, env):
+    return env["SSL_LIBS"], [env.File(env["SSL_SOURCE"] + "/Configure"), env.File(env["SSL_SOURCE"] + "/VERSION.dat")]
+
+
+def build_openssl(env, jobs=None):
+    if env["SSL_EXTERNAL"]:
+        # Setup the env to use the provided libraries, and return them without building.
+        env.Prepend(CPPPATH=[env["SSL_INCLUDE"]])
+        env.Prepend(LIBPATH=[env["SSL_BUILD"]])
+        if env["platform"] == "windows":
+            env.PrependUnique(LIBS=["crypt32", "ws2_32", "advapi32", "user32"])
+        env.Prepend(LIBS=env["SSL_LIBS"])
+        return [env["SSL_CRYPTO_LIBRARY"], env["SSL_LIBRARY"]]
+
+    if jobs is None:
+        jobs = int(env.GetOption("num_jobs"))
+
+    # Since the OpenSSL build system does not support macOS universal binaries, we first need to build the two libraries
+    # separately, then we join them together using lipo.
+    if env["platform"] == "macos" and env["arch"] == "universal":
+        build_envs = {
+            "x86_64": env.Clone(),
+            "arm64": env.Clone(),
+        }
+        arch_ssl = []
+        for arch in build_envs:
+            benv = build_envs[arch]
+            benv["arch"] = arch
+            generate(benv)
+            benv["SSLBUILDJOBS"] = max([1, int(jobs / len(build_envs))])
+            ssl = benv.OpenSSLBuilder()
+            arch_ssl.extend(ssl)
+            benv.NoCache(ssl)  # Needs refactoring to properly cache generated headers.
+
+        # x86_64 and arm64 includes are equivalent.
+        env["SSL_INCLUDE"] = build_envs["arm64"]["SSL_INCLUDE"]
+
+        # Join libraries using lipo.
+        lipo_action = "lipo $SOURCES -create -output $TARGET"
+        ssl_libs = list(map(lambda arch: build_envs[arch]["SSL_LIBRARY"], build_envs))
+        ssl_crypto_libs = list(map(lambda arch: build_envs[arch]["SSL_CRYPTO_LIBRARY"], build_envs))
+        ssl = env.Command(env["SSL_LIBRARY"], ssl_libs, lipo_action)
+        ssl += env.Command(env["SSL_CRYPTO_LIBRARY"], ssl_crypto_libs, lipo_action)
+        env.Depends(ssl, arch_ssl)
+    else:
+        benv = env.Clone()
+        benv["SSLBUILDJOBS"] = jobs
+        ssl = benv.OpenSSLBuilder()
+        benv.NoCache(ssl)  # Needs refactoring to properly cache generated headers.
+
+    # Setup the environment to use the freshly built openssl.
+    env.Prepend(CPPPATH=[env["SSL_INCLUDE"]])
+    env.Prepend(LIBPATH=[env["SSL_BUILD"]])
+    if env["platform"] == "windows":
+        env.PrependUnique(LIBS=["crypt32", "ws2_32", "advapi32", "user32"])
+    env.Prepend(LIBS=env["SSL_LIBS"])
+
+    return ssl
+
+
+def ssl_generator(target, source, env, for_signature):
+    # Strip the -j option for signature to avoid rebuilding when num_jobs changes.
+    build = env["SSLBUILDCOM"].replace("-j$SSLBUILDJOBS", "") if for_signature else env["SSLBUILDCOM"]
+    return [
+        Mkdir("$SSL_BUILD"),
+        Mkdir("$SSL_INSTALL"),
+        SCons.Action.Action("$SSLCONFIGCOM", "$SSLCONFIGCOMSTR"),
+        SCons.Action.Action(build, "$SSLBUILDCOMSTR"),
+    ]
+
+
+def options(opts):
+    opts.Add(PathVariable("openssl_source", "Path to the openssl sources.", "thirdparty/openssl"))
+    opts.Add("openssl_build", "Destination path of the openssl build.", "bin/thirdparty/openssl")
+    opts.Add(
+        "openssl_configure_options",
+        "OpenSSL configure options override. Will use a reasonable default if not specified.",
+        "",
+    )
+    opts.Add(
+        "openssl_configure_target", "OpenSSL configure target override, will be autodetected if not specified.", ""
+    )
+    opts.Add(
+        "openssl_configure_flags",
+        "OpenSSL configure compiler flags override. Will be autodetected if not specified.",
+        "",
+    )
+    opts.Add(
+        "openssl_external_crypto",
+        'An external libcrypto static library (e.g. "/usr/lib/x86_64-linux-gnu/libcrypto.a"). If not provided, OpenSSL will be built from source.',
+        "",
+    )
+    opts.Add(
+        "openssl_external_ssl",
+        'An external libssl static library (e.g. "/usr/lib/x86_64-linux-gnu/libssl.a"). If not provided, OpenSSL will be built from source.',
+        "",
+    )
+    opts.Add(
+        "openssl_external_include",
+        'An external OpenSSL "include" folder (e.g. "/usr/include/openssl").',
+        "",
+    )
+
+
+def exists(env):
+    return True
+
+
+def generate(env):
+    env.AddMethod(build_openssl, "OpenSSL")
+
+    # Check if the user specified infos about external OpenSSL files.
+    external_opts = ["openssl_external_crypto", "openssl_external_ssl", "openssl_external_include"]
+    is_set = lambda k: env.get(k, "") != ""
+    if any(map(is_set, external_opts)):
+        # Need provide the whole (crypto, ssl, include) triple to proceed.
+        if not all(map(is_set, external_opts)):
+            print('Error: The options "%s" must all be set to use a external library.' % '", "'.join(external_opts))
+            sys.exit(255)
+
+        env["SSL_CRYPTO_LIBRARY"] = env.File("${openssl_external_crypto}")
+        env["SSL_LIBRARY"] = env.File("${openssl_external_ssl}")
+        env["SSL_BUILD"] = env.Dir("${SSL_LIBRARY.dir}").abspath
+        env["SSL_INSTALL"] = env.Dir("${SSL_LIBRARY.dir}").abspath
+        env["SSL_INCLUDE"] = env.Dir("${openssl_external_include}").abspath
+        env["SSL_LIBS"] = [env["SSL_LIBRARY"], env["SSL_CRYPTO_LIBRARY"]]
+        env["SSL_EXTERNAL"] = True
+        return
+
+    # We will need to build our own OpenSSL library.
+    env["SSL_EXTERNAL"] = False
+
+    # Android needs the NDK in ENV, and proper PATH setup.
+    if env["platform"] == "android" and env["ENV"].get("ANDROID_NDK_ROOT", "") == "":
+        cc_path = os.path.dirname(env["CC"])
+        if cc_path and cc_path not in env["ENV"]:
+            env.PrependENVPath("PATH", cc_path)
+        if "ANDROID_NDK_ROOT" not in env["ENV"]:
+            env["ENV"]["ANDROID_NDK_ROOT"] = env.get("ANDROID_NDK_ROOT", os.environ.get("ANDROID_NDK_ROOT", ""))
+
+    env["SSL_SOURCE"] = env.Dir(env["openssl_source"]).abspath
+    env["SSL_BUILD"] = env.Dir(env["openssl_build"] + "/{}/{}".format(env["platform"], env["arch"])).abspath
+    env["SSL_INSTALL"] = env.Dir(env["SSL_BUILD"] + "/dest").abspath
+    env["SSL_INCLUDE"] = env.Dir(env["SSL_INSTALL"] + "/include").abspath
+    lib_ext = ".lib" if env.get("is_msvc", False) else ".a"
+    env["SSL_LIBRARY"] = env.File(env["SSL_BUILD"] + "/libssl" + lib_ext)
+    env["SSL_CRYPTO_LIBRARY"] = env.File(env["SSL_BUILD"] + "/libcrypto" + lib_ext)
+    env["SSL_LIBS"] = [env["SSL_LIBRARY"], env["SSL_CRYPTO_LIBRARY"]]
+
+    # Configure action
+    env["PERL"] = env.get("PERL", "perl")
+    env["_ssl_configure_args"] = ssl_configure_args
+    env["SSLPLATFORMCONFIG"] = "${_ssl_configure_args(__env__)}"
+    env["SSLCONFFLAGS"] = SCons.Util.CLVar("")
+    # fmt: off
+    env["SSLCONFIGCOM"] = 'cd ${TARGET.dir} && $PERL -- ${SOURCE.abspath} --prefix="${SSL_INSTALL}" --openssldir="${SSL_INSTALL}" $SSLPLATFORMCONFIG $SSLCONFFLAGS'
+    # fmt: on
+
+    # Build action
+    env["SSLBUILDJOBS"] = "${__env__.GetOption('num_jobs')}"
+    # fmt: off
+    env["SSLBUILDCOM"] = "make -j$SSLBUILDJOBS -C ${TARGET.dir} && make -j$SSLBUILDJOBS -C ${TARGET.dir} install_sw install_ssldirs"
+    # fmt: on
+
+    # Windows MSVC needs to build using NMake
+    if env["platform"] == "windows" and env.get("is_msvc", False):
+        env["SSLBUILDCOM"] = "cd ${TARGET.dir} && nmake install_sw install_ssldirs"
+
+    env["BUILDERS"]["OpenSSLBuilder"] = SCons.Builder.Builder(generator=ssl_generator, emitter=ssl_emitter)
+    env.AddMethod(build_openssl, "OpenSSL")

tools/ssh2.py

@@ -0,0 +1,52 @@
+import os
+
+
+def build_library(env, deps):
+    config = {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo" if env["debug_symbols"] else "Release",
+        "OPENSSL_USE_STATIC_LIBS": 1,
+        "OPENSSL_INCLUDE_DIR": env["SSL_INCLUDE"],
+        "OPENSSL_SSL_LIBRARY": env["SSL_LIBRARY"].abspath,
+        "OPENSSL_CRYPTO_LIBRARY": env["SSL_CRYPTO_LIBRARY"].abspath,
+        "OPENSSL_ROOT_DIR": env["SSL_INSTALL"],
+        "BUILD_EXAMPLES": 0,
+        "BUILD_TESTING": 0,
+        "BUILD_SHARED_LIBS": 0,
+        "CMAKE_DISABLE_FIND_PACKAGE_ZLIB": 1,
+        "CMAKE_DISABLE_FIND_PACKAGE_OPENSSL": 1,
+        "CRYPTO_BACKEND": "OpenSSL",
+    }
+
+    if env["platform"] != "windows":
+        config["CMAKE_C_FLAGS"] = "-fPIC"
+    else:
+        config["OPENSSL_ROOT_DIR"] = env["SSL_BUILD"]
+
+    is_msvc = env.get("is_msvc", False)
+    lib_ext = ".lib" if is_msvc else ".a"
+    libs = ["src/libssh2{}".format(lib_ext)]
+
+    source = env.Dir("#thirdparty/ssh2/libssh2").abspath
+    target = env.Dir("#bin/thirdparty/libssh2").abspath
+
+    ssh2 = env.CMakeBuild(
+        "#bin/thirdparty/ssh2/",
+        "#thirdparty/ssh2/libssh2",
+        cmake_options=config,
+        cmake_outputs=libs,
+        cmake_targets=[],
+        dependencies=deps,
+    )
+
+    env.Append(CPPPATH=["#thirdparty/ssh2/libssh2/include"])
+    env.Prepend(LIBS=ssh2[1:])
+
+    return ssh2
+
+
+def exists(env):
+    return "CMake" in env
+
+
+def generate(env):
+    env.AddMethod(build_library, "BuildSSH2")