rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/{oid.c → libgit2/oid.c}

@@ -9,11 +9,18 @@
 
 #include "git2/oid.h"
 #include "repository.h"
-#include "threadstate.h"
+#include "runtime.h"
 #include <string.h>
 #include <limits.h>
 
-static char to_hex[] = "0123456789abcdef";
+const git_oid git_oid__empty_blob_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 });
+const git_oid git_oid__empty_tree_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 });
 
 static int oid_error_invalid(const char *msg)
 {
@@ -21,21 +28,31 @@ static int oid_error_invalid(const char *msg)
 	return -1;
 }
 
-int git_oid_fromstrn(git_oid *out, const char *str, size_t length)
+int git_oid__fromstrn(
+	git_oid *out,
+	const char *str,
+	size_t length,
+	git_oid_t type)
 {
-	size_t p;
+	size_t size, p;
 	int v;
 
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(str);
 
+	if (!(size = git_oid_size(type)))
+		return oid_error_invalid("unknown type");
+
 	if (!length)
 		return oid_error_invalid("too short");
 
-	if (length > GIT_OID_HEXSZ)
+	if (length > git_oid_hexsize(type))
 		return oid_error_invalid("too long");
 
-	memset(out->id, 0, GIT_OID_RAWSZ);
+#ifdef GIT_EXPERIMENTAL_SHA256
+	out->type = type;
+#endif
+	memset(out->id, 0, size);
 
 	for (p = 0; p < length; p++) {
 		v = git__fromhex(str[p]);
@@ -48,87 +65,161 @@ int git_oid_fromstrn(git_oid *out, const char *str, size_t length)
 	return 0;
 }
 
-int git_oid_fromstrp(git_oid *out, const char *str)
+int git_oid__fromstrp(git_oid *out, const char *str, git_oid_t type)
 {
-	return git_oid_fromstrn(out, str, strlen(str));
+	return git_oid__fromstrn(out, str, strlen(str), type);
 }
 
-int git_oid_fromstr(git_oid *out, const char *str)
+int git_oid__fromstr(git_oid *out, const char *str, git_oid_t type)
 {
-	return git_oid_fromstrn(out, str, GIT_OID_HEXSZ);
+	return git_oid__fromstrn(out, str, git_oid_hexsize(type), type);
 }
 
-GIT_INLINE(char) *fmt_one(char *str, unsigned int val)
+#ifdef GIT_EXPERIMENTAL_SHA256
+int git_oid_fromstrn(
+	git_oid *out,
+	const char *str,
+	size_t length,
+	git_oid_t type)
 {
-	*str++ = to_hex[val >> 4];
-	*str++ = to_hex[val & 0xf];
-	return str;
+	return git_oid__fromstrn(out, str, length, type);
+}
+
+int git_oid_fromstrp(git_oid *out, const char *str, git_oid_t type)
+{
+	return git_oid_fromstrn(out, str, strlen(str), type);
+}
+
+int git_oid_fromstr(git_oid *out, const char *str, git_oid_t type)
+{
+	return git_oid_fromstrn(out, str, git_oid_hexsize(type), type);
+}
+#else
+int git_oid_fromstrn(
+	git_oid *out,
+	const char *str,
+	size_t length)
+{
+	return git_oid__fromstrn(out, str, length, GIT_OID_SHA1);
+}
+
+int git_oid_fromstrp(git_oid *out, const char *str)
+{
+	return git_oid__fromstrn(out, str, strlen(str), GIT_OID_SHA1);
+}
+
+int git_oid_fromstr(git_oid *out, const char *str)
+{
+	return git_oid__fromstrn(out, str, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1);
 }
+#endif
 
 int git_oid_nfmt(char *str, size_t n, const git_oid *oid)
 {
-	size_t i, max_i;
+	size_t hex_size;
 
 	if (!oid) {
 		memset(str, 0, n);
 		return 0;
 	}
-	if (n > GIT_OID_HEXSZ) {
-		memset(&str[GIT_OID_HEXSZ], 0, n - GIT_OID_HEXSZ);
-		n = GIT_OID_HEXSZ;
-	}
 
-	max_i = n / 2;
+	if (!(hex_size = git_oid_hexsize(git_oid_type(oid))))
+		return oid_error_invalid("unknown type");
 
-	for (i = 0; i < max_i; i++)
-		str = fmt_one(str, oid->id[i]);
-
-	if (n & 1)
-		*str++ = to_hex[oid->id[i] >> 4];
+	if (n > hex_size) {
+		memset(&str[hex_size], 0, n - hex_size);
+		n = hex_size;
+	}
 
+	git_oid_fmt_substr(str, oid, 0, n);
 	return 0;
 }
 
 int git_oid_fmt(char *str, const git_oid *oid)
 {
-	return git_oid_nfmt(str, GIT_OID_HEXSZ, 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 i;
+	size_t hex_size;
 
-	str = fmt_one(str, oid->id[0]);
-	*str++ = '/';
-	for (i = 1; i < sizeof(oid->id); i++)
-		str = fmt_one(str, oid->id[i]);
+	if (!(hex_size = git_oid_hexsize(git_oid_type(oid))))
+		return oid_error_invalid("unknown type");
 
+	git_oid_fmt_substr(str, oid, 0, 2);
+	str[2] = '/';
+	git_oid_fmt_substr(&str[3], oid, 2, (hex_size - 2));
 	return 0;
 }
 
+static git_tlsdata_key thread_str_key;
+
+static void GIT_SYSTEM_CALL thread_str_free(void *s)
+{
+	char *str = (char *)s;
+	git__free(str);
+}
+
+static void thread_str_global_shutdown(void)
+{
+	char *str = git_tlsdata_get(thread_str_key);
+	git_tlsdata_set(thread_str_key, NULL);
+
+	git__free(str);
+	git_tlsdata_dispose(thread_str_key);
+}
+
+int git_oid_global_init(void)
+{
+	if (git_tlsdata_init(&thread_str_key, thread_str_free) != 0)
+		return -1;
+
+	return git_runtime_shutdown_register(thread_str_global_shutdown);
+}
+
 char *git_oid_tostr_s(const git_oid *oid)
 {
-	char *str = GIT_THREADSTATE->oid_fmt;
-	git_oid_nfmt(str, GIT_OID_HEXSZ + 1, oid);
+	char *str;
+
+	if ((str = git_tlsdata_get(thread_str_key)) == NULL) {
+		if ((str = git__malloc(GIT_OID_MAX_HEXSIZE + 1)) == NULL)
+			return NULL;
+
+		git_tlsdata_set(thread_str_key, str);
+	}
+
+	git_oid_nfmt(str, git_oid_hexsize(git_oid_type(oid)) + 1, oid);
 	return str;
 }
 
 char *git_oid_allocfmt(const git_oid *oid)
 {
-	char *str = git__malloc(GIT_OID_HEXSZ + 1);
-	if (!str)
+	size_t hex_size = git_oid_hexsize(git_oid_type(oid));
+	char *str = git__malloc(hex_size + 1);
+
+	if (!hex_size || !str)
+		return NULL;
+
+	if (git_oid_nfmt(str, hex_size + 1, oid) < 0) {
+		git__free(str);
 		return NULL;
-	git_oid_nfmt(str, GIT_OID_HEXSZ + 1, oid);
+	}
+
 	return str;
 }
 
 char *git_oid_tostr(char *out, size_t n, const git_oid *oid)
 {
+	size_t hex_size;
+
 	if (!out || n == 0)
 		return "";
 
-	if (n > GIT_OID_HEXSZ + 1)
-		n = GIT_OID_HEXSZ + 1;
+	hex_size = oid ? git_oid_hexsize(git_oid_type(oid)) : 0;
+
+	if (n > hex_size + 1)
+		n = hex_size + 1;
 
 	git_oid_nfmt(out, n - 1, oid); /* allow room for terminating NUL */
 	out[n - 1] = '\0';
@@ -136,52 +227,44 @@ char *git_oid_tostr(char *out, size_t n, const git_oid *oid)
 	return out;
 }
 
-int git_oid__parse(
-	git_oid *oid, const char **buffer_out,
-	const char *buffer_end, const char *header)
+int git_oid__fromraw(git_oid *out, const unsigned char *raw, git_oid_t type)
 {
-	const size_t sha_len = GIT_OID_HEXSZ;
-	const size_t header_len = strlen(header);
+	size_t size;
 
-	const char *buffer = *buffer_out;
-
-	if (buffer + (header_len + sha_len + 1) > buffer_end)
-		return -1;
-
-	if (memcmp(buffer, header, header_len) != 0)
-		return -1;
-
-	if (buffer[header_len + sha_len] != '\n')
-		return -1;
-
-	if (git_oid_fromstr(oid, buffer + header_len) < 0)
-		return -1;
-
-	*buffer_out = buffer + (header_len + sha_len + 1);
+	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;
 }
 
-void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid)
+#ifdef GIT_EXPERIMENTAL_SHA256
+int git_oid_fromraw(git_oid *out, const unsigned char *raw, git_oid_t type)
 {
-	char hex_oid[GIT_OID_HEXSZ];
-
-	git_oid_fmt(hex_oid, oid);
-	git_buf_puts(buf, header);
-	git_buf_put(buf, hex_oid, GIT_OID_HEXSZ);
-	git_buf_putc(buf, '\n');
+	return git_oid__fromraw(out, raw, type);
 }
-
+#else
 int git_oid_fromraw(git_oid *out, const unsigned char *raw)
 {
-	memcpy(out->id, raw, sizeof(out->id));
-	return 0;
+	return git_oid__fromraw(out, raw, GIT_OID_SHA1);
 }
+#endif
 
 int git_oid_cpy(git_oid *out, const git_oid *src)
 {
-	memcpy(out->id, src->id, sizeof(out->id));
-	return 0;
+	size_t size;
+
+	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);
 }
 
 int git_oid_cmp(const git_oid *a, const git_oid *b)
@@ -196,34 +279,22 @@ 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)
 {
-	const unsigned char *a = oid_a->id;
-	const unsigned char *b = oid_b->id;
-
-	if (len > GIT_OID_HEXSZ)
-		len = GIT_OID_HEXSZ;
-
-	while (len > 1) {
-		if (*a != *b)
-			return 1;
-		a++;
-		b++;
-		len -= 2;
-	};
-
-	if (len)
-		if ((*a ^ *b) & 0xf0)
-			return 1;
+#ifdef GIT_EXPERIMENTAL_SHA256
+	if (oid_a->type != oid_b->type)
+		return oid_a->type - oid_b->type;
+#endif
 
-	return 0;
+	return git_oid_raw_ncmp(oid_a->id, oid_b->id, len);
 }
 
 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(git_oid_type(oid_a));
 	int hexval;
 
-	for (a = oid_a->id; *str && (a - oid_a->id) < GIT_OID_RAWSZ; ++a) {
+	for (a = oid_a->id; *str && (a - oid_a->id) < size; ++a) {
 		if ((hexval = git__fromhex(*str++)) < 0)
 			return -1;
 		strval = (unsigned char)(hexval << 4);
@@ -247,8 +318,16 @@ 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;
-	unsigned int i;
-	for (i = 0; i < GIT_OID_RAWSZ; ++i, ++a)
+	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)
 			return 0;
 	return 1;
@@ -405,7 +484,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 	idx = 0;
 	is_leaf = false;
 
-	for (i = 0; i < GIT_OID_HEXSZ; ++i) {
+	for (i = 0; i < GIT_OID_SHA1_HEXSIZE; ++i) {
 		int c = git__fromhex(text_oid[i]);
 		trie_node *node;
 

data/vendor/libgit2/src/libgit2/oid.h

@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_oid_h__
+#define INCLUDE_oid_h__
+
+#include "common.h"
+
+#include "git2/experimental.h"
+#include "git2/oid.h"
+#include "hash.h"
+
+#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;
+}
+
+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;
+}
+
+GIT_INLINE(bool) git_oid_type_is_valid(git_oid_t type)
+{
+	return (type == GIT_OID_SHA1
+#ifdef GIT_EXPERIMENTAL_SHA256
+	     || type == GIT_OID_SHA256
+#endif
+	);
+}
+
+GIT_INLINE(const char *) git_oid_type_name(git_oid_t type)
+{
+	switch (type) {
+	case GIT_OID_SHA1:
+		return "sha1";
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+	case GIT_OID_SHA256:
+		return "sha256";
+#endif
+	}
+
+	return "unknown";
+}
+
+GIT_INLINE(git_oid_t) git_oid_type_fromstr(const char *name)
+{
+	if (strcmp(name, "sha1") == 0)
+		return GIT_OID_SHA1;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+	if (strcmp(name, "sha256") == 0)
+		return GIT_OID_SHA256;
+#endif
+
+	return 0;
+}
+
+GIT_INLINE(git_oid_t) git_oid_type_fromstrn(const char *name, size_t len)
+{
+	if (len == CONST_STRLEN("sha1") && strncmp(name, "sha1", len) == 0)
+		return GIT_OID_SHA1;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+	if (len == CONST_STRLEN("sha256") && strncmp(name, "sha256", len) == 0)
+		return GIT_OID_SHA256;
+#endif
+
+	return 0;
+}
+
+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;
+}
+
+/**
+ * Format a git_oid into a newly allocated c-string.
+ *
+ * The c-string is owned by the caller and needs to be manually freed.
+ *
+ * @param id the oid structure to format
+ * @return the c-string; NULL if memory is exhausted. Caller must
+ *			deallocate the string with git__free().
+ */
+char *git_oid_allocfmt(const git_oid *id);
+
+/**
+ * Format the requested nibbles of an object id.
+ *
+ * @param str the string to write into
+ * @param oid the oid structure to format
+ * @param start the starting number of nibbles
+ * @param count the number of nibbles to format
+ */
+GIT_INLINE(void) git_oid_fmt_substr(
+	char *str,
+	const git_oid *oid,
+	size_t start,
+	size_t count)
+{
+	static char hex[] = "0123456789abcdef";
+	size_t i, end = start + count, min = start / 2, max = end / 2;
+
+	if (start & 1)
+		*str++ = hex[oid->id[min++] & 0x0f];
+
+	for (i = min; i < max; i++) {
+		*str++ = hex[oid->id[i] >> 4];
+		*str++ = hex[oid->id[i] & 0x0f];
+	}
+
+	if (end & 1)
+		*str++ = hex[oid->id[i] >> 4];
+}
+
+GIT_INLINE(int) git_oid_raw_ncmp(
+	const unsigned char *sha1,
+	const unsigned char *sha2,
+	size_t len)
+{
+	if (len > GIT_OID_MAX_HEXSIZE)
+		len = GIT_OID_MAX_HEXSIZE;
+
+	while (len > 1) {
+		if (*sha1 != *sha2)
+			return 1;
+		sha1++;
+		sha2++;
+		len -= 2;
+	};
+
+	if (len)
+		if ((*sha1 ^ *sha2) & 0xf0)
+			return 1;
+
+	return 0;
+}
+
+GIT_INLINE(int) git_oid_raw_cmp(
+	const unsigned char *sha1,
+	const unsigned char *sha2,
+	size_t size)
+{
+	return memcmp(sha1, sha2, size);
+}
+
+GIT_INLINE(int) git_oid_raw_cpy(
+	unsigned char *dst,
+	const unsigned char *src,
+	size_t size)
+{
+	memcpy(dst, src, size);
+	return 0;
+}
+
+/*
+ * Compare two oid structures.
+ *
+ * @param a first oid structure.
+ * @param b second oid structure.
+ * @return <0, 0, >0 if a < b, a == b, a > b.
+ */
+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)
+		out->id[len / 2] &= 0xF0;
+}
+
+GIT_INLINE(bool) git_oid__is_hexstr(const char *str, git_oid_t type)
+{
+	size_t i;
+
+	for (i = 0; str[i] != '\0'; i++) {
+		if (git__fromhex(str[i]) < 0)
+			return false;
+	}
+
+	return (i == git_oid_hexsize(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
+}
+
+/* SHA256 support */
+
+int git_oid__fromstr(git_oid *out, const char *str, git_oid_t type);
+
+int git_oid__fromstrp(git_oid *out, const char *str, git_oid_t type);
+
+int git_oid__fromstrn(
+	git_oid *out,
+	const char *str,
+	size_t length,
+	git_oid_t type);
+
+int git_oid__fromraw(git_oid *out, const unsigned char *raw, git_oid_t type);
+
+int git_oid_global_init(void);
+
+#endif