rugged 1.5.0.1 → 1.7.1

data/vendor/libgit2/src/libgit2/oid.c

@@ -14,13 +14,13 @@
 #include <limits.h>
 
 const git_oid git_oid__empty_blob_sha1 =
-	{{ 0xe6, 0x9d, 0xe2, 0x9b, 0xb2, 0xd1, 0xd6, 0x43, 0x4b, 0x8b,
-	   0x29, 0xae, 0x77, 0x5a, 0xd8, 0xc2, 0xe4, 0x8c, 0x53, 0x91 }};
+	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 =
-	{{ 0x4b, 0x82, 0x5d, 0xc6, 0x42, 0xcb, 0x6e, 0xb9, 0xa0, 0x60,
-	   0xe5, 0x4b, 0xf8, 0xd6, 0x92, 0x88, 0xfb, 0xee, 0x49, 0x04 }};
-
-static char to_hex[] = "0123456789abcdef";
+	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)
 {
@@ -28,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]);
@@ -55,87 +65,134 @@ 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;
 
-	for (i = 0; i < max_i; i++)
-		str = fmt_one(str, oid->id[i]);
+	if (!(hex_size = git_oid_hexsize(git_oid_type(oid))))
+		return oid_error_invalid("unknown type");
 
-	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;
 }
 
 char *git_oid_tostr_s(const git_oid *oid)
 {
-	char *str = GIT_THREADSTATE->oid_fmt;
-	git_oid_nfmt(str, GIT_OID_HEXSZ + 1, oid);
+	git_threadstate *threadstate = git_threadstate_get();
+	char *str;
+
+	if (!threadstate)
+		return NULL;
+
+	str = threadstate->oid_fmt;
+	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;
-	git_oid_nfmt(str, GIT_OID_HEXSZ + 1, oid);
+
+	if (git_oid_nfmt(str, hex_size + 1, oid) < 0) {
+		git__free(str);
+		return NULL;
+	}
+
 	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';
@@ -143,51 +200,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);
-
-	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;
+	size_t size;
 
-	*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_str *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_str_puts(buf, header);
-	git_str_put(buf, hex_oid, GIT_OID_HEXSZ);
-	git_str_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)
 {
-	return git_oid_raw_cpy(out->id, src->id);
+	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)
@@ -202,6 +252,11 @@ 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);
 }
 
@@ -209,9 +264,10 @@ 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);
@@ -235,8 +291,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;
@@ -393,7 +457,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

@@ -9,11 +9,120 @@
 
 #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(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.
  *
@@ -25,13 +134,42 @@ extern const git_oid git_oid__empty_tree_sha1;
  */
 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_HEXSZ)
-		len = GIT_OID_HEXSZ;
+	if (len > GIT_OID_MAX_HEXSIZE)
+		len = GIT_OID_MAX_HEXSIZE;
 
 	while (len > 1) {
 		if (*sha1 != *sha2)
@@ -50,16 +188,18 @@ GIT_INLINE(int) git_oid_raw_ncmp(
 
 GIT_INLINE(int) git_oid_raw_cmp(
 	const unsigned char *sha1,
-	const unsigned char *sha2)
+	const unsigned char *sha2,
+	size_t size)
 {
-	return memcmp(sha1, sha2, GIT_OID_RAWSZ);
+	return memcmp(sha1, sha2, size);
 }
 
 GIT_INLINE(int) git_oid_raw_cpy(
 	unsigned char *dst,
-	const unsigned char *src)
+	const unsigned char *src,
+	size_t size)
 {
-	memcpy(dst, src, GIT_OID_RAWSZ);
+	memcpy(dst, src, size);
 	return 0;
 }
 
@@ -72,19 +212,30 @@ GIT_INLINE(int) git_oid_raw_cpy(
  */
 GIT_INLINE(int) git_oid__cmp(const git_oid *a, const git_oid *b)
 {
-	return git_oid_raw_cmp(a->id, b->id);
+#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_INLINE(bool) git_oid__is_hexstr(const char *str, git_oid_t type)
 {
 	size_t i;
 
@@ -93,7 +244,30 @@ GIT_INLINE(bool) git_oid__is_hexstr(const char *str)
 			return false;
 	}
 
-	return (i == GIT_OID_HEXSZ);
+	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);
+
 #endif

data/vendor/libgit2/src/libgit2/oidarray.c

@@ -15,10 +15,17 @@ void git_oidarray_dispose(git_oidarray *arr)
 	git__free(arr->ids);
 }
 
-void git_oidarray__from_array(git_oidarray *arr, git_array_oid_t *array)
+void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array)
 {
-	arr->count = array->size;
-	arr->ids = array->ptr;
+	out->count = array->size;
+	out->ids = array->ptr;
+}
+
+void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array)
+{
+	out->ptr = array->ids;
+	out->size = array->count;
+	out->asize = array->count;
 }
 
 void git_oidarray__reverse(git_oidarray *arr)
@@ -33,6 +40,45 @@ void git_oidarray__reverse(git_oidarray *arr)
 	}
 }
 
+int git_oidarray__add(git_array_oid_t *arr, git_oid *id)
+{
+	git_oid *add, *iter;
+	size_t i;
+
+	git_array_foreach(*arr, i, iter) {
+		if (git_oid_cmp(iter, id) == 0)
+			return 0;
+	}
+
+	if ((add = git_array_alloc(*arr)) == NULL)
+		return -1;
+
+	git_oid_cpy(add, id);
+	return 0;
+}
+
+bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id)
+{
+	bool found = false;
+	size_t remain, i;
+	git_oid *iter;
+
+	git_array_foreach(*arr, i, iter) {
+		if (git_oid_cmp(iter, id) == 0) {
+			arr->size--;
+			remain = arr->size - i;
+
+			if (remain > 0)
+				memmove(&arr->ptr[i], &arr->ptr[i+1], remain * sizeof(git_oid));
+
+			found = true;
+			break;
+		}
+	}
+
+	return found;
+}
+
 #ifndef GIT_DEPRECATE_HARD
 
 void git_oidarray_free(git_oidarray *arr)

data/vendor/libgit2/src/libgit2/oidarray.h

@@ -15,6 +15,10 @@
 typedef git_array_t(git_oid) git_array_oid_t;
 
 extern void git_oidarray__reverse(git_oidarray *arr);
-extern void git_oidarray__from_array(git_oidarray *arr, git_array_oid_t *array);
+extern void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array);
+extern void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array);
+
+int git_oidarray__add(git_array_oid_t *arr, git_oid *id);
+bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id);
 
 #endif