sha256: make sha256 an experimental optional feature

libgit2 can be built with optional, experimental sha256 support. This
allows consumers to begin testing and providing feedback for our sha256
support while we continue to develop it, and allows us to make API
breaking changes while we iterate on a final sha256 implementation.

The results will be `git2-experimental.dll` and installed as
`git2-experimental.h` to avoid confusion with a production libgit2.

CMakeLists.txt

@@ -15,6 +15,9 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake")
 # Build options
 #
 
+# Experimental features
+option(EXPERIMENTAL_SHA256     "Enable experimental SHA256 support (for R&D/testing)"  OFF)
+
 # Optional subsystems
 option(BUILD_SHARED_LIBS       "Build Shared Library (OFF for Static)"                  ON)
 option(BUILD_TESTS             "Build Tests using the Clar suite"                       ON)
@@ -107,6 +110,7 @@ include(IdeSplitSources)
 include(FeatureSummary)
 include(EnableWarnings)
 include(DefaultCFlags)
+include(ExperimentalFeatures)
 
 
 #

cmake/ExperimentalFeatures.cmake

+if(EXPERIMENTAL_SHA256)
+	add_feature_info("SHA256 API" ON "experimental SHA256 APIs")
+
+	set(EXPERIMENTAL 1)
+	set(GIT_EXPERIMENTAL_SHA256 1)
+else()
+	add_feature_info("SHA256 API" OFF "experimental SHA256 APIs")
+endif()
+
+if(EXPERIMENTAL)
+	set(LIBGIT2_FILENAME "${LIBGIT2_FILENAME}-experimental")
+endif()

include/git2.h

@@ -28,6 +28,7 @@
 #include "git2/diff.h"
 #include "git2/email.h"
 #include "git2/errors.h"
+#include "git2/experimental.h"
 #include "git2/filter.h"
 #include "git2/global.h"
 #include "git2/graph.h"

include/git2/deprecated.h

@@ -777,6 +777,12 @@ typedef git_trace_cb git_trace_callback;
  */
 /**@{*/
 
+#ifndef GIT_EXPERIMENTAL_SHA256
+# define GIT_OID_RAWSZ    GIT_OID_SHA1_SIZE
+# define GIT_OID_HEXSZ    GIT_OID_SHA1_HEXSIZE
+# define GIT_OID_HEX_ZERO GIT_OID_SHA1_HEXZERO
+#endif
+
 GIT_EXTERN(int) git_oid_iszero(const git_oid *id);
 
 /**@}*/

include/git2/oid.h

@@ -9,6 +9,7 @@
 
 #include "common.h"
 #include "types.h"
+#include "experimental.h"
 
 /**
  * @file git2/oid.h
@@ -21,22 +22,74 @@ GIT_BEGIN_DECL
 
 /** The type of object id. */
 typedef enum {
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 	GIT_OID_SHA1 = 1,  /**< SHA1 */
 	GIT_OID_SHA256 = 2 /**< SHA256 */
+#else
+	GIT_OID_SHA1 = 1   /**< SHA1 */
+#endif
+
 } git_oid_t;
 
+/*
+ * SHA1 is currently the only supported object ID type.
+ */
+
 /** SHA1 is currently libgit2's default oid type. */
 #define GIT_OID_DEFAULT         GIT_OID_SHA1
 
-/** Size (in bytes) of a raw/binary oid */
+/** Size (in bytes) of a raw/binary sha1 oid */
 #define GIT_OID_SHA1_SIZE       20
-#define GIT_OID_SHA256_SIZE     32
-#define GIT_OID_MAX_SIZE        GIT_OID_SHA256_SIZE
-
-/** Size (in bytes) of a hex formatted oid */
+/** Size (in bytes) of a hex formatted sha1 oid */
 #define GIT_OID_SHA1_HEXSIZE   (GIT_OID_SHA1_SIZE * 2)
-#define GIT_OID_SHA256_HEXSIZE (GIT_OID_SHA256_SIZE * 2)
-#define GIT_OID_MAX_HEXSIZE     GIT_OID_SHA256_HEXSIZE
+
+/**
+ * The binary representation of the null sha1 object ID.
+ */
+#ifndef GIT_EXPERIMENTAL_SHA256
+# define GIT_OID_SHA1_ZERO   { { 0 } }
+#else
+# define GIT_OID_SHA1_ZERO   { GIT_OID_SHA1, { 0 } }
+#endif
+
+/**
+ * The string representation of the null sha1 object ID.
+ */
+#define GIT_OID_SHA1_HEXZERO   "0000000000000000000000000000000000000000"
+
+/*
+ * Experimental SHA256 support is a breaking change to the API.
+ * This exists for application compatibility testing.
+ */
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+
+/** Size (in bytes) of a raw/binary sha256 oid */
+# define GIT_OID_SHA256_SIZE     32
+/** Size (in bytes) of a hex formatted sha256 oid */
+# define GIT_OID_SHA256_HEXSIZE (GIT_OID_SHA256_SIZE * 2)
+
+/**
+ * The binary representation of the null sha256 object ID.
+ */
+# define GIT_OID_SHA256_ZERO { GIT_OID_SHA256, { 0 } }
+
+/**
+ * The string representation of the null sha256 object ID.
+ */
+# define GIT_OID_SHA256_HEXZERO "0000000000000000000000000000000000000000000000000000000000000000"
+
+#endif
+
+/* Maximum possible object ID size in raw / hex string format. */
+#ifndef GIT_EXPERIMENTAL_SHA256
+# define GIT_OID_MAX_SIZE        GIT_OID_SHA1_SIZE
+# define GIT_OID_MAX_HEXSIZE     GIT_OID_SHA1_HEXSIZE
+#else
+# define GIT_OID_MAX_SIZE        GIT_OID_SHA256_SIZE
+# define GIT_OID_MAX_HEXSIZE     GIT_OID_SHA256_HEXSIZE
+#endif
 
 /** Minimum length (in number of hex characters,
  * i.e. packets of 4 bits) of an oid prefix */
@@ -44,26 +97,17 @@ typedef enum {
 
 /** Unique identity of any object (commit, tree, blob, tag). */
 typedef struct git_oid {
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 	/** type of object id */
 	unsigned char type;
+#endif
 
 	/** raw binary formatted id */
 	unsigned char id[GIT_OID_MAX_SIZE];
 } git_oid;
 
 /**
- * The binary representation of the null object ID.
- */
-#define GIT_OID_SHA1_ZERO   { GIT_OID_SHA1,   { 0 } }
-#define GIT_OID_SHA256_ZERO { GIT_OID_SHA256, { 0 } }
-
-/**
- * The string representation of the null object ID.
- */
-#define GIT_OID_SHA1_HEXZERO   "0000000000000000000000000000000000000000"
-#define GIT_OID_SHA256_HEXZERO "0000000000000000000000000000000000000000000000000000000000000000"
-
-/**
  * Parse a hex formatted object id into a git_oid.
  *
  * The appropriate number of bytes for the given object ID type will

src/cli/CMakeLists.txt

 set(CLI_INCLUDES
 	"${libgit2_BINARY_DIR}/src/util"
+	"${libgit2_BINARY_DIR}/include"
+	"${libgit2_BINARY_DIR}/include/git2"
 	"${libgit2_SOURCE_DIR}/src/util"
 	"${libgit2_SOURCE_DIR}/src/cli"
 	"${libgit2_SOURCE_DIR}/include")
@@ -39,6 +41,7 @@ target_link_libraries(git2_cli ${CLI_LIBGIT2_LIBRARY} ${LIBGIT2_SYSTEM_LIBS})
 
 set_target_properties(git2_cli PROPERTIES C_STANDARD 90)
 set_target_properties(git2_cli PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${libgit2_BINARY_DIR})
+set_target_properties(git2_cli PROPERTIES OUTPUT_NAME ${LIBGIT2_FILENAME})
 
 ide_split_sources(git2_cli)
 

src/libgit2/CMakeLists.txt

@@ -9,6 +9,8 @@ include(PkgBuildConfig)
 
 set(LIBGIT2_INCLUDES
 	"${PROJECT_BINARY_DIR}/src/util"
+	"${PROJECT_BINARY_DIR}/include"
+	"${PROJECT_BINARY_DIR}/include/git2"
 	"${PROJECT_SOURCE_DIR}/src/libgit2"
 	"${PROJECT_SOURCE_DIR}/src/util"
 	"${PROJECT_SOURCE_DIR}/include")
@@ -109,7 +111,7 @@ if(SONAME)
 	endif()
 endif()
 
-pkg_build_config(NAME libgit2
+pkg_build_config(NAME "${LIBGIT2_FILENAME}"
 	VERSION ${libgit2_VERSION}
 	DESCRIPTION "The git library, take 2"
 	LIBS_SELF git2
@@ -122,10 +124,26 @@ if(MSVC_IDE)
 	set_source_files_properties(win32/precompiled.c COMPILE_FLAGS "/Ycprecompiled.h")
 endif()
 
+# support experimental features and functionality
+
+configure_file(experimental.h.in "${PROJECT_BINARY_DIR}/include/git2/experimental.h")
+
+# translate filenames in the git2.h so that they match the install directory
+# (allows for side-by-side installs of libgit2 and libgit2-experimental.)
+
+FILE(READ "${PROJECT_SOURCE_DIR}/include/git2.h" LIBGIT2_INCLUDE)
+STRING(REGEX REPLACE "#include \"git2\/" "#include \"${LIBGIT2_FILENAME}/" LIBGIT2_INCLUDE "${LIBGIT2_INCLUDE}")
+FILE(WRITE "${PROJECT_BINARY_DIR}/include/${LIBGIT2_FILENAME}.h" ${LIBGIT2_INCLUDE})
+
 # Install
+
 install(TARGETS libgit2package
 	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/git2 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(FILES ${PROJECT_SOURCE_DIR}/include/git2.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/git2/
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${LIBGIT2_FILENAME}")
+install(FILES ${PROJECT_BINARY_DIR}/include/git2/experimental.h
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${LIBGIT2_FILENAME}")
+install(FILES "${PROJECT_BINARY_DIR}/include/${LIBGIT2_FILENAME}.h"
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

src/libgit2/diff.c

@@ -381,7 +381,10 @@ int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opt
 	if ((error = (flush_hunk(&args.result, &args.ctx))) < 0)
 		goto out;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 	args.result.type = GIT_OID_SHA1;
+#endif
+
 	git_oid_cpy(out, &args.result);
 
 out:

src/libgit2/experimental.h.in

+#ifndef INCLUDE_experimental_h__
+#define INCLUDE_experimental_h__
+
+#cmakedefine GIT_EXPERIMENTAL_SHA256 1
+
+#endif

src/libgit2/indexer.c

@@ -444,7 +444,10 @@ static int store_object(git_indexer *idx)
 		git__free(pentry);
 		goto on_error;
 	}
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 	oid.type = GIT_OID_SHA1;
+#endif
 
 	entry_size = idx->off - entry_start;
 	if (entry_start > UINT31_MAX) {

src/libgit2/object.c

@@ -520,7 +520,10 @@ static int git_object__short_id(git_str *out, const git_object *obj)
 		memcpy(&id.id, &obj->cached.oid.id, (len + 1) / 2);
 		if (len & 1)
 			id.id[len / 2] &= 0xf0;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 		id.type = GIT_OID_SHA1;
+#endif
 
 		error = git_odb_exists_prefix(NULL, odb, &id, len);
 		if (error != GIT_EAMBIGUOUS)
@@ -635,7 +638,7 @@ int git_object__write_oid_header(
 	const char *header,
 	const git_oid *oid)
 {
-	size_t hex_size = git_oid_hexsize(oid->type);
+	size_t hex_size = git_oid_hexsize(git_oid_type(oid));
 	char hex_oid[GIT_OID_MAX_HEXSIZE];
 
 	if (!hex_size) {

src/libgit2/odb.c

@@ -140,7 +140,10 @@ int git_odb__hashobj(git_oid *id, git_rawobj *obj, git_oid_t oid_type)
 	vec[1].data = obj->data;
 	vec[1].len = obj->len;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 	id->type = oid_type;
+#endif
+
 	return git_hash_vec(id->id, vec, 2, algorithm);
 }
 
@@ -254,7 +257,10 @@ int git_odb__hashfd(
 	}
 
 	error = git_hash_final(out->id, &ctx);
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 	out->type = oid_type;
+#endif
 
 done:
 	git_hash_ctx_cleanup(&ctx);
@@ -1332,7 +1338,7 @@ int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
 		error = odb_read_1(out, db, id, true);
 
 	if (error == GIT_ENOTFOUND)
-		return git_odb__error_notfound("no match for id", id, git_oid_hexsize(id->type));
+		return git_odb__error_notfound("no match for id", id, git_oid_hexsize(git_oid_type(id)));
 
 	return error;
 }
@@ -1679,7 +1685,10 @@ int git_odb_stream_finalize_write(git_oid *out, git_odb_stream *stream)
 			"stream_finalize_write()");
 
 	git_hash_final(out->id, stream->hash_ctx);
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 	out->type = stream->oid_type;
+#endif
 
 	if (git_odb__freshen(stream->backend->odb, out))
 		return 0;
@@ -1858,8 +1867,8 @@ int git_odb__error_mismatch(const git_oid *expected, const git_oid *actual)
 	char expected_oid[GIT_OID_MAX_HEXSIZE + 1],
 	     actual_oid[GIT_OID_MAX_HEXSIZE + 1];
 
-	git_oid_tostr(expected_oid, git_oid_hexsize(expected->type) + 1, expected);
-	git_oid_tostr(actual_oid, git_oid_hexsize(actual->type) + 1, actual);
+	git_oid_tostr(expected_oid, git_oid_hexsize(git_oid_type(expected)) + 1, expected);
+	git_oid_tostr(actual_oid, git_oid_hexsize(git_oid_type(actual)) + 1, actual);
 
 	git_error_set(GIT_ERROR_ODB, "object hash mismatch - expected %s but got %s",
 		expected_oid, actual_oid);

src/libgit2/odb_loose.c

@@ -737,7 +737,9 @@ GIT_INLINE(int) filename_to_oid(struct loose_backend *backend, git_oid *oid, con
 		oid->id[1 + i/2] = (unsigned char) v;
 	}
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 	oid->type = backend->options.oid_type;
+#endif
 
 	return 0;
 }

src/libgit2/oid.c

@@ -14,13 +14,13 @@
 #include <limits.h>
 
 const git_oid git_oid__empty_blob_sha1 =
-	{ GIT_OID_SHA1,
+	GIT_OID_INIT(GIT_OID_SHA1,
 	  { 0xe6, 0x9d, 0xe2, 0x9b, 0xb2, 0xd1, 0xd6, 0x43, 0x4b, 0x8b,
-	    0x29, 0xae, 0x77, 0x5a, 0xd8, 0xc2, 0xe4, 0x8c, 0x53, 0x91 }};
+	    0x29, 0xae, 0x77, 0x5a, 0xd8, 0xc2, 0xe4, 0x8c, 0x53, 0x91 });
 const git_oid git_oid__empty_tree_sha1 =
-	{ GIT_OID_SHA1,
+	GIT_OID_INIT(GIT_OID_SHA1,
 	  { 0x4b, 0x82, 0x5d, 0xc6, 0x42, 0xcb, 0x6e, 0xb9, 0xa0, 0x60,
-	    0xe5, 0x4b, 0xf8, 0xd6, 0x92, 0x88, 0xfb, 0xee, 0x49, 0x04 }};
+	    0xe5, 0x4b, 0xf8, 0xd6, 0x92, 0x88, 0xfb, 0xee, 0x49, 0x04 });
 
 static int oid_error_invalid(const char *msg)
 {
@@ -49,7 +49,9 @@ int git_oid_fromstrn(
 	if (length > git_oid_hexsize(type))
 		return oid_error_invalid("too long");
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 	out->type = type;
+#endif
 	memset(out->id, 0, size);
 
 	for (p = 0; p < length; p++) {
@@ -82,7 +84,7 @@ int git_oid_nfmt(char *str, size_t n, const git_oid *oid)
 		return 0;
 	}
 
-	if (!(hex_size = git_oid_hexsize(oid->type)))
+	if (!(hex_size = git_oid_hexsize(git_oid_type(oid))))
 		return oid_error_invalid("unknown type");
 
 	if (n > hex_size) {
@@ -96,14 +98,14 @@ int git_oid_nfmt(char *str, size_t n, const git_oid *oid)
 
 int git_oid_fmt(char *str, const git_oid *oid)
 {
-	return git_oid_nfmt(str, git_oid_hexsize(oid->type), oid);
+	return git_oid_nfmt(str, git_oid_hexsize(git_oid_type(oid)), oid);
 }
 
 int git_oid_pathfmt(char *str, const git_oid *oid)
 {
 	size_t hex_size;
 
-	if (!(hex_size = git_oid_hexsize(oid->type)))
+	if (!(hex_size = git_oid_hexsize(git_oid_type(oid))))
 		return oid_error_invalid("unknown type");
 
 	git_oid_fmt_substr(str, oid, 0, 2);
@@ -115,13 +117,13 @@ int git_oid_pathfmt(char *str, const git_oid *oid)
 char *git_oid_tostr_s(const git_oid *oid)
 {
 	char *str = GIT_THREADSTATE->oid_fmt;
-	git_oid_nfmt(str, git_oid_hexsize(oid->type) + 1, oid);
+	git_oid_nfmt(str, git_oid_hexsize(git_oid_type(oid)) + 1, oid);
 	return str;
 }
 
 char *git_oid_allocfmt(const git_oid *oid)
 {
-	size_t hex_size = git_oid_hexsize(oid->type);
+	size_t hex_size = git_oid_hexsize(git_oid_type(oid));
 	char *str = git__malloc(hex_size + 1);
 
 	if (!hex_size || !str)
@@ -142,7 +144,7 @@ char *git_oid_tostr(char *out, size_t n, const git_oid *oid)
 	if (!out || n == 0)
 		return "";
 
-	hex_size = oid ? git_oid_hexsize(oid->type) : 0;
+	hex_size = oid ? git_oid_hexsize(git_oid_type(oid)) : 0;
 
 	if (n > hex_size + 1)
 		n = hex_size + 1;
@@ -160,7 +162,9 @@ int git_oid_fromraw(git_oid *out, const unsigned char *raw, git_oid_t type)
 	if (!(size = git_oid_size(type)))
 		return oid_error_invalid("unknown type");
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 	out->type = type;
+#endif
 	memcpy(out->id, raw, size);
 	return 0;
 }
@@ -169,10 +173,13 @@ int git_oid_cpy(git_oid *out, const git_oid *src)
 {
 	size_t size;
 
-	if (!(size = git_oid_size(src->type)))
+	if (!(size = git_oid_size(git_oid_type(src))))
 		return oid_error_invalid("unknown type");
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 	out->type = src->type;
+#endif
+
 	return git_oid_raw_cpy(out->id, src->id, size);
 }
 
@@ -188,8 +195,10 @@ int git_oid_equal(const git_oid *a, const git_oid *b)
 
 int git_oid_ncmp(const git_oid *oid_a, const git_oid *oid_b, size_t len)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	if (oid_a->type != oid_b->type)
 		return oid_a->type - oid_b->type;
+#endif
 
 	return git_oid_raw_ncmp(oid_a->id, oid_b->id, len);
 }
@@ -198,7 +207,7 @@ int git_oid_strcmp(const git_oid *oid_a, const char *str)
 {
 	const unsigned char *a;
 	unsigned char strval;
-	long size = (long)git_oid_size(oid_a->type);
+	long size = (long)git_oid_size(git_oid_type(oid_a));
 	int hexval;
 
 	for (a = oid_a->id; *str && (a - oid_a->id) < size; ++a) {
@@ -225,12 +234,14 @@ int git_oid_streq(const git_oid *oid_a, const char *str)
 int git_oid_is_zero(const git_oid *oid_a)
 {
 	const unsigned char *a = oid_a->id;
-	size_t size = git_oid_size(oid_a->type), i;
+	size_t size = git_oid_size(git_oid_type(oid_a)), i;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 	if (!oid_a->type)
 		return 1;
 	else if (!size)
 		return 0;
+#endif
 
 	for (i = 0; i < size; ++i, ++a)
 		if (*a != 0)

src/libgit2/oid.h

@@ -9,21 +9,42 @@
 
 #include "common.h"
 
+#include "git2/experimental.h"
 #include "git2/oid.h"
 #include "hash.h"
 
-#define GIT_OID_NONE { 0, { 0 } }
+#ifdef GIT_EXPERIMENTAL_SHA256
+# define GIT_OID_NONE { 0, { 0 } }
+# define GIT_OID_INIT(type, ...) { type, __VA_ARGS__ }
+#else
+# define GIT_OID_NONE { { 0 } }
+# define GIT_OID_INIT(type, ...) { __VA_ARGS__ }
+#endif
 
 extern const git_oid git_oid__empty_blob_sha1;
 extern const git_oid git_oid__empty_tree_sha1;
 
+GIT_INLINE(git_oid_t) git_oid_type(const git_oid *oid)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+	return oid->type;
+#else
+	GIT_UNUSED(oid);
+	return GIT_OID_SHA1;
+#endif
+}
+
 GIT_INLINE(size_t) git_oid_size(git_oid_t type)
 {
 	switch (type) {
 	case GIT_OID_SHA1:
 		return GIT_OID_SHA1_SIZE;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 	case GIT_OID_SHA256:
 		return GIT_OID_SHA256_SIZE;
+#endif
+
 	}
 
 	return 0;
@@ -34,8 +55,12 @@ GIT_INLINE(size_t) git_oid_hexsize(git_oid_t type)
 	switch (type) {
 	case GIT_OID_SHA1:
 		return GIT_OID_SHA1_HEXSIZE;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 	case GIT_OID_SHA256:
 		return GIT_OID_SHA256_HEXSIZE;
+#endif
+
 	}
 
 	return 0;
@@ -46,8 +71,12 @@ GIT_INLINE(git_hash_algorithm_t) git_oid_algorithm(git_oid_t type)
 	switch (type) {
 	case GIT_OID_SHA1:
 		return GIT_HASH_ALGORITHM_SHA1;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 	case GIT_OID_SHA256:
 		return GIT_HASH_ALGORITHM_SHA256;
+#endif
+
 	}
 
 	return 0;
@@ -142,16 +171,23 @@ GIT_INLINE(int) git_oid_raw_cpy(
  */
 GIT_INLINE(int) git_oid__cmp(const git_oid *a, const git_oid *b)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	if (a->type != b->type)
 		return a->type - b->type;
 
 	return git_oid_raw_cmp(a->id, b->id, git_oid_size(a->type));
+#else
+	return git_oid_raw_cmp(a->id, b->id, git_oid_size(GIT_OID_SHA1));
+#endif
 }
 
 GIT_INLINE(void) git_oid__cpy_prefix(
 	git_oid *out, const git_oid *id, size_t len)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	out->type = id->type;
+#endif
+
 	memcpy(&out->id, id->id, (len + 1) / 2);
 
 	if (len & 1)
@@ -173,7 +209,10 @@ GIT_INLINE(bool) git_oid__is_hexstr(const char *str, git_oid_t type)
 GIT_INLINE(void) git_oid_clear(git_oid *out, git_oid_t type)
 {
 	memset(out->id, 0, git_oid_size(type));
+
+#ifdef GIT_EXPERIMENTAL_SHA256
 	out->type = type;
+#endif
 }
 
 #endif

src/util/CMakeLists.txt

@@ -8,6 +8,8 @@ configure_file(git2_features.h.in git2_features.h)
 
 set(UTIL_INCLUDES
 	"${PROJECT_BINARY_DIR}/src/util"
+	"${PROJECT_BINARY_DIR}/include"
+	"${PROJECT_BINARY_DIR}/include/git2"
 	"${PROJECT_SOURCE_DIR}/src/util"
 	"${PROJECT_SOURCE_DIR}/include")
 

tests/clar/clar_libgit2.h

@@ -5,6 +5,7 @@
 #include <git2.h>
 #include "common.h"
 #include "posix.h"
+#include "oid.h"
 
 /**
  * Replace for `clar_must_pass` that passes the last library error as the
@@ -140,17 +141,18 @@ GIT_INLINE(void) clar__assert_equal_oid(
 	if (git_oid_equal(one, two))
 		return;
 
-	if (one->type != two->type) {
+	if (git_oid_type(one) != git_oid_type(two)) {
 		char err[64];
 
-		snprintf(err, 64, "different oid types: %d vs %d", one->type, two->type);
+		snprintf(err, 64, "different oid types: %d vs %d", git_oid_type(one), git_oid_type(two));
 		clar__fail(file, func, line, desc, err, 1);
-	} else if (one->type == GIT_OID_SHA1) {
+	} else if (git_oid_type(one) == GIT_OID_SHA1) {
 		char err[] = "\"........................................\" != \"........................................\"";
 		git_oid_fmt(&err[1], one);
 		git_oid_fmt(&err[47], two);
 
 		clar__fail(file, func, line, desc, err, 1);
+#ifdef GIT_EXPERIMENTAL_SHA256
 	} else if (one->type == GIT_OID_SHA256) {
 		char err[] = "\"................................................................\" != \"................................................................\"";
 
@@ -158,6 +160,7 @@ GIT_INLINE(void) clar__assert_equal_oid(
 		git_oid_fmt(&err[71], one);
 
 		clar__fail(file, func, line, desc, err, 1);
+#endif
 	} else {
 		clar__fail(file, func, line, desc, "unknown oid types", 1);
 	}

tests/libgit2/core/oid.c

@@ -9,6 +9,7 @@ const char *str_oid_sha1 = "ae90f12eea699729ed24555e40b9fd669da12a12";
 const char *str_oid_sha1_p = "ae90f12eea699729ed";
 const char *str_oid_sha1_m = "ae90f12eea699729ed24555e40b9fd669da12a12THIS IS EXTRA TEXT THAT SHOULD GET IGNORED";
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static git_oid id_sha256;
 static git_oid idp_sha256;
 static git_oid idm_sha256;
@@ -16,6 +17,7 @@ static git_oid idm_sha256;
 const char *str_oid_sha256 = "d3e63d2f2e43d1fee23a74bf19a0ede156cba2d1bd602eba13de433cea1bb512";
 const char *str_oid_sha256_p = "d3e63d2f2e43d1fee2";
 const char *str_oid_sha256_m = "d3e63d2f2e43d1fee23a74bf19a0ede156cba2d1bd602eba13de433cea1bb512 GARBAGE EXTRA TEXT AT THE END";
+#endif
 
 void test_core_oid__initialize(void)
 {
@@ -23,9 +25,11 @@ void test_core_oid__initialize(void)
 	cl_git_pass(git_oid_fromstrp(&idp_sha1, str_oid_sha1_p, GIT_OID_SHA1));
 	cl_git_fail(git_oid_fromstrp(&idm_sha1, str_oid_sha1_m, GIT_OID_SHA1));
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 	cl_git_pass(git_oid_fromstr(&id_sha256, str_oid_sha256, GIT_OID_SHA256));
 	cl_git_pass(git_oid_fromstrp(&idp_sha256, str_oid_sha256_p, GIT_OID_SHA256));
 	cl_git_fail(git_oid_fromstrp(&idm_sha256, str_oid_sha256_m, GIT_OID_SHA256));
+#endif
 }
 
 void test_core_oid__streq_sha1(void)
@@ -48,6 +52,7 @@ void test_core_oid__streq_sha1(void)
 
 void test_core_oid__streq_sha256(void)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	cl_assert_equal_i(0, git_oid_streq(&id_sha256, str_oid_sha256));
 	cl_assert_equal_i(-1, git_oid_streq(&id_sha256, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
 
@@ -62,6 +67,7 @@ void test_core_oid__streq_sha256(void)
 
 	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "deadbeef"));
 	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "I'm not an oid.... :)"));
+#endif
 }
 
 void test_core_oid__strcmp_sha1(void)
@@ -84,6 +90,7 @@ void test_core_oid__strcmp_sha1(void)
 
 void test_core_oid__strcmp_sha256(void)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	cl_assert_equal_i(0, git_oid_strcmp(&id_sha256, str_oid_sha256));
 	cl_assert(git_oid_strcmp(&id_sha256, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef") < 0);
 
@@ -98,6 +105,7 @@ void test_core_oid__strcmp_sha256(void)
 
 	cl_assert(git_oid_strcmp(&idp_sha256, "deadbeef") < 0);
 	cl_assert_equal_i(-1, git_oid_strcmp(&idp_sha256, "I'm not an oid.... :)"));
+#endif
 }
 
 void test_core_oid__ncmp_sha1(void)
@@ -121,6 +129,7 @@ void test_core_oid__ncmp_sha1(void)
 
 void test_core_oid__ncmp_sha256(void)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	cl_assert(!git_oid_ncmp(&id_sha256, &idp_sha256, 0));
 	cl_assert(!git_oid_ncmp(&id_sha256, &idp_sha256, 1));
 	cl_assert(!git_oid_ncmp(&id_sha256, &idp_sha256, 2));
@@ -142,6 +151,7 @@ void test_core_oid__ncmp_sha256(void)
 	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 63));
 	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 64));
 	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 65));
+#endif
 }
 
 void test_core_oid__is_hexstr(void)
@@ -154,25 +164,25 @@ void test_core_oid__is_hexstr(void)
 
 void test_core_oid__fmt_substr_sha1(void)
 {
-	char buf[GIT_OID_MAX_HEXSIZE];
+	char buf[GIT_OID_MAX_HEXSIZE + 1];
 
-	memset(buf, 0, GIT_OID_MAX_HEXSIZE);
+	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
 	git_oid_fmt_substr(buf, &id_sha1, 0, 40);
 	cl_assert_equal_s(buf, str_oid_sha1);
 
-	memset(buf, 0, GIT_OID_MAX_HEXSIZE);
+	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
 	git_oid_fmt_substr(buf, &id_sha1, 0, 18);
 	cl_assert_equal_s(buf, str_oid_sha1_p);
 
-	memset(buf, 0, GIT_OID_MAX_HEXSIZE);
+	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
 	git_oid_fmt_substr(buf, &id_sha1, 0, 5);
 	cl_assert_equal_s(buf, "ae90f");
 
-	memset(buf, 0, GIT_OID_MAX_HEXSIZE);
+	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
 	git_oid_fmt_substr(buf, &id_sha1, 5, 5);
 	cl_assert_equal_s(buf, "12eea");
 
-	memset(buf, 0, GIT_OID_MAX_HEXSIZE);
+	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
 	git_oid_fmt_substr(buf, &id_sha1, 5, 6);
 	cl_assert_equal_s(buf, "12eea6");
 }

tests/libgit2/core/oidmap.c

@@ -28,7 +28,9 @@ void test_core_oidmap__initialize(void)
 		test_oids[i].oid.id[ 9] = (unsigned char)(i >> 8);
 		test_oids[i].oid.id[10] = (unsigned char)(i >> 16);
 		test_oids[i].oid.id[11] = (unsigned char)(i >> 24);
+#ifdef GIT_EXPERIMENTAL_SHA256
 		test_oids[i].oid.type = GIT_OID_SHA1;
+#endif
 	}
 
 	cl_git_pass(git_oidmap_new(&g_map));
@@ -94,9 +96,9 @@ void test_core_oidmap__get_fails_with_nonexisting_key(void)
 void test_core_oidmap__setting_oid_persists(void)
 {
 	git_oid oids[] = {
-	    { GIT_OID_SHA1, { 0x01 }},
-	    { GIT_OID_SHA1, { 0x02 }},
-	    { GIT_OID_SHA1, { 0x03 }}
+		GIT_OID_INIT(GIT_OID_SHA1, { 0x01 }),
+		GIT_OID_INIT(GIT_OID_SHA1, { 0x02 }),
+		GIT_OID_INIT(GIT_OID_SHA1, { 0x03 })
 	};
 
 	cl_git_pass(git_oidmap_set(g_map, &oids[0], "one"));
@@ -111,9 +113,9 @@ void test_core_oidmap__setting_oid_persists(void)
 void test_core_oidmap__setting_existing_key_updates(void)
 {
 	git_oid oids[] = {
-	    { GIT_OID_SHA1, { 0x01 }},
-	    { GIT_OID_SHA1, { 0x02 }},
-	    { GIT_OID_SHA1, { 0x03 }}
+		GIT_OID_INIT(GIT_OID_SHA1, { 0x01 }),
+		GIT_OID_INIT(GIT_OID_SHA1, { 0x02 }),
+		GIT_OID_INIT(GIT_OID_SHA1, { 0x03 })
 	};
 
 	cl_git_pass(git_oidmap_set(g_map, &oids[0], "one"));

tests/libgit2/core/pool.c

@@ -27,7 +27,12 @@ void test_core_pool__oid(void)
 
 #ifndef GIT_DEBUG_POOL
 	/* with fixed page size, allocation must end up with these values */
+
+# ifdef GIT_EXPERIMENTAL_SHA256
 	cl_assert_equal_i(sizeof(void *) == 8 ? 90 : 82, git_pool__open_pages(&p));
+# else
+	cl_assert_equal_i(sizeof(void *) == 8 ? 55 : 45, git_pool__open_pages(&p));
+# endif
 #endif
 	git_pool_clear(&p);
 }

tests/libgit2/odb/loose.c

@@ -160,6 +160,7 @@ void test_odb_loose__exists_sha1(void)
 
 void test_odb_loose__exists_sha256(void)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	git_oid id, id2;
 	git_odb *odb;
 	git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT;
@@ -184,6 +185,7 @@ void test_odb_loose__exists_sha256(void)
 	cl_assert_equal_i(GIT_ENOTFOUND, git_odb_exists_prefix(&id2, odb, &id, 8));
 
 	git_odb_free(odb);
+#endif
 }
 
 void test_odb_loose__simple_reads_sha1(void)
@@ -199,6 +201,7 @@ void test_odb_loose__simple_reads_sha1(void)
 
 void test_odb_loose__simple_reads_sha256(void)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	test_read_object(&commit_sha256);
 	test_read_object(&tree_sha256);
 	test_read_object(&tag_sha256);
@@ -206,6 +209,7 @@ void test_odb_loose__simple_reads_sha256(void)
 	test_read_object(&one_sha256);
 	test_read_object(&two_sha256);
 	test_read_object(&some_sha256);
+#endif
 }
 
 void test_odb_loose__streaming_reads_sha1(void)
@@ -226,6 +230,7 @@ void test_odb_loose__streaming_reads_sha1(void)
 
 void test_odb_loose__streaming_reads_sha256(void)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	size_t blocksizes[] = { 1, 2, 4, 16, 99, 1024, 123456789 };
 	size_t i;
 
@@ -238,6 +243,7 @@ void test_odb_loose__streaming_reads_sha256(void)
 		test_readstream_object(&two_sha256, blocksizes[i]);
 		test_readstream_object(&some_sha256, blocksizes[i]);
 	}
+#endif
 }
 
 void test_odb_loose__read_header_sha1(void)
@@ -253,6 +259,7 @@ void test_odb_loose__read_header_sha1(void)
 
 void test_odb_loose__read_header_sha256(void)
 {
+#ifdef GIT_EXPERIMENTAL_SHA256
 	test_read_header(&commit_sha256);
 	test_read_header(&tree_sha256);
 	test_read_header(&tag_sha256);
@@ -260,6 +267,7 @@ void test_odb_loose__read_header_sha256(void)
 	test_read_header(&one_sha256);
 	test_read_header(&two_sha256);
 	test_read_header(&some_sha256);
+#endif
 }
 
 static void test_write_object_permission(

tests/libgit2/odb/loose_data.h

@@ -35,6 +35,7 @@ static object_data one = {
     sizeof(one_data),
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static object_data one_sha256 = {
     one_bytes,
     sizeof(one_bytes),
@@ -46,6 +47,7 @@ static object_data one_sha256 = {
     one_data,
     sizeof(one_data),
 };
+#endif
 
 
 /*
@@ -84,6 +86,7 @@ static unsigned char commit_bytes[] = {
     0x1f, 0x78, 0x35,
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static unsigned char commit_bytes_sha256[] = {
     0x78, 0x01, 0x85, 0x90, 0xc1, 0x4e, 0xc3, 0x30,
     0x0c, 0x86, 0x39, 0xe7, 0x29, 0x7c, 0x87, 0x4e,
@@ -117,6 +120,7 @@ static unsigned char commit_bytes_sha256[] = {
     0x22, 0x98, 0x42, 0x6d, 0xcf, 0x7f, 0xbf, 0x83,
     0x7d, 0x03, 0x6d, 0x1e, 0x7e, 0xa9
 };
+#endif
 
 static unsigned char commit_data[] = {
     0x74, 0x72, 0x65, 0x65, 0x20, 0x64, 0x66, 0x66,
@@ -166,6 +170,7 @@ static unsigned char commit_data[] = {
     0x3e, 0x0a,
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static unsigned char commit_data_sha256[] = {
     0x74, 0x72, 0x65, 0x65, 0x20, 0x33, 0x34, 0x61,
     0x34, 0x38, 0x35, 0x34, 0x62, 0x35, 0x34, 0x32,
@@ -216,6 +221,7 @@ static unsigned char commit_data_sha256[] = {
     0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d,
     0x3e, 0x0a
 };
+#endif
 
 static object_data commit = {
     commit_bytes,
@@ -229,6 +235,7 @@ static object_data commit = {
     sizeof(commit_data),
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static object_data commit_sha256 = {
     commit_bytes_sha256,
     sizeof(commit_bytes_sha256),
@@ -240,6 +247,7 @@ static object_data commit_sha256 = {
     commit_data_sha256,
     sizeof(commit_data_sha256),
 };
+#endif
 
 /*
  * tree == dff2da90b254e1beb889d1f1f1288be1803782df (sha1)
@@ -284,6 +292,7 @@ static unsigned char tree_data[] = {
     0xd8, 0xc2, 0xe4, 0x8c, 0x53, 0x91,
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static unsigned char tree_bytes_sha256[] = {
     0x78, 0x01, 0x2b, 0x29, 0x4a, 0x4d, 0x55, 0x30,
     0x32, 0x32, 0x66, 0x30, 0x34, 0x30, 0x30, 0x33,
@@ -346,6 +355,7 @@ static unsigned char tree_data_sha256[] = {
     0xa7, 0xcd, 0x2a, 0xc9, 0xb4, 0x4a, 0xda, 0xf7,
     0xed, 0x3e, 0xdc, 0x0d, 0x08, 0xdd, 0x78
 };
+#endif
 
 static object_data tree = {
     tree_bytes,
@@ -359,6 +369,7 @@ static object_data tree = {
     sizeof(tree_data),
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static object_data tree_sha256 = {
     tree_bytes_sha256,
     sizeof(tree_bytes_sha256),
@@ -370,6 +381,7 @@ static object_data tree_sha256 = {
     tree_data_sha256,
     sizeof(tree_data_sha256),
 };
+#endif
 
 /*
  * tag == 09d373e1dfdc16b129ceec6dd649739911541e05 (sha1)
@@ -422,6 +434,7 @@ static unsigned char tag_data[] = {
     0x2e, 0x30, 0x2e, 0x31, 0x0a,
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static unsigned char tag_bytes_sha256[] = {
     0x78, 0x01, 0x55, 0x8f, 0xd1, 0x4e, 0x84, 0x30,
     0x10, 0x45, 0x7d, 0xee, 0x57, 0xcc, 0xbb, 0x2e,
@@ -509,6 +522,7 @@ static unsigned char tag_data_sha256[] = {
     0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d,
     0x3e, 0x0a
 };
+#endif
 
 static object_data tag = {
     tag_bytes,
@@ -522,6 +536,7 @@ static object_data tag = {
     sizeof(tag_data),
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static object_data tag_sha256 = {
     tag_bytes_sha256,
     sizeof(tag_bytes_sha256),
@@ -533,6 +548,7 @@ static object_data tag_sha256 = {
     tag_data_sha256,
     sizeof(tag_data_sha256),
 };
+#endif
 
 /*
  * zero == e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 (sha1)
@@ -559,6 +575,7 @@ static object_data zero = {
     0,
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static object_data zero_sha256 = {
     zero_bytes,
     sizeof(zero_bytes),
@@ -570,6 +587,7 @@ static object_data zero_sha256 = {
     zero_data,
     0,
 };
+#endif
 
 /*
  * two == 78981922613b2afb6025042ff6bd878ac1994e85 (sha1)
@@ -597,6 +615,7 @@ static object_data two = {
     sizeof(two_data),
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static object_data two_sha256 = {
     two_bytes,
     sizeof(two_bytes),
@@ -608,6 +627,7 @@ static object_data two_sha256 = {
     two_data,
     sizeof(two_data),
 };
+#endif
 
 /*
  * some == fd8430bc864cfcd5f10e5590f8a447e01b942bfe (sha1)
@@ -858,6 +878,7 @@ static object_data some = {
     sizeof(some_data),
 };
 
+#ifdef GIT_EXPERIMENTAL_SHA256
 static object_data some_sha256 = {
     some_bytes,
     sizeof(some_bytes),
@@ -869,3 +890,4 @@ static object_data some_sha256 = {
     some_data,
     sizeof(some_data),
 };
+#endif