rugged 1.4.3 → 1.5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd9e9d1521fe3c4ead7642651af0bbf071c2b076be3144458d8f11abc58a95b3
-  data.tar.gz: 4f1cfdbbd40ec1cf1061a62ee73265b2e3b51b4cdc076096ab90984fa284549d
+  metadata.gz: 2ea6cb574b0ccc0c76c624cae0d3845590b5aef4e1653a604964736f2de1c489
+  data.tar.gz: 0d5bd0607f91187a8c04c0bafa516b5162602d2c29657b5dd1ce6922da06cc22
 SHA512:
-  metadata.gz: 8bb5a3504f11e676cfc01ae0212e8d0e67cd3bf79bf32e73f4d88662e15f1e6997b50ade4cc7cd4d453f55670d921fa00f2feeec17bbfc69e82e31323114a837
-  data.tar.gz: 3c1d68d25b56f587ab5e7532d077cc793feebed4d1d90d25b566c7969c326328d0c96d847f90774c2beb0b33de914b7887b0316a1960cd8620133bdc5e451449
+  metadata.gz: c15f2a343f085539228baeca8d9ba93fa23fb3cfb22cacc9bc4bb8126f6c9082ee81a24f3b338f2f3685927acf88d86832a1645bd37ddbfa70d142c5a3796c14
+  data.tar.gz: 99cef08979f3931643e93bf12490865ecc365b352511fd2bdd3156d98d2ae6bc52e9ab6e449da1c7841a3335b9f6d41733c6fa6083a3404bd2d1f337110d371a

data/README.md

@@ -1,4 +1,4 @@
-# Rugged [![Build Status](https://travis-ci.org/libgit2/rugged.svg?branch=master)](https://travis-ci.org/libgit2/rugged)
+# Rugged [![Rugged CI](https://github.com/libgit2/rugged/actions/workflows/ci.yml/badge.svg)](https://github.com/libgit2/rugged/actions/workflows/ci.yml)
 **libgit2 bindings in Ruby**
 
 Rugged is a library for accessing [libgit2](https://github.com/libgit2/libgit2) in Ruby. It gives you the speed and
@@ -17,21 +17,53 @@ Rugged is a self-contained gem. You can install it by running:
 
     $ gem install rugged
 
-You need to have CMake and `pkg-config` installed on your system to be able to build the included version of `libgit2`. On OS X, after installing [Homebrew](http://brew.sh/), you can get the required packages with:
+## Prerequisites
+You need to have CMake and `pkg-config` installed on your system to be able to build the included version of `libgit2`. 
+
+### Debian, Including Ubuntu
+All Debian-derived Linux distros provide `apt`:
+```bash
+$ sudo apt install libgit2-dev cmake pkg-config
+```
+
+Note that you only need `libgit2-dev` if you want to build with the system
+libgit2 rather than the vendored version. In this case, note that the major and
+minor versions of libgit2 and rugged must match.
+
+### Mac
+On OS X, after installing [Homebrew](http://brew.sh/), you can get the required packages with:
 ```bash
 $ brew install cmake pkg-config
 ```
 
 Please follow the above in case installation of the gem fails with `ERROR: CMake is required to build Rugged.`.
 
+### Options
+
 If you want to build Rugged with HTTPS and SSH support, check out the list of optional [libgit2 dependencies](https://github.com/libgit2/libgit2#optional-dependencies).
 
+To install `rugged` with SSH support ensure you have the `LibSSH2` library present, then pass the required `CMAKE_FLAGS`:
+```bash
+CMAKE_FLAGS='-DUSE_SSH=ON' gem install rugged
+```
+
+Or pass the `--with-ssh` build option:
+```bash
+gem install rugged -- --with-ssh
+```
+
 If you're using bundler and want to bundle `libgit2` with Rugged, you can use the `:submodules` option:
 
 ```ruby
 gem 'rugged', git: 'git://github.com/libgit2/rugged.git', submodules: true
 ```
 
+If you would like to bundle rugged with SSH support add the `--with-ssh` build option to the bundler config:
+```bash
+bundle config build.rugged --with-ssh
+```
+
+## Usage
 To load Rugged, you'll usually want to add something like this:
 
 ```ruby

data/ext/rugged/extconf.rb

@@ -14,8 +14,11 @@ $CFLAGS << " -O3" unless $CFLAGS[/-O\d/]
 $CFLAGS << " -Wall -Wno-comment"
 
 cmake_flags = [ ENV["CMAKE_FLAGS"] ]
+cmake_flags << "-DBUILD_CLI=OFF"
+cmake_flags << "-DBUILD_TESTS=OFF"
 cmake_flags << "-DREGEX_BACKEND=builtin"
 cmake_flags << "-DUSE_SHA1DC=ON" if with_config("sha1dc")
+cmake_flags << "-DUSE_SSH=ON"    if with_config("ssh")
 
 def sys(cmd)
   puts " -- #{cmd}"

data/ext/rugged/rugged.c

@@ -75,6 +75,21 @@ static VALUE rb_git_libgit2_version(VALUE self)
 	return rb_ary_new3(3, INT2NUM(major), INT2NUM(minor), INT2NUM(rev));
 }
 
+/*
+ *  call-seq:
+ *     Rugged.libgit2_prerelease -> prerelease string
+ *
+ *  Returns a string with the prerelease string for libgit2. This will be empty
+ *  for tagged releases.
+ */
+static VALUE rb_git_libgit2_prerelease(VALUE self)
+{
+	const char *prerelease;
+
+	prerelease = git_libgit2_prerelease();
+	return rb_str_new_utf8(prerelease ? prerelease : "");
+}
+
 /*
  *  call-seq:
  *     Rugged.features -> [feature, ...]
@@ -585,6 +600,7 @@ void Init_rugged(void)
 	}
 
 	rb_define_module_function(rb_mRugged, "libgit2_version", rb_git_libgit2_version, 0);
+	rb_define_module_function(rb_mRugged, "libgit2_prerelease", rb_git_libgit2_prerelease, 0);
 	rb_define_module_function(rb_mRugged, "features", rb_git_features, 0);
 	rb_define_module_function(rb_mRugged, "valid_full_oid?", rb_git_valid_full_oid, 1);
 	rb_define_module_function(rb_mRugged, "hex_to_raw", rb_git_hex_to_raw, 1);

data/ext/rugged/rugged.h

@@ -165,6 +165,10 @@ struct rugged_remote_cb_payload
 	int exception;
 };
 
+void rugged_remote_init_custom_headers(VALUE rb_options, git_strarray *custom_headers);
+
+void rugged_remote_init_proxy_options(VALUE rb_options, git_proxy_options *proxy_options);
+
 void rugged_remote_init_callbacks_and_payload_from_options(
 	VALUE rb_options,
 	git_remote_callbacks *callbacks,

data/ext/rugged/rugged_remote.c

@@ -198,7 +198,7 @@ void rugged_remote_init_callbacks_and_payload_from_options(
 	}
 }
 
-static void init_custom_headers(VALUE rb_options, git_strarray *custom_headers)
+void rugged_remote_init_custom_headers(VALUE rb_options, git_strarray *custom_headers)
 {
 	if (!NIL_P(rb_options))
 	{
@@ -207,7 +207,7 @@ static void init_custom_headers(VALUE rb_options, git_strarray *custom_headers)
 	}
 }
 
-static void init_proxy_options(VALUE rb_options, git_proxy_options *proxy_options)
+void rugged_remote_init_proxy_options(VALUE rb_options, git_proxy_options *proxy_options)
 {
 	if (NIL_P(rb_options)) return;
 
@@ -330,8 +330,8 @@ static VALUE rb_git_remote_ls(int argc, VALUE *argv, VALUE self)
 	rb_scan_args(argc, argv, ":", &rb_options);
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
-	init_custom_headers(rb_options, &custom_headers);
-	init_proxy_options(rb_options, &proxy_options);
+	rugged_remote_init_custom_headers(rb_options, &custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &proxy_options);
 
 	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks, &proxy_options, &custom_headers)) ||
 	    (error = git_remote_ls(&heads, &heads_len, remote)))
@@ -535,8 +535,8 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
 		rb_raise(rb_eTypeError, "Invalid direction. Expected :fetch or :push");
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
-	init_custom_headers(rb_options, &custom_headers);
-	init_proxy_options(rb_options, &proxy_options);
+	rugged_remote_init_custom_headers(rb_options, &custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &proxy_options);
 
 	error = git_remote_connect(remote, direction, &callbacks, &proxy_options, &custom_headers);
 	git_remote_disconnect(remote);
@@ -628,8 +628,8 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 	Data_Get_Struct(self, git_remote, remote);
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
-	init_custom_headers(rb_options, &opts.custom_headers);
-	init_proxy_options(rb_options, &opts.proxy_opts);
+	rugged_remote_init_custom_headers(rb_options, &opts.custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &opts.proxy_opts);
 
 	if (!NIL_P(rb_options)) {
 		VALUE rb_prune_type;
@@ -723,8 +723,8 @@ static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self)
 	Data_Get_Struct(self, git_remote, remote);
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
-	init_custom_headers(rb_options, &opts.custom_headers);
-	init_proxy_options(rb_options, &opts.proxy_opts);
+	rugged_remote_init_custom_headers(rb_options, &opts.custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &opts.proxy_opts);
 	init_pb_parallelism(rb_options, &opts);
 
 	error = git_remote_push(remote, &refspecs, &opts);

data/ext/rugged/rugged_repo.c

@@ -528,14 +528,9 @@ static void parse_clone_options(git_clone_options *ret, VALUE rb_options, struct
 		ret->checkout_branch = StringValueCStr(val);
 	}
 
-	val = rb_hash_aref(rb_options, CSTR2SYM("proxy_url"));
-	if (!NIL_P(val)) {
-		Check_Type(val, T_STRING);
-		ret->fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
-		ret->fetch_opts.proxy_opts.url = StringValueCStr(val);
-	}
-
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &ret->fetch_opts.callbacks, remote_payload);
+	rugged_remote_init_custom_headers(rb_options, &ret->fetch_opts.custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &ret->fetch_opts.proxy_opts);
 }
 
 /*

data/ext/rugged/rugged_settings.c

@@ -86,6 +86,11 @@ static VALUE rb_git_set_option(VALUE self, VALUE option, VALUE value)
 		git_libgit2_opts(GIT_OPT_ENABLE_STRICT_OBJECT_CREATION, strict);
 	}
 
+	else if (strcmp(opt, "fsync_gitdir") == 0) {
+		int fsync = RTEST(value) ? 1 : 0;
+		git_libgit2_opts(GIT_OPT_ENABLE_FSYNC_GITDIR, fsync);
+	}
+
 	else {
 		rb_raise(rb_eArgError, "Unknown option specified");
 	}

data/lib/rugged/tree.rb

@@ -172,21 +172,25 @@ module Rugged
 
     # Walks the tree but only yields blobs
     def walk_blobs(mode=:postorder)
+      return to_enum(__method__) unless block_given?
       self.walk(mode) { |root, e| yield root, e if e[:type] == :blob }
     end
 
     # Walks the tree but only yields subtrees
     def walk_trees(mode=:postorder)
+      return to_enum(__method__) unless block_given?
       self.walk(mode) { |root, e| yield root, e if e[:type] == :tree }
     end
 
     # Iterate over the blobs in this tree
     def each_blob
+      return to_enum(__method__) unless block_given?
       self.each { |e| yield e if e[:type] == :blob }
     end
 
     # Iterate over the subtrees in this tree
     def each_tree
+      return to_enum(__method__) unless block_given?
       self.each { |e| yield e if e[:type] == :tree }
     end
   end

data/lib/rugged/version.rb

@@ -4,5 +4,5 @@
 # For full terms see the included LICENSE file.
 
 module Rugged
-  Version = VERSION = '1.4.3'
+  Version = VERSION = '1.5.0.1'
 end

data/vendor/libgit2/CMakeLists.txt

@@ -1,9 +1,12 @@
-# CMake build script for the libgit2 project
+# libgit2: the cross-platform, linkable library implementation of git.
 # See `README.md` for build instructions.
+#
+# This top-level CMakeLists.txt sets up configuration options and
+# determines which subprojects to build.
 
 cmake_minimum_required(VERSION 3.5.1)
 
-project(libgit2 VERSION "1.4.3" LANGUAGES C)
+project(libgit2 VERSION "1.5.0" LANGUAGES C)
 
 # Add find modules to the path
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake")
@@ -15,6 +18,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake")
 # Optional subsystems
 option(BUILD_SHARED_LIBS       "Build Shared Library (OFF for Static)"                  ON)
 option(BUILD_TESTS             "Build Tests using the Clar suite"                       ON)
+option(BUILD_CLI               "Build the command-line interface"                       ON)
 option(BUILD_EXAMPLES          "Build library usage example apps"                      OFF)
 option(BUILD_FUZZERS           "Build the fuzz targets"                                OFF)
 
@@ -25,7 +29,8 @@ option(USE_NSEC                "Support nanosecond precision file mtimes and cti
 # Backend selection
 option(USE_SSH                 "Link with libssh2 to enable SSH support"               OFF)
 option(USE_HTTPS               "Enable HTTPS support. Can be set to a specific backend" ON)
-option(USE_SHA1                "Enable SHA1. Can be set to CollisionDetection(ON)/HTTPS/Generic" ON)
+option(USE_SHA1                "Enable SHA1. Can be set to CollisionDetection(ON)/HTTPS" ON)
+option(USE_SHA256              "Enable SHA256. Can be set to HTTPS/Builtin" ON)
 option(USE_GSSAPI              "Link with libgssapi for SPNEGO auth"      OFF)
    set(USE_HTTP_PARSER         "" CACHE STRING "Specifies the HTTP Parser implementation; either system or builtin.")
    set(REGEX_BACKEND           "" CACHE STRING "Regular expression implementation. One of regcomp_l, pcre2, pcre, regcomp, or builtin.")
@@ -127,6 +132,14 @@ if(BUILD_FUZZERS)
 endif()
 
 
+# Export for people who use us as a dependency
+
+if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}")
+	set(LIBGIT2_DEPENDENCY_OBJECTS ${LIBGIT2_DEPENDENCY_OBJECTS} PARENT_SCOPE)
+	set(LIBGIT2_SYSTEM_LIBS ${LIBGIT2_SYSTEM_LIBS} PARENT_SCOPE)
+endif()
+
+
 # Summary
 
 feature_summary(WHAT ENABLED_FEATURES DESCRIPTION "Enabled features:")

data/vendor/libgit2/COPYING

@@ -1144,3 +1144,43 @@ worldwide. This software is distributed without any warranty.
 
 See <http://creativecommons.org/publicdomain/zero/1.0/>.
 
+----------------------------------------------------------------------
+
+The built-in SHA256 support (src/hash/rfc6234) is taken from RFC 6234
+under the following license:
+
+Copyright (c) 2011 IETF Trust and the persons identified as
+authors of the code.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the following
+conditions are met:
+
+- Redistributions of source code must retain the above
+  copyright notice, this list of conditions and
+  the following disclaimer.
+
+- Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the following
+  disclaimer in the documentation and/or other materials provided
+  with the distribution.
+
+- Neither the name of Internet Society, IETF or IETF Trust, nor
+  the names of specific contributors, may be used to endorse or
+  promote products derived from this software without specific
+  prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/vendor/libgit2/cmake/AddClarTest.cmake

@@ -0,0 +1,7 @@
+function(ADD_CLAR_TEST project name)
+        if(NOT USE_LEAK_CHECKER STREQUAL "OFF")
+                add_test(${name} "${PROJECT_SOURCE_DIR}/script/${USE_LEAK_CHECKER}.sh" "${PROJECT_BINARY_DIR}/${project}" ${ARGN})
+        else()
+                add_test(${name} "${PROJECT_BINARY_DIR}/${project}" ${ARGN})
+        endif()
+endfunction(ADD_CLAR_TEST)

data/vendor/libgit2/cmake/FindPCRE.cmake

@@ -16,19 +16,18 @@
 # PCRE_FOUND	- True if pcre found.
 
 # Look for the header file.
-find_path(PCRE_INCLUDE_DIR NAMES pcreposix.h)
+find_path(PCRE_INCLUDE_DIR NAMES pcre.h)
 
 # Look for the library.
 find_library(PCRE_LIBRARY NAMES pcre)
-find_library(PCRE_POSIX_LIBRARY NAMES pcreposix)
 
 # Handle the QUIETLY and REQUIRED arguments and set PCRE_FOUND to TRUE if all listed variables are TRUE.
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(PCRE DEFAULT_MSG PCRE_LIBRARY PCRE_POSIX_LIBRARY PCRE_INCLUDE_DIR)
+find_package_handle_standard_args(PCRE DEFAULT_MSG PCRE_LIBRARY PCRE_INCLUDE_DIR)
 
 # Copy the results to the output variables.
 if(PCRE_FOUND)
-	set(PCRE_LIBRARIES ${PCRE_LIBRARY} ${PCRE_POSIX_LIBRARY})
+	set(PCRE_LIBRARIES ${PCRE_LIBRARY})
 	set(PCRE_INCLUDE_DIRS ${PCRE_INCLUDE_DIR})
 else(PCRE_FOUND)
 	set(PCRE_LIBRARIES)

data/vendor/libgit2/cmake/FindPCRE2.cmake

@@ -16,7 +16,7 @@
 # PCRE2_FOUND	- True if pcre found.
 
 # Look for the header file.
-find_path(PCRE2_INCLUDE_DIR NAMES pcre2posix.h)
+find_path(PCRE2_INCLUDE_DIR NAMES pcre2.h)
 
 # Look for the library.
 find_library(PCRE2_LIBRARY NAMES pcre2-8)

data/vendor/libgit2/cmake/SelectHTTPSBackend.cmake

@@ -64,7 +64,7 @@ if(USE_HTTPS)
 
 		if(NOT CERT_LOCATION)
 			message(STATUS "Auto-detecting default certificates location")
-			if(CMAKE_SYSTEM_NAME MATCHES Darwin)
+			if(EXISTS "/usr/local/opt/openssl/bin/openssl")
 				# Check for an Homebrew installation
 				set(OPENSSL_CMD "/usr/local/opt/openssl/bin/openssl")
 			else()

data/vendor/libgit2/cmake/SelectHashes.cmake

@@ -4,6 +4,9 @@ include(SanitizeBool)
 
 # USE_SHA1=CollisionDetection(ON)/HTTPS/Generic/OFF
 sanitizebool(USE_SHA1)
+sanitizebool(USE_SHA256)
+
+# sha1
 
 if(USE_SHA1 STREQUAL ON)
 	SET(USE_SHA1 "CollisionDetection")
@@ -21,32 +24,77 @@ endif()
 
 if(USE_SHA1 STREQUAL "CollisionDetection")
 	set(GIT_SHA1_COLLISIONDETECT 1)
-	add_definitions(-DSHA1DC_NO_STANDARD_INCLUDES=1)
-	add_definitions(-DSHA1DC_CUSTOM_INCLUDE_SHA1_C=\"common.h\")
-	add_definitions(-DSHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C=\"common.h\")
 elseif(USE_SHA1 STREQUAL "OpenSSL")
-	# OPENSSL_FOUND should already be set, we're checking USE_HTTPS
-
 	set(GIT_SHA1_OPENSSL 1)
+elseif(USE_SHA1 STREQUAL "OpenSSL-Dynamic")
+	set(GIT_SHA1_OPENSSL 1)
+	set(GIT_SHA1_OPENSSL_DYNAMIC 1)
+	list(APPEND LIBGIT2_SYSTEM_LIBS dl)
+elseif(USE_SHA1 STREQUAL "CommonCrypto")
+	set(GIT_SHA1_COMMON_CRYPTO 1)
+elseif(USE_SHA1 STREQUAL "mbedTLS")
+	set(GIT_SHA1_MBEDTLS 1)
+elseif(USE_SHA1 STREQUAL "Win32")
+	set(GIT_SHA1_WIN32 1)
+else()
+	message(FATAL_ERROR "Asked for unknown SHA1 backend: ${USE_SHA1}")
+endif()
+
+# sha256
+
+if(USE_SHA256 STREQUAL ON AND USE_HTTPS)
+	SET(USE_SHA256 "HTTPS")
+elseif(USE_SHA256 STREQUAL ON)
+	SET(USE_SHA256 "Builtin")
+endif()
+
+if(USE_SHA256 STREQUAL "HTTPS")
+	if(USE_HTTPS STREQUAL "SecureTransport")
+		set(USE_SHA256 "CommonCrypto")
+	elseif(USE_HTTPS STREQUAL "WinHTTP")
+		set(USE_SHA256 "Win32")
+	elseif(USE_HTTPS)
+		set(USE_SHA256 ${USE_HTTPS})
+	endif()
+endif()
+
+if(USE_SHA256 STREQUAL "Builtin")
+	set(GIT_SHA256_BUILTIN 1)
+elseif(USE_SHA256 STREQUAL "OpenSSL")
+	set(GIT_SHA256_OPENSSL 1)
+elseif(USE_SHA256 STREQUAL "OpenSSL-Dynamic")
+	set(GIT_SHA256_OPENSSL 1)
+	set(GIT_SHA256_OPENSSL_DYNAMIC 1)
+	list(APPEND LIBGIT2_SYSTEM_LIBS dl)
+elseif(USE_SHA256 STREQUAL "CommonCrypto")
+	set(GIT_SHA256_COMMON_CRYPTO 1)
+elseif(USE_SHA256 STREQUAL "mbedTLS")
+	set(GIT_SHA256_MBEDTLS 1)
+elseif(USE_SHA256 STREQUAL "Win32")
+	set(GIT_SHA256_WIN32 1)
+else()
+	message(FATAL_ERROR "Asked for unknown SHA256 backend: ${USE_SHA256}")
+endif()
+
+# add library requirements
+if(USE_SHA1 STREQUAL "OpenSSL" OR USE_SHA256 STREQUAL "OpenSSL")
 	if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 		list(APPEND LIBGIT2_PC_LIBS "-lssl")
 	else()
 		list(APPEND LIBGIT2_PC_REQUIRES "openssl")
 	endif()
-elseif(USE_SHA1 STREQUAL "CommonCrypto")
-	set(GIT_SHA1_COMMON_CRYPTO 1)
-elseif(USE_SHA1 STREQUAL "mbedTLS")
-	set(GIT_SHA1_MBEDTLS 1)
+endif()
+
+if(USE_SHA1 STREQUAL "mbedTLS" OR USE_SHA256 STREQUAL "mbedTLS")
 	list(APPEND LIBGIT2_SYSTEM_INCLUDES ${MBEDTLS_INCLUDE_DIR})
 	list(APPEND LIBGIT2_SYSTEM_LIBS ${MBEDTLS_LIBRARIES})
 	# mbedTLS has no pkgconfig file, hence we can't require it
 	# https://github.com/ARMmbed/mbedtls/issues/228
 	# For now, pass its link flags as our own
 	list(APPEND LIBGIT2_PC_LIBS ${MBEDTLS_LIBRARIES})
-elseif(USE_SHA1 STREQUAL "Win32")
-	set(GIT_SHA1_WIN32 1)
-elseif(NOT (USE_SHA1 STREQUAL "Generic"))
-	message(FATAL_ERROR "Asked for unknown SHA1 backend: ${USE_SHA1}")
 endif()
 
-add_feature_info(SHA ON "using ${USE_SHA1}")
+# notify feature enablement
+
+add_feature_info(SHA1 ON "using ${USE_SHA1}")
+add_feature_info(SHA256 ON "using ${USE_SHA256}")

data/vendor/libgit2/deps/ntlmclient/crypt_openssl.c

@@ -44,7 +44,9 @@ static inline void HMAC_CTX_free(HMAC_CTX *ctx)
 
 #endif
 
-#if (OPENSSL_VERSION_NUMBER >= 0x10100000L && !LIBRESSL_VERSION_NUMBER) || defined(CRYPT_OPENSSL_DYNAMIC)
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)) || \
+	(defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER >= 0x03050000fL) || \
+	defined(CRYPT_OPENSSL_DYNAMIC)
 
 static inline void HMAC_CTX_cleanup(HMAC_CTX *ctx)
 {

data/vendor/libgit2/deps/zlib/adler32.c

@@ -177,3 +177,10 @@ uLong ZEXPORT adler32_combine(adler1, adler2, len2)
     return adler32_combine_(adler1, adler2, len2);
 }
 
+uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off64_t len2;
+{
+    return adler32_combine_(adler1, adler2, len2);
+}