rugged 1.6.5 → 1.7.1

data/vendor/libgit2/src/libgit2/diff.h

@@ -30,15 +30,15 @@ typedef enum {
 } git_diff_origin_t;
 
 struct git_diff {
-	git_refcount     rc;
+	git_refcount      rc;
 	git_repository   *repo;
-	git_attr_session attrsession;
+	git_attr_session  attrsession;
 	git_diff_origin_t type;
-	git_diff_options opts;
-	git_vector       deltas;    /* vector of git_diff_delta */
+	git_diff_options  opts;
+	git_vector        deltas;    /* vector of git_diff_delta */
 	git_pool pool;
-	git_iterator_t old_src;
-	git_iterator_t new_src;
+	git_iterator_t    old_src;
+	git_iterator_t    new_src;
 	git_diff_perfdata perf;
 
 	int (*strcomp)(const char *, const char *);

data/vendor/libgit2/src/libgit2/diff_file.c

@@ -112,7 +112,7 @@ int git_diff_file_content__init_from_diff(
 	case GIT_DELTA_DELETED:
 		has_data = use_old; break;
 	case GIT_DELTA_UNTRACKED:
-		has_data = !use_old &&
+		has_data = (use_old == (diff->opts.flags & GIT_DIFF_REVERSE)) &&
 			(diff->opts.flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) != 0;
 		break;
 	case GIT_DELTA_UNREADABLE:
@@ -144,7 +144,7 @@ int git_diff_file_content__init_from_src(
 
 	if (!src->blob && !src->buf) {
 		fc->flags |= GIT_DIFF_FLAG__NO_DATA;
-		git_oid_clear(&fc->file->id, GIT_OID_SHA1);
+		git_oid_clear(&fc->file->id, opts->oid_type);
 	} else {
 		fc->flags |= GIT_DIFF_FLAG__LOADED;
 		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
@@ -154,7 +154,7 @@ int git_diff_file_content__init_from_src(
 			git_blob_dup((git_blob **)&fc->blob, (git_blob *) src->blob);
 			fc->file->size = git_blob_rawsize(src->blob);
 			git_oid_cpy(&fc->file->id, git_blob_id(src->blob));
-			fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE;
+			fc->file->id_abbrev = (uint16_t)git_oid_hexsize(repo->oid_type);
 
 			fc->map.len  = (size_t)fc->file->size;
 			fc->map.data = (char *)git_blob_rawcontent(src->blob);
@@ -162,10 +162,10 @@ int git_diff_file_content__init_from_src(
 			fc->flags |= GIT_DIFF_FLAG__FREE_BLOB;
 		} else {
 			int error;
-			if ((error = git_odb__hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB, GIT_OID_SHA1)) < 0)
+			if ((error = git_odb__hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB, opts->oid_type)) < 0)
 				return error;
 			fc->file->size = src->buflen;
-			fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE;
+			fc->file->id_abbrev = (uint16_t)git_oid_hexsize(opts->oid_type);
 
 			fc->map.len  = src->buflen;
 			fc->map.data = (char *)src->buf;
@@ -178,7 +178,7 @@ int git_diff_file_content__init_from_src(
 static int diff_file_content_commit_to_str(
 	git_diff_file_content *fc, bool check_status)
 {
-	char oid[GIT_OID_SHA1_HEXSIZE+1];
+	char oid[GIT_OID_MAX_HEXSIZE+1];
 	git_str content = GIT_STR_INIT;
 	const char *status = "";
 
@@ -420,7 +420,7 @@ static int diff_file_content_load_workdir(
 	if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
 		error = git_odb__hash(
 			&fc->file->id, fc->map.data, fc->map.len,
-			GIT_OBJECT_BLOB, GIT_OID_SHA1);
+			GIT_OBJECT_BLOB, diff_opts->oid_type);
 		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 	}
 

data/vendor/libgit2/src/libgit2/diff_generate.c

@@ -61,8 +61,8 @@ static git_diff_delta *diff_delta__alloc(
 	}
 	delta->status = status;
 
-	git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
-	git_oid_clear(&delta->new_file.id, GIT_OID_SHA1);
+	git_oid_clear(&delta->old_file.id, diff->base.opts.oid_type);
+	git_oid_clear(&delta->new_file.id, diff->base.opts.oid_type);
 
 	return delta;
 }
@@ -149,10 +149,13 @@ static int diff_delta__from_one(
 	const git_index_entry *entry = nitem;
 	bool has_old = false;
 	git_diff_delta *delta;
+	git_oid_t oid_type;
 	const char *matched_pathspec;
 
 	GIT_ASSERT_ARG((oitem != NULL) ^ (nitem != NULL));
 
+	oid_type = diff->base.opts.oid_type;
+
 	if (oitem) {
 		entry = oitem;
 		has_old = true;
@@ -186,20 +189,23 @@ static int diff_delta__from_one(
 	GIT_ASSERT(status != GIT_DELTA_MODIFIED);
 	delta->nfiles = 1;
 
+	git_oid_clear(&delta->old_file.id, diff->base.opts.oid_type);
+	git_oid_clear(&delta->new_file.id, diff->base.opts.oid_type);
+
 	if (has_old) {
 		delta->old_file.mode = entry->mode;
 		delta->old_file.size = entry->file_size;
 		delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;
 		git_oid_cpy(&delta->old_file.id, &entry->id);
-		git_oid_clear(&delta->new_file.id, GIT_OID_SHA1);
-		delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+		git_oid_clear(&delta->new_file.id, oid_type);
+		delta->old_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
 	} else /* ADDED, IGNORED, UNTRACKED */ {
 		delta->new_file.mode = entry->mode;
 		delta->new_file.size = entry->file_size;
 		delta->new_file.flags |= GIT_DIFF_FLAG_EXISTS;
-		git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
+		git_oid_clear(&delta->old_file.id, oid_type);
 		git_oid_cpy(&delta->new_file.id, &entry->id);
-		delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+		delta->new_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
 	}
 
 	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
@@ -225,6 +231,9 @@ static int diff_delta__from_two(
 	const git_oid *old_id = &old_entry->id;
 	git_diff_delta *delta;
 	const char *canonical_path = old_entry->path;
+	git_oid_t oid_type;
+
+	oid_type = diff->base.opts.oid_type;
 
 	if (status == GIT_DELTA_UNMODIFIED &&
 		DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNMODIFIED))
@@ -254,14 +263,14 @@ static int diff_delta__from_two(
 		delta->old_file.size = old_entry->file_size;
 		delta->old_file.mode = old_mode;
 		git_oid_cpy(&delta->old_file.id, old_id);
-		delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+		delta->old_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
 		delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID |
 			GIT_DIFF_FLAG_EXISTS;
 	}
 
 	if (!git_index_entry_is_conflict(new_entry)) {
 		git_oid_cpy(&delta->new_file.id, new_id);
-		delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+		delta->new_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
 		delta->new_file.size = new_entry->file_size;
 		delta->new_file.mode = new_mode;
 		delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;
@@ -490,6 +499,14 @@ static int diff_generated_apply_options(
 			return -1;
 	}
 
+	if (!diff->base.opts.oid_type) {
+		diff->base.opts.oid_type = repo->oid_type;
+	} else if (diff->base.opts.oid_type != repo->oid_type) {
+		git_error_set(GIT_ERROR_INVALID,
+			"specified object ID type does not match repository object ID type");
+		return -1;
+	}
+
 	/* flag INCLUDE_TYPECHANGE_TREES implies INCLUDE_TYPECHANGE */
 	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE_TREES))
 		diff->base.opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE;
@@ -603,7 +620,7 @@ int git_diff__oid_for_file(
 	entry.mode = mode;
 	entry.file_size = (uint32_t)size;
 	entry.path = (char *)path;
-	git_oid_clear(&entry.id, GIT_OID_SHA1);
+	git_oid_clear(&entry.id, diff->opts.oid_type);
 
 	return git_diff__oid_for_entry(out, diff, &entry, mode, NULL);
 }
@@ -624,7 +641,7 @@ int git_diff__oid_for_entry(
 	GIT_ASSERT(d->type == GIT_DIFF_TYPE_GENERATED);
 	diff = (git_diff_generated *)d;
 
-	git_oid_clear(out, GIT_OID_SHA1);
+	git_oid_clear(out, diff->base.opts.oid_type);
 
 	if (git_repository_workdir_path(&full_path, diff->base.repo, entry.path) < 0)
 		return -1;
@@ -660,7 +677,8 @@ int git_diff__oid_for_entry(
 			git_error_clear();
 		}
 	} else if (S_ISLNK(mode)) {
-		error = git_odb__hashlink(out, full_path.ptr, GIT_OID_SHA1);
+		error = git_odb__hashlink(out, full_path.ptr,
+			diff->base.opts.oid_type);
 		diff->base.perf.oid_calculations++;
 	} else if (!git__is_sizet(entry.file_size)) {
 		git_error_set(GIT_ERROR_NOMEMORY, "file size overflow (for 32-bits) on '%s'",
@@ -676,7 +694,8 @@ int git_diff__oid_for_entry(
 		else {
 			error = git_odb__hashfd_filtered(
 				out, fd, (size_t)entry.file_size,
-				GIT_OBJECT_BLOB, GIT_OID_SHA1, fl);
+				GIT_OBJECT_BLOB, diff->base.opts.oid_type,
+				fl);
 			p_close(fd);
 			diff->base.perf.oid_calculations++;
 		}
@@ -785,7 +804,7 @@ static int maybe_modified(
 	git_diff_generated *diff,
 	diff_in_progress *info)
 {
-	git_oid noid = GIT_OID_SHA1_ZERO;
+	git_oid noid;
 	git_delta_t status = GIT_DELTA_MODIFIED;
 	const git_index_entry *oitem = info->oitem;
 	const git_index_entry *nitem = info->nitem;
@@ -796,6 +815,8 @@ static int maybe_modified(
 	const char *matched_pathspec;
 	int error = 0;
 
+	git_oid_clear(&noid, diff->base.opts.oid_type);
+
 	if (!diff_pathspec_match(&matched_pathspec, diff, oitem))
 		return 0;
 
@@ -1700,11 +1721,11 @@ int git_diff__commit(
 	*out = NULL;
 
 	if ((parents = git_commit_parentcount(commit)) > 1) {
-		char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
+		char commit_oidstr[GIT_OID_MAX_HEXSIZE + 1];
 
 		error = -1;
 		git_error_set(GIT_ERROR_INVALID, "commit %s is a merge commit",
-			git_oid_tostr(commit_oidstr, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit)));
+			git_oid_tostr(commit_oidstr, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit)));
 		goto on_error;
 	}
 

data/vendor/libgit2/src/libgit2/diff_parse.c

@@ -29,7 +29,7 @@ static void diff_parsed_free(git_diff *d)
 	git__free(diff);
 }
 
-static git_diff_parsed *diff_parsed_alloc(void)
+static git_diff_parsed *diff_parsed_alloc(git_oid_t oid_type)
 {
 	git_diff_parsed *diff;
 
@@ -51,6 +51,7 @@ static git_diff_parsed *diff_parsed_alloc(void)
 	}
 
 	diff->base.opts.flags &= ~GIT_DIFF_IGNORE_CASE;
+	diff->base.opts.oid_type = oid_type;
 
 	if (git_pool_init(&diff->base.pool, 1) < 0 ||
 	    git_vector_init(&diff->patches, 0, NULL) < 0 ||
@@ -67,19 +68,34 @@ static git_diff_parsed *diff_parsed_alloc(void)
 int git_diff_from_buffer(
 	git_diff **out,
 	const char *content,
-	size_t content_len)
+	size_t content_len
+#ifdef GIT_EXPERIMENTAL_SHA256
+	, git_diff_parse_options *opts
+#endif
+	)
 {
 	git_diff_parsed *diff;
 	git_patch *patch;
 	git_patch_parse_ctx *ctx = NULL;
+	git_patch_options patch_opts = GIT_PATCH_OPTIONS_INIT;
+	git_oid_t oid_type;
 	int error = 0;
 
 	*out = NULL;
 
-	diff = diff_parsed_alloc();
+#ifdef GIT_EXPERIMENTAL_SHA256
+	oid_type = (opts && opts->oid_type) ? opts->oid_type :
+		GIT_OID_DEFAULT;
+#else
+	oid_type = GIT_OID_DEFAULT;
+#endif
+
+	patch_opts.oid_type = oid_type;
+
+	diff = diff_parsed_alloc(oid_type);
 	GIT_ERROR_CHECK_ALLOC(diff);
 
-	ctx = git_patch_parse_ctx_init(content, content_len, NULL);
+	ctx = git_patch_parse_ctx_init(content, content_len, &patch_opts);
 	GIT_ERROR_CHECK_ALLOC(ctx);
 
 	while (ctx->parse_ctx.remain_len) {

data/vendor/libgit2/src/libgit2/diff_print.c

@@ -29,6 +29,7 @@ typedef struct {
 	const char *new_prefix;
 	uint32_t flags;
 	int id_strlen;
+	git_oid_t oid_type;
 
 	int (*strcomp)(const char *, const char *);
 } diff_print_info;
@@ -46,6 +47,8 @@ static int diff_print_info_init__common(
 	pi->payload = payload;
 	pi->buf = out;
 
+	GIT_ASSERT(pi->oid_type);
+
 	if (!pi->id_strlen) {
 		if (!repo)
 			pi->id_strlen = GIT_ABBREV_DEFAULT;
@@ -53,8 +56,9 @@ static int diff_print_info_init__common(
 			return -1;
 	}
 
-	if (pi->id_strlen > GIT_OID_SHA1_HEXSIZE)
-		pi->id_strlen = GIT_OID_SHA1_HEXSIZE;
+	if (pi->id_strlen > 0 &&
+	    (size_t)pi->id_strlen > git_oid_hexsize(pi->oid_type))
+		pi->id_strlen = (int)git_oid_hexsize(pi->oid_type);
 
 	memset(&pi->line, 0, sizeof(pi->line));
 	pi->line.old_lineno = -1;
@@ -78,6 +82,7 @@ static int diff_print_info_init_fromdiff(
 
 	if (diff) {
 		pi->flags = diff->opts.flags;
+		pi->oid_type = diff->opts.oid_type;
 		pi->id_strlen = diff->opts.id_abbrev;
 		pi->old_prefix = diff->opts.old_prefix;
 		pi->new_prefix = diff->opts.new_prefix;
@@ -101,6 +106,7 @@ static int diff_print_info_init_frompatch(
 	memset(pi, 0, sizeof(diff_print_info));
 
 	pi->flags = patch->diff_opts.flags;
+	pi->oid_type = patch->diff_opts.oid_type;
 	pi->id_strlen = patch->diff_opts.id_abbrev;
 	pi->old_prefix = patch->diff_opts.old_prefix;
 	pi->new_prefix = patch->diff_opts.new_prefix;
@@ -212,7 +218,10 @@ static int diff_print_one_raw(
 	git_str *out = pi->buf;
 	int id_abbrev;
 	char code = git_diff_status_char(delta->status);
-	char start_oid[GIT_OID_SHA1_HEXSIZE+1], end_oid[GIT_OID_SHA1_HEXSIZE+1];
+	char start_oid[GIT_OID_MAX_HEXSIZE + 1],
+	     end_oid[GIT_OID_MAX_HEXSIZE + 1];
+	size_t oid_hexsize;
+	bool id_is_abbrev;
 
 	GIT_UNUSED(progress);
 
@@ -231,12 +240,21 @@ static int diff_print_one_raw(
 		return -1;
 	}
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	GIT_ASSERT(delta->old_file.id.type == delta->new_file.id.type);
+	oid_hexsize = git_oid_hexsize(delta->old_file.id.type);
+#else
+	oid_hexsize = GIT_OID_SHA1_HEXSIZE;
+#endif
+
+	id_is_abbrev = (pi->id_strlen > 0 &&
+	                (size_t)pi->id_strlen <= oid_hexsize);
+
 	git_oid_tostr(start_oid, pi->id_strlen + 1, &delta->old_file.id);
 	git_oid_tostr(end_oid, pi->id_strlen + 1, &delta->new_file.id);
 
-	git_str_printf(
-		out, (pi->id_strlen <= GIT_OID_SHA1_HEXSIZE) ?
-			":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c",
+	git_str_printf(out,
+		id_is_abbrev ? ":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c",
 		delta->old_file.mode, delta->new_file.mode, start_oid, end_oid, code);
 
 	if (delta->similarity > 0)
@@ -273,7 +291,8 @@ static int diff_print_oid_range(
 	git_str *out, const git_diff_delta *delta, int id_strlen,
 	bool print_index)
 {
-	char start_oid[GIT_OID_SHA1_HEXSIZE+1], end_oid[GIT_OID_SHA1_HEXSIZE+1];
+	char start_oid[GIT_OID_MAX_HEXSIZE + 1],
+	     end_oid[GIT_OID_MAX_HEXSIZE + 1];
 
 	if (delta->old_file.mode &&
 			id_strlen > delta->old_file.id_abbrev) {

data/vendor/libgit2/src/libgit2/diff_tform.c

@@ -364,7 +364,7 @@ static int insert_delete_side_of_split(
 	memset(&deleted->new_file, 0, sizeof(deleted->new_file));
 	deleted->new_file.path = deleted->old_file.path;
 	deleted->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
-	git_oid_clear(&deleted->new_file.id, GIT_OID_SHA1);
+	git_oid_clear(&deleted->new_file.id, diff->opts.oid_type);
 
 	return git_vector_insert(onto, deleted);
 }
@@ -398,7 +398,7 @@ static int apply_splits_and_deletes(
 			memset(&delta->old_file, 0, sizeof(delta->old_file));
 			delta->old_file.path = delta->new_file.path;
 			delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
-			git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
+			git_oid_clear(&delta->old_file.id, diff->opts.oid_type);
 		}
 
 		/* clean up delta before inserting into new list */
@@ -997,7 +997,7 @@ find_best_matches:
 				memset(&src->new_file, 0, sizeof(src->new_file));
 				src->new_file.path = src->old_file.path;
 				src->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
-				git_oid_clear(&src->new_file.id, GIT_OID_SHA1);
+				git_oid_clear(&src->new_file.id, diff->opts.oid_type);
 
 				num_updates++;
 
@@ -1023,7 +1023,7 @@ find_best_matches:
 				memset(&src->old_file, 0, sizeof(src->old_file));
 				src->old_file.path = src->new_file.path;
 				src->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
-				git_oid_clear(&src->old_file.id, GIT_OID_SHA1);
+				git_oid_clear(&src->old_file.id, diff->opts.oid_type);
 
 				src->flags &= ~GIT_DIFF_FLAG__TO_SPLIT;
 				num_rewrites--;

data/vendor/libgit2/src/libgit2/diff_xdiff.h

@@ -10,7 +10,7 @@
 #include "common.h"
 
 #include "diff.h"
-#include "xdiff/xdiff.h"
+#include "xdiff.h"
 #include "patch_generate.h"
 
 /* xdiff cannot cope with large files.  these files should not be passed to

data/vendor/libgit2/src/libgit2/email.c

@@ -130,11 +130,12 @@ static int append_header(
 	const git_signature *author,
 	git_email_create_options *opts)
 {
-	char id[GIT_OID_SHA1_HEXSIZE];
+	char id[GIT_OID_MAX_HEXSIZE + 1];
 	int error;
 
-	if ((error = git_oid_fmt(id, commit_id)) < 0 ||
-	    (error = git_str_printf(out, "From %.*s %s\n", GIT_OID_SHA1_HEXSIZE, id, EMAIL_TIMESTAMP)) < 0 ||
+	git_oid_tostr(id, GIT_OID_MAX_HEXSIZE + 1, commit_id);
+
+	if ((error = git_str_printf(out, "From %s %s\n", id, EMAIL_TIMESTAMP)) < 0 ||
 	    (error = git_str_printf(out, "From: %s <%s>\n", author->name, author->email)) < 0 ||
 	    (error = append_date(out, &author->when)) < 0 ||
 	    (error = append_subject(out, patch_idx, patch_count, summary, opts)) < 0)

data/vendor/libgit2/src/libgit2/errors.c

@@ -16,32 +16,51 @@
  * New error handling
  ********************************************/
 
-static git_error g_git_oom_error = {
+static git_error oom_error = {
 	"Out of memory",
 	GIT_ERROR_NOMEMORY
 };
 
-static git_error g_git_uninitialized_error = {
+static git_error uninitialized_error = {
 	"libgit2 has not been initialized; you must call git_libgit2_init",
 	GIT_ERROR_INVALID
 };
 
+static git_error tlsdata_error = {
+	"thread-local data initialization failure",
+	GIT_ERROR
+};
+
 static void set_error_from_buffer(int error_class)
 {
-	git_error *error = &GIT_THREADSTATE->error_t;
-	git_str *buf = &GIT_THREADSTATE->error_buf;
+	git_threadstate *threadstate = git_threadstate_get();
+	git_error *error;
+	git_str *buf;
+
+	if (!threadstate)
+		return;
+
+	error = &threadstate->error_t;
+	buf = &threadstate->error_buf;
 
 	error->message = buf->ptr;
 	error->klass = error_class;
 
-	GIT_THREADSTATE->last_error = error;
+	threadstate->last_error = error;
 }
 
 static void set_error(int error_class, char *string)
 {
-	git_str *buf = &GIT_THREADSTATE->error_buf;
+	git_threadstate *threadstate = git_threadstate_get();
+	git_str *buf;
+
+	if (!threadstate)
+		return;
+
+	buf = &threadstate->error_buf;
 
 	git_str_clear(buf);
+
 	if (string) {
 		git_str_puts(buf, string);
 		git__free(string);
@@ -52,7 +71,12 @@ static void set_error(int error_class, char *string)
 
 void git_error_set_oom(void)
 {
-	GIT_THREADSTATE->last_error = &g_git_oom_error;
+	git_threadstate *threadstate = git_threadstate_get();
+
+	if (!threadstate)
+		return;
+
+	threadstate->last_error = &oom_error;
 }
 
 void git_error_set(int error_class, const char *fmt, ...)
@@ -69,10 +93,18 @@ void git_error_vset(int error_class, const char *fmt, va_list ap)
 #ifdef GIT_WIN32
 	DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0;
 #endif
+
+	git_threadstate *threadstate = git_threadstate_get();
 	int error_code = (error_class == GIT_ERROR_OS) ? errno : 0;
-	git_str *buf = &GIT_THREADSTATE->error_buf;
+	git_str *buf;
+
+	if (!threadstate)
+		return;
+
+	buf = &threadstate->error_buf;
 
 	git_str_clear(buf);
+
 	if (fmt) {
 		git_str_vprintf(buf, fmt, ap);
 		if (error_class == GIT_ERROR_OS)
@@ -81,7 +113,7 @@ void git_error_vset(int error_class, const char *fmt, va_list ap)
 
 	if (error_class == GIT_ERROR_OS) {
 #ifdef GIT_WIN32
-		char * win32_error = git_win32_get_error_message(win32_error_code);
+		char *win32_error = git_win32_get_error_message(win32_error_code);
 		if (win32_error) {
 			git_str_puts(buf, win32_error);
 			git__free(win32_error);
@@ -103,10 +135,16 @@ void git_error_vset(int error_class, const char *fmt, va_list ap)
 
 int git_error_set_str(int error_class, const char *string)
 {
-	git_str *buf = &GIT_THREADSTATE->error_buf;
+	git_threadstate *threadstate = git_threadstate_get();
+	git_str *buf;
 
 	GIT_ASSERT_ARG(string);
 
+	if (!threadstate)
+		return -1;
+
+	buf = &threadstate->error_buf;
+
 	git_str_clear(buf);
 	git_str_puts(buf, string);
 
@@ -119,9 +157,14 @@ int git_error_set_str(int error_class, const char *string)
 
 void git_error_clear(void)
 {
-	if (GIT_THREADSTATE->last_error != NULL) {
+	git_threadstate *threadstate = git_threadstate_get();
+
+	if (!threadstate)
+		return;
+
+	if (threadstate->last_error != NULL) {
 		set_error(0, NULL);
-		GIT_THREADSTATE->last_error = NULL;
+		threadstate->last_error = NULL;
 	}
 
 	errno = 0;
@@ -132,17 +175,29 @@ void git_error_clear(void)
 
 const git_error *git_error_last(void)
 {
+	git_threadstate *threadstate;
+
 	/* If the library is not initialized, return a static error. */
 	if (!git_libgit2_init_count())
-		return &g_git_uninitialized_error;
+		return &uninitialized_error;
+
+	if ((threadstate = git_threadstate_get()) == NULL)
+		return &tlsdata_error;
 
-	return GIT_THREADSTATE->last_error;
+	return threadstate->last_error;
 }
 
 int git_error_state_capture(git_error_state *state, int error_code)
 {
-	git_error *error = GIT_THREADSTATE->last_error;
-	git_str *error_buf = &GIT_THREADSTATE->error_buf;
+	git_threadstate *threadstate = git_threadstate_get();
+	git_error *error;
+	git_str *error_buf;
+
+	if (!threadstate)
+		return -1;
+
+	error = threadstate->last_error;
+	error_buf = &threadstate->error_buf;
 
 	memset(state, 0, sizeof(git_error_state));
 
@@ -150,13 +205,13 @@ int git_error_state_capture(git_error_state *state, int error_code)
 		return 0;
 
 	state->error_code = error_code;
-	state->oom = (error == &g_git_oom_error);
+	state->oom = (error == &oom_error);
 
 	if (error) {
 		state->error_msg.klass = error->klass;
 
 		if (state->oom)
-			state->error_msg.message = g_git_oom_error.message;
+			state->error_msg.message = oom_error.message;
 		else
 			state->error_msg.message = git_str_detach(error_buf);
 	}