Merge pull request #290 from Faless/fix/disable_zlib_detection

ssh2: Disable zlib detection
2026-01-01 01:48:28 +03:00 · 2025-05-31 00:58:30 +02:00 · 2025-05-31 00:43:58 +02:00 · 2025-05-28 23:03:10 +02:00 · 2025-05-28 22:52:21 +02:00 · 2025-05-27 17:29:49 +02:00
32 changed files with 708 additions and 464 deletions
--- a/.gitattributes
+++ b/.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
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -9,9 +9,9 @@ env:

 jobs:
  linux-x64:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Setup Godot build cache
@@ -19,63 +19,76 @@ jobs:
        with:
          cache-name: linux-x86_64
        continue-on-error: true
-      - name: build-linux-editor-x64
+      - name: Build for Linux editor x86_64
        run: |
-          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@v3
+          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@v3
+      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Setup Godot build cache
        uses: ./godot-cpp/.github/actions/godot-cache
        with:
          cache-name: windows-x86_64
-      - uses: actions/setup-python@v2
-        with:
-          python-version: "3.x"
-          architecture: "x64"
-      - uses: ilammy/msvc-dev-cmd@v1
-      - name: build-windows-editor-x64
+      - uses: ilammy/msvc-dev-cmd@v1  # For dumpbin.
+      - uses: ilammy/setup-nasm@v1
+      - name: Build for Windows editor x86_64
+        shell: powershell
        run: |
-          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@v3
+          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@v3
+      - 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-macos-editor-universal
+      - name: Build for macOS editor universal
        run: |
-          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@v3
+          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/
--- a/.github/workflows/clang-format.yml
+++ b/.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
--- a/.gitignore
+++ b/.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
--- a/.gitmodules
+++ b/.gitmodules
@@ -2,10 +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
--- a/README.md
+++ b/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`.

--- a/38
+++ b/38
@@ -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")

--- a/THIRDPARTY.md
+++ b/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

--- a/demo/addons/godot-git-plugin/git_plugin.gdextension
+++ b/demo/addons/godot-git-plugin/git_plugin.gdextension
@@ -1,12 +1,10 @@
 [configuration]

 entry_symbol = "git_plugin_init"
-compatibility_minimum = "4.1.0"
+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"
--- a/build_openssl_universal_macos.sh
+++ b/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
--- a/demo/.gitattributes
+++ b/demo/.gitattributes
@@ -1,2 +0,0 @@
-# Normalize EOL for all files that Git considers text files.
-* text=auto eol=lf
--- a/demo/.gitignore
+++ b/demo/.gitignore
@@ -1,2 +0,0 @@
-# Godot 4+ specific ignores
-.godot/
--- a/demo/addons/godot-git-plugin/plugin.cfg
+++ b/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="3.1.1"
-script="godot-git-plugin.gd"
--- a/demo/demo.tscn
+++ b/demo/demo.tscn
@@ -1,3 +0,0 @@
-[gd_scene format=3 uid="uid://cr5ci1iwmxnlb"]
-
-[node name="Node3D" type="Node3D"]
--- a/demo/new_script.gd
+++ b/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
--- a/demo/project.godot
+++ b/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.1")
-
-[editor]
-
-version_control/plugin_name="GitPlugin"
-version_control/autoload_on_startup=true
-
-[editor_plugins]
-
-enabled=PackedStringArray()
--- a/2
+++ b/2
--- a/godot-git-plugin/SCsub
+++ b/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)
--- a/godot-git-plugin/src/git_callbacks.cpp
+++ b/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: ", godot::String::utf8(progress_str).strip_edges());
-	delete[] progress_str;
+	godot::UtilityFunctions::print("remote: ", godot::String::utf8(str, len).strip_edges());

 	return 0;
 }
@@ -63,7 +59,7 @@ 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;
 }

--- a/release.sh
+++ b/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
--- a/thirdparty/SCsub
+++ b/thirdparty/SCsub
@@ -1,6 +0,0 @@
-#!/usr/bin/env python
-
-Import("env")
-
-SConscript("ssh2/SCsub")
-SConscript("git2/SCsub")
--- a/thirdparty/git2/SCsub
+++ b/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)
--- a/thirdparty/git2/libgit2
+++ b/thirdparty/git2/libgit2
--- a/thirdparty/openssl
+++ b/thirdparty/openssl
--- a/thirdparty/openssl/libcrypto.a
+++ b/thirdparty/openssl/libcrypto.a
--- a/thirdparty/openssl/libssl.a
+++ b/thirdparty/openssl/libssl.a
--- a/thirdparty/ssh2/SCsub
+++ b/thirdparty/ssh2/SCsub
@@ -1,114 +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_kbd_packet.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)
--- a/thirdparty/ssh2/libssh2
+++ b/thirdparty/ssh2/libssh2
--- a/tools/cmake.py
+++ b/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")
--- a/tools/git2.py
+++ b/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")
--- a/tools/openssl.py
+++ b/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")
--- a/tools/ssh2.py
+++ b/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")
Author	SHA1	Message	Date
Rémi Verschelde	b51e8ee42a	Merge pull request #290 from Faless/fix/disable_zlib_detection ssh2: Disable zlib detection	2025-05-31 00:58:30 +02:00
Fabio Alessandrelli	94db3a7c36	ssh2: Disable zlib detection This seems to only be used with the OpenSSL backend (which we plan to drop). libgit2 already use builtin ZLIB, I'm not even sure we if it would be used in libssh2 (we only use libssh2 to provide git ssh access, and git already compress objects.	2025-05-31 00:43:58 +02:00
Rémi Verschelde	179e3ddb00	Merge pull request #289 from akien-mga/misc-fixes Misc fixes and cleanup	2025-05-28 23:03:10 +02:00
Rémi Verschelde	2a4c781e86	Misc fixes and cleanup - Remove the `demo` project which isn't really useful. * Instead the `addons` subfolder is made top-level and that's where stuff gets written. - Update the README following recent PRs (#191, #199) as OpenSSL is now compiled from source for all platforms. * Also remove obsolete `build_openssl_universal_macos.sh` script. - Remove the bogus `plugin.cfg` which isn't necessary, and was confusing users who tried to enable it. * Fixes #267. - Bump min SCons version to 3.1.2 and Python to 3.6. - Bump `compatibility_minimum` to `4.2.0` following #196. - Remove some code in `godot-git-plugin/SCsub` that seems redundant with `godot-cpp` config. - Remove unnecessary `.exp` and `.lib` files in Windows artifact, rename its folder to `windows`. - Remove `export-ignore`s in `.gitattributes`, they're incomplete and not actually doing anything usable. - Fix artifacts URL handling in `release.sh`, make it executable. - CI: Update clang-format check to version 18.	2025-05-28 22:52:21 +02:00
Rémi Verschelde	fd85a8ef39	Merge pull request #288 from akien-mga/ci-cleanup CI: Don't install openssl for macOS + misc cleanup	2025-05-27 17:29:49 +02:00
Rémi Verschelde	f322436f66	CI: Don't install openssl for macOS + misc cleanup	2025-05-27 17:18:41 +02:00
Rémi Verschelde	78d6464745	Merge pull request #286 from Faless/build/force_msvc_lto Force LTO on windows MSVC as libgit2 requires it	2025-05-27 15:38:05 +02:00
Rémi Verschelde	91bb644dd4	Merge pull request #287 from Faless/build/fix_macos_deployment_target Force macOS deployment target for OpenSSL when specified	2025-05-27 14:17:09 +02:00
Rémi Verschelde	1e346f89fa	Merge pull request #285 from Faless/build/fix_libgit_tool Properly specify the `STATIC_CRT` libgit2 flag	2025-05-27 14:01:19 +02:00
Fabio Alessandrelli	9a43d562c0	Force macOS deployment target for OpenSSL when specified	2025-05-27 12:24:54 +02:00
Fabio Alessandrelli	f6f2db53a9	Force LTO on windows MSVC This silences the linker complaining that libgit uses LTO but we are not linking with it.	2025-05-27 12:20:59 +02:00
Fabio Alessandrelli	c7c7822191	Properly specify the STATIC_CRT libgit2 flag libgit2 CMake configuration uses a custom flag `STATIC_CRT` and not the new CMake policy CMP0091. When forcing the CMake policy (as we do in our cmake tool), we need to also set the custom `STATIC_CRT` to avoid compiler warning about the /MD and /MT flag being overridden.	2025-05-27 11:53:22 +02:00
Rémi Verschelde	392b3d6697	Merge pull request #283 from akien-mga/ci-windows-fail-on-error CI: Ensure Windows job fails on error	2025-05-27 10:38:58 +02:00
Rémi Verschelde	51dcc3c455	CI: Ensure Windows job fails on error Default `pwsh` is apparently not properly configured to fail fast, but `powershell` is, whatever is the difference. Minor tweaks to CI setup.	2025-05-27 10:27:17 +02:00
Rémi Verschelde	4fdf03d471	Merge pull request #284 from Faless/fix/win_build Fix Windows MSVC build	2025-05-27 09:36:25 +02:00
Fabio Alessandrelli	1442ac5f0b	Fix Windows MSVC build Update the CMake tool so it respects the use_static_cpp godot-cpp option compiling with the proper CRT. Fix inclusion of secur32 in git2 tool.	2025-05-27 01:24:04 +02:00
Rémi Verschelde	3ab9d035e7	Merge pull request #199 from Faless/build/openssl_and_cmake Use OpenSSL on windows too, build libgit2, ssh2 with cmake.	2025-05-26 18:02:46 +02:00
Fabio Alessandrelli	0d0c30784d	Use OpenSSL on windows too, build libgit2, ssh2 with cmake. And update the libraries.	2025-05-26 17:17:29 +02:00
Rémi Verschelde	ef24a3673d	Merge pull request #191 from Faless/build/openssl [SCons] Build OpenSSL from source.	2025-05-26 17:02:24 +02:00
Fabio Alessandrelli	955ec02503	[SCons] Build OpenSSL from source by default Remove prebuilt static libraries for macOS. Can optionally still use external (static) libraries by supplying the `openssl_external_*` parameters to scons.	2025-05-26 16:57:27 +02:00
Rémi Verschelde	b8d79c3fc9	Merge pull request #246 from dsnopek/godot-cpp-41-branch Update godot-cpp to `godot-4.2-stable`	2025-05-26 16:14:24 +02:00
David Snopek	900e95db82	Update godot-cpp to the latest on the `4.2` branch	2025-05-26 09:02:51 -05:00
Rémi Verschelde	9544fb84ec	Merge pull request #272 from dsnopek/update-ci-versions Update various out-dated versions in CI	2025-05-25 15:41:03 +02:00
David Snopek	edcfc47af0	Update various out-dated versions in CI Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>	2025-05-25 15:29:15 +02:00
Joel Croteau	e86106b8c2	Stop `progress_cb` from generating spurious warnings (#243 ) `progress_cb` is used to give progress updates on pushes and pulls. There is no reason for it to pollute the logs by logging its updates as warnings. Changed these to plain print statements.	2024-07-07 05:15:37 +02:00