rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/merge_file.c

@@ -6,169 +6,306 @@
  */
 
 #include "common.h"
+
 #include "repository.h"
-#include "merge_file.h"
+#include "posix.h"
+#include "fileops.h"
+#include "index.h"
+#include "diff_xdiff.h"
+#include "merge.h"
 
 #include "git2/repository.h"
 #include "git2/object.h"
 #include "git2/index.h"
+#include "git2/merge.h"
 
 #include "xdiff/xdiff.h"
 
+/* only examine the first 8000 bytes for binaryness.
+ * https://github.com/git/git/blob/77bd3ea9f54f1584147b594abc04c26ca516d987/xdiff-interface.c#L197
+ */
+#define GIT_MERGE_FILE_BINARY_SIZE 8000
+
 #define GIT_MERGE_FILE_SIDE_EXISTS(X)	((X)->mode != 0)
 
-GIT_INLINE(const char *) merge_file_best_path(
-	const git_merge_file_input *ancestor,
-	const git_merge_file_input *ours,
-	const git_merge_file_input *theirs)
+int git_merge_file__input_from_index(
+	git_merge_file_input *input_out,
+	git_odb_object **odb_object_out,
+	git_odb *odb,
+	const git_index_entry *entry)
 {
-	if (!GIT_MERGE_FILE_SIDE_EXISTS(ancestor)) {
-		if (strcmp(ours->path, theirs->path) == 0)
-			return ours->path;
+	int error = 0;
 
-		return NULL;
-	}
+	assert(input_out && odb_object_out && odb && entry);
+
+	if ((error = git_odb_read(odb_object_out, odb, &entry->id)) < 0)
+		goto done;
 
-	if (strcmp(ancestor->path, ours->path) == 0)
-		return theirs->path;
-	else if(strcmp(ancestor->path, theirs->path) == 0)
-		return ours->path;
+	input_out->path = entry->path;
+	input_out->mode = entry->mode;
+	input_out->ptr = (char *)git_odb_object_data(*odb_object_out);
+	input_out->size = git_odb_object_size(*odb_object_out);
 
-	return NULL;
+done:
+	return error;
 }
 
-GIT_INLINE(int) merge_file_best_mode(
+static void merge_file_normalize_opts(
+	git_merge_file_options *out,
+	const git_merge_file_options *given_opts)
+{
+	if (given_opts)
+		memcpy(out, given_opts, sizeof(git_merge_file_options));
+	else {
+		git_merge_file_options default_opts = GIT_MERGE_FILE_OPTIONS_INIT;
+		memcpy(out, &default_opts, sizeof(git_merge_file_options));
+	}
+}
+
+static int merge_file__xdiff(
+	git_merge_file_result *out,
 	const git_merge_file_input *ancestor,
 	const git_merge_file_input *ours,
-	const git_merge_file_input *theirs)
+	const git_merge_file_input *theirs,
+	const git_merge_file_options *given_opts)
 {
-	/*
-	 * If ancestor didn't exist and either ours or theirs is executable,
-	 * assume executable.  Otherwise, if any mode changed from the ancestor,
-	 * use that one.
-	 */
-	if (GIT_MERGE_FILE_SIDE_EXISTS(ancestor)) {
-		if (ours->mode == GIT_FILEMODE_BLOB_EXECUTABLE ||
-			theirs->mode == GIT_FILEMODE_BLOB_EXECUTABLE)
-			return GIT_FILEMODE_BLOB_EXECUTABLE;
-
-		return GIT_FILEMODE_BLOB;
+	xmparam_t xmparam;
+	mmfile_t ancestor_mmfile = {0}, our_mmfile = {0}, their_mmfile = {0};
+	mmbuffer_t mmbuffer;
+	git_merge_file_options options = GIT_MERGE_FILE_OPTIONS_INIT;
+	const char *path;
+	int xdl_result;
+	int error = 0;
+
+	memset(out, 0x0, sizeof(git_merge_file_result));
+
+	merge_file_normalize_opts(&options, given_opts);
+
+	memset(&xmparam, 0x0, sizeof(xmparam_t));
+
+	if (ancestor) {
+		xmparam.ancestor = (options.ancestor_label) ?
+			options.ancestor_label : ancestor->path;
+		ancestor_mmfile.ptr = (char *)ancestor->ptr;
+		ancestor_mmfile.size = ancestor->size;
 	}
 
-	if (ancestor->mode == ours->mode)
-		return theirs->mode;
-	else if(ancestor->mode == theirs->mode)
-		return ours->mode;
+	xmparam.file1 = (options.our_label) ?
+		options.our_label : ours->path;
+	our_mmfile.ptr = (char *)ours->ptr;
+	our_mmfile.size = ours->size;
 
-	return 0;
-}
+	xmparam.file2 = (options.their_label) ?
+		options.their_label : theirs->path;
+	their_mmfile.ptr = (char *)theirs->ptr;
+	their_mmfile.size = theirs->size;
 
-int git_merge_file_input_from_index_entry(
-	git_merge_file_input *input,
-	git_repository *repo,
-	const git_index_entry *entry)
-{
-	git_odb *odb = NULL;
-	int error = 0;
+	if (options.favor == GIT_MERGE_FILE_FAVOR_OURS)
+		xmparam.favor = XDL_MERGE_FAVOR_OURS;
+	else if (options.favor == GIT_MERGE_FILE_FAVOR_THEIRS)
+		xmparam.favor = XDL_MERGE_FAVOR_THEIRS;
+	else if (options.favor == GIT_MERGE_FILE_FAVOR_UNION)
+		xmparam.favor = XDL_MERGE_FAVOR_UNION;
+
+	xmparam.level = (options.flags & GIT_MERGE_FILE_SIMPLIFY_ALNUM) ?
+		XDL_MERGE_ZEALOUS_ALNUM : XDL_MERGE_ZEALOUS;
+
+	if (options.flags & GIT_MERGE_FILE_STYLE_DIFF3)
+		xmparam.style = XDL_MERGE_DIFF3;
+
+	if (options.flags & GIT_MERGE_FILE_IGNORE_WHITESPACE)
+		xmparam.xpp.flags |= XDF_IGNORE_WHITESPACE;
+	if (options.flags & GIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGE)
+		xmparam.xpp.flags |= XDF_IGNORE_WHITESPACE_CHANGE;
+	if (options.flags & GIT_MERGE_FILE_IGNORE_WHITESPACE_EOL)
+		xmparam.xpp.flags |= XDF_IGNORE_WHITESPACE_AT_EOL;
+
+	if (options.flags & GIT_MERGE_FILE_DIFF_PATIENCE)
+		xmparam.xpp.flags |= XDF_PATIENCE_DIFF;
 
-	assert(input && repo && entry);
+	if (options.flags & GIT_MERGE_FILE_DIFF_MINIMAL)
+		xmparam.xpp.flags |= XDF_NEED_MINIMAL;
 
-	if (entry->mode == 0)
-		return 0;
+	xmparam.marker_size = options.marker_size;
 
-	if ((error = git_repository_odb(&odb, repo)) < 0 ||
-		(error = git_odb_read(&input->odb_object, odb, &entry->oid)) < 0)
+	if ((xdl_result = xdl_merge(&ancestor_mmfile, &our_mmfile,
+		&their_mmfile, &xmparam, &mmbuffer)) < 0) {
+		git_error_set(GIT_ERROR_MERGE, "failed to merge files");
+		error = -1;
 		goto done;
+	}
 
-	input->mode = entry->mode;
-	input->path = git__strdup(entry->path);
-	input->mmfile.size = git_odb_object_size(input->odb_object);
-	input->mmfile.ptr = (char *)git_odb_object_data(input->odb_object);
+	path = git_merge_file__best_path(
+		ancestor ? ancestor->path : NULL,
+		ours->path,
+		theirs->path);
 
-	if (input->label == NULL)
-		input->label = entry->path;
+	if (path != NULL && (out->path = git__strdup(path)) == NULL) {
+		error = -1;
+		goto done;
+	}
+
+	out->automergeable = (xdl_result == 0);
+	out->ptr = (const char *)mmbuffer.ptr;
+	out->len = mmbuffer.size;
+	out->mode = git_merge_file__best_mode(
+		ancestor ? ancestor->mode : 0,
+		ours->mode,
+		theirs->mode);
 
 done:
-	git_odb_free(odb);
+	if (error < 0)
+		git_merge_file_result_free(out);
 
 	return error;
 }
 
-int git_merge_file_input_from_diff_file(
-	git_merge_file_input *input,
-	git_repository *repo,
-	const git_diff_file *file)
+static bool merge_file__is_binary(const git_merge_file_input *file)
 {
-	git_odb *odb = NULL;
-	int error = 0;
+	size_t len = file ? file->size : 0;
 
-	assert(input && repo && file);
+	if (len > GIT_XDIFF_MAX_SIZE)
+		return true;
+	if (len > GIT_MERGE_FILE_BINARY_SIZE)
+		len = GIT_MERGE_FILE_BINARY_SIZE;
 
-	if (file->mode == 0)
-		return 0;
+	return len ? (memchr(file->ptr, 0, len) != NULL) : false;
+}
 
-	if ((error = git_repository_odb(&odb, repo)) < 0 ||
-		(error = git_odb_read(&input->odb_object, odb, &file->oid)) < 0)
+static int merge_file__binary(
+	git_merge_file_result *out,
+	const git_merge_file_input *ours,
+	const git_merge_file_input *theirs,
+	const git_merge_file_options *given_opts)
+{
+	const git_merge_file_input *favored = NULL;
+
+	memset(out, 0x0, sizeof(git_merge_file_result));
+
+	if (given_opts && given_opts->favor == GIT_MERGE_FILE_FAVOR_OURS)
+		favored = ours;
+	else if (given_opts && given_opts->favor == GIT_MERGE_FILE_FAVOR_THEIRS)
+		favored = theirs;
+	else
 		goto done;
 
-	input->mode = file->mode;
-	input->path = git__strdup(file->path);
-	input->mmfile.size = git_odb_object_size(input->odb_object);
-	input->mmfile.ptr = (char *)git_odb_object_data(input->odb_object);
+	if ((out->path = git__strdup(favored->path)) == NULL ||
+		(out->ptr = git__malloc(favored->size)) == NULL)
+		goto done;
 
-	if (input->label == NULL)
-		input->label = file->path;
+	memcpy((char *)out->ptr, favored->ptr, favored->size);
+	out->len = favored->size;
+	out->mode = favored->mode;
+	out->automergeable = 1;
 
 done:
-	git_odb_free(odb);
+	return 0;
+}
 
-	return error;
+static int merge_file__from_inputs(
+	git_merge_file_result *out,
+	const git_merge_file_input *ancestor,
+	const git_merge_file_input *ours,
+	const git_merge_file_input *theirs,
+	const git_merge_file_options *given_opts)
+{
+	if (merge_file__is_binary(ancestor) ||
+		merge_file__is_binary(ours) ||
+		merge_file__is_binary(theirs))
+		return merge_file__binary(out, ours, theirs, given_opts);
+
+	return merge_file__xdiff(out, ancestor, ours, theirs, given_opts);
 }
 
-int git_merge_files(
+static git_merge_file_input *git_merge_file__normalize_inputs(
+	git_merge_file_input *out,
+	const git_merge_file_input *given)
+{
+	memcpy(out, given, sizeof(git_merge_file_input));
+
+	if (!out->path)
+		out->path = "file.txt";
+
+	if (!out->mode)
+		out->mode = 0100644;
+
+	return out;
+}
+
+int git_merge_file(
 	git_merge_file_result *out,
-	git_merge_file_input *ancestor,
-	git_merge_file_input *ours,
-	git_merge_file_input *theirs,
-	git_merge_automerge_flags flags)
+	const git_merge_file_input *ancestor,
+	const git_merge_file_input *ours,
+	const git_merge_file_input *theirs,
+	const git_merge_file_options *options)
 {
-	xmparam_t xmparam;
-	mmbuffer_t mmbuffer;
-	int xdl_result;
-	int error = 0;
+	git_merge_file_input inputs[3] = { {0} };
 
-	assert(out && ancestor && ours && theirs);
+	assert(out && ours && theirs);
 
 	memset(out, 0x0, sizeof(git_merge_file_result));
 
-	if (!GIT_MERGE_FILE_SIDE_EXISTS(ours) || !GIT_MERGE_FILE_SIDE_EXISTS(theirs))
-		return 0;
+	if (ancestor)
+		ancestor = git_merge_file__normalize_inputs(&inputs[0], ancestor);
 
-	memset(&xmparam, 0x0, sizeof(xmparam_t));
-	xmparam.ancestor = ancestor->label;
-	xmparam.file1 = ours->label;
-	xmparam.file2 = theirs->label;
+	ours = git_merge_file__normalize_inputs(&inputs[1], ours);
+	theirs = git_merge_file__normalize_inputs(&inputs[2], theirs);
 
-	out->path = merge_file_best_path(ancestor, ours, theirs);
-	out->mode = merge_file_best_mode(ancestor, ours, theirs);
+	return merge_file__from_inputs(out, ancestor, ours, theirs, options);
+}
 
-	if (flags == GIT_MERGE_AUTOMERGE_FAVOR_OURS)
-		xmparam.favor = XDL_MERGE_FAVOR_OURS;
+int git_merge_file_from_index(
+	git_merge_file_result *out,
+	git_repository *repo,
+	const git_index_entry *ancestor,
+	const git_index_entry *ours,
+	const git_index_entry *theirs,
+	const git_merge_file_options *options)
+{
+	git_merge_file_input *ancestor_ptr = NULL,
+		ancestor_input = {0}, our_input = {0}, their_input = {0};
+	git_odb *odb = NULL;
+	git_odb_object *odb_object[3] = { 0 };
+	int error = 0;
 
-	if (flags == GIT_MERGE_AUTOMERGE_FAVOR_THEIRS)
-		xmparam.favor = XDL_MERGE_FAVOR_THEIRS;
+	assert(out && repo && ours && theirs);
 
-	if ((xdl_result = xdl_merge(&ancestor->mmfile, &ours->mmfile,
-		&theirs->mmfile, &xmparam, &mmbuffer)) < 0) {
-		giterr_set(GITERR_MERGE, "Failed to merge files.");
-		error = -1;
+	memset(out, 0x0, sizeof(git_merge_file_result));
+
+	if ((error = git_repository_odb(&odb, repo)) < 0)
 		goto done;
+
+	if (ancestor) {
+		if ((error = git_merge_file__input_from_index(
+			&ancestor_input, &odb_object[0], odb, ancestor)) < 0)
+			goto done;
+
+		ancestor_ptr = &ancestor_input;
 	}
 
-	out->automergeable = (xdl_result == 0);
-	out->data = (unsigned char *)mmbuffer.ptr;
-	out->len = mmbuffer.size;
+	if ((error = git_merge_file__input_from_index(
+			&our_input, &odb_object[1], odb, ours)) < 0 ||
+		(error = git_merge_file__input_from_index(
+			&their_input, &odb_object[2], odb, theirs)) < 0)
+		goto done;
+
+	error = merge_file__from_inputs(out,
+		ancestor_ptr, &our_input, &their_input, options);
 
 done:
+	git_odb_object_free(odb_object[0]);
+	git_odb_object_free(odb_object[1]);
+	git_odb_object_free(odb_object[2]);
+	git_odb_free(odb);
+
 	return error;
 }
+
+void git_merge_file_result_free(git_merge_file_result *result)
+{
+	if (result == NULL)
+		return;
+
+	git__free((char *)result->path);
+	git__free((char *)result->ptr);
+}

data/vendor/libgit2/src/message.c

@@ -21,7 +21,7 @@ static size_t line_length_without_trailing_spaces(const char *line, size_t len)
 
 /* Greatly inspired from git.git "stripspace" */
 /* see https://github.com/git/git/blob/497215d8811ac7b8955693ceaad0899ecd894ed2/builtin/stripspace.c#L4-67 */
-int git_message__prettify(git_buf *message_out, const char *message, int strip_comments)
+int git_message_prettify(git_buf *message_out, const char *message, int strip_comments, char comment_char)
 {
 	const size_t message_len = strlen(message);
 
@@ -29,6 +29,8 @@ int git_message__prettify(git_buf *message_out, const char *message, int strip_c
 	size_t i, line_length, rtrimmed_line_length;
 	char *next_newline;
 
+	git_buf_sanitize(message_out);
+
 	for (i = 0; i < strlen(message); i += line_length) {
 		next_newline = memchr(message + i, '\n', message_len - i);
 
@@ -38,7 +40,7 @@ int git_message__prettify(git_buf *message_out, const char *message, int strip_c
 			line_length = message_len - i;
 		}
 
-		if (strip_comments && line_length && message[i] == '#')
+		if (strip_comments && line_length && message[i] == comment_char)
 			continue;
 
 		rtrimmed_line_length = line_length_without_trailing_spaces(message + i, line_length);
@@ -58,29 +60,3 @@ int git_message__prettify(git_buf *message_out, const char *message, int strip_c
 
 	return git_buf_oom(message_out) ? -1 : 0;
 }
-
-int git_message_prettify(char *message_out, size_t buffer_size, const char *message, int strip_comments)
-{
-	git_buf buf = GIT_BUF_INIT;
-	ssize_t out_size = -1;
-
-	if (message_out && buffer_size)
-		*message_out = '\0';
-
-	if (git_message__prettify(&buf, message, strip_comments) < 0)
-		goto done;
-
-	if (message_out && buf.size + 1 > buffer_size) { /* +1 for NUL byte */
-		giterr_set(GITERR_INVALID, "Buffer too short to hold the cleaned message");
-		goto done;
-	}
-
-	if (message_out)
-		git_buf_copy_cstr(message_out, buffer_size, &buf);
-
-	out_size = buf.size + 1;
-
-done:
-	git_buf_free(&buf);
-	return (int)out_size;
-}

data/vendor/libgit2/src/message.h

@@ -7,9 +7,11 @@
 #ifndef INCLUDE_message_h__
 #define INCLUDE_message_h__
 
+#include "common.h"
+
 #include "git2/message.h"
 #include "buffer.h"
 
 int git_message__prettify(git_buf *message_out, const char *message, int strip_comments);
 
-#endif /* INCLUDE_message_h__ */
+#endif

data/vendor/libgit2/src/mwindow.c

@@ -5,12 +5,14 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "common.h"
 #include "mwindow.h"
+
 #include "vector.h"
 #include "fileops.h"
 #include "map.h"
 #include "global.h"
+#include "strmap.h"
+#include "pack.h"
 
 #define DEFAULT_WINDOW_SIZE \
 	(sizeof(void*) >= 8 \
@@ -26,20 +28,118 @@ size_t git_mwindow__mapped_limit = DEFAULT_MAPPED_LIMIT;
 /* Whenever you want to read or modify this, grab git__mwindow_mutex */
 static git_mwindow_ctl mem_ctl;
 
+/* Global list of mwindow files, to open packs once across repos */
+git_strmap *git__pack_cache = NULL;
+
+static void git_mwindow_files_free(void)
+{
+	git_strmap *tmp = git__pack_cache;
+
+	git__pack_cache = NULL;
+	git_strmap_free(tmp);
+}
+
+int git_mwindow_global_init(void)
+{
+	assert(!git__pack_cache);
+
+	git__on_shutdown(git_mwindow_files_free);
+	return git_strmap_alloc(&git__pack_cache);
+}
+
+int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
+{
+	int error;
+	char *packname;
+	size_t pos;
+	struct git_pack_file *pack;
+
+	if ((error = git_packfile__name(&packname, path)) < 0)
+		return error;
+
+	if (git_mutex_lock(&git__mwindow_mutex) < 0) {
+		git_error_set(GIT_ERROR_OS, "failed to lock mwindow mutex");
+		return -1;
+	}
+
+	pos = git_strmap_lookup_index(git__pack_cache, packname);
+	git__free(packname);
+
+	if (git_strmap_valid_index(git__pack_cache, pos)) {
+		pack = git_strmap_value_at(git__pack_cache, pos);
+		git_atomic_inc(&pack->refcount);
+
+		git_mutex_unlock(&git__mwindow_mutex);
+		*out = pack;
+		return 0;
+	}
+
+	/* If we didn't find it, we need to create it */
+	if ((error = git_packfile_alloc(&pack, path)) < 0) {
+		git_mutex_unlock(&git__mwindow_mutex);
+		return error;
+	}
+
+	git_atomic_inc(&pack->refcount);
+
+	git_strmap_insert(git__pack_cache, pack->pack_name, pack, &error);
+	git_mutex_unlock(&git__mwindow_mutex);
+
+	if (error < 0) {
+		git_packfile_free(pack);
+		return -1;
+	}
+
+	*out = pack;
+	return 0;
+}
+
+void git_mwindow_put_pack(struct git_pack_file *pack)
+{
+	int count;
+	size_t pos;
+
+	if (git_mutex_lock(&git__mwindow_mutex) < 0)
+		return;
+
+	/* put before get would be a corrupted state */
+	assert(git__pack_cache);
+
+	pos = git_strmap_lookup_index(git__pack_cache, pack->pack_name);
+	/* if we cannot find it, the state is corrupted */
+	assert(git_strmap_valid_index(git__pack_cache, pos));
+
+	count = git_atomic_dec(&pack->refcount);
+	if (count == 0) {
+		git_strmap_delete_at(git__pack_cache, pos);
+		git_packfile_free(pack);
+	}
+
+	git_mutex_unlock(&git__mwindow_mutex);
+	return;
+}
+
+void git_mwindow_free_all(git_mwindow_file *mwf)
+{
+	if (git_mutex_lock(&git__mwindow_mutex)) {
+		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
+		return;
+	}
+
+	git_mwindow_free_all_locked(mwf);
+
+	git_mutex_unlock(&git__mwindow_mutex);
+}
+
 /*
  * Free all the windows in a sequence, typically because we're done
  * with the file
  */
-void git_mwindow_free_all(git_mwindow_file *mwf)
+void git_mwindow_free_all_locked(git_mwindow_file *mwf)
 {
 	git_mwindow_ctl *ctl = &mem_ctl;
 	size_t i;
 
-	if (git_mutex_lock(&git__mwindow_mutex)) {
-		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
-		return;
-	}
-
 	/*
 	 * Remove these windows from the global list
 	 */
@@ -67,8 +167,6 @@ void git_mwindow_free_all(git_mwindow_file *mwf)
 		mwf->windows = w->next;
 		git__free(w);
 	}
-
-	git_mutex_unlock(&git__mwindow_mutex);
 }
 
 /*
@@ -131,7 +229,7 @@ static int git_mwindow_close_lru(git_mwindow_file *mwf)
 	}
 
 	if (!lru_w) {
-		giterr_set(GITERR_OS, "Failed to close memory window. Couldn't find LRU");
+		git_error_set(GIT_ERROR_OS, "failed to close memory window; couldn't find LRU");
 		return -1;
 	}
 
@@ -185,8 +283,18 @@ static git_mwindow *new_window(
 	 */
 
 	if (git_futils_mmap_ro(&w->window_map, fd, w->offset, (size_t)len) < 0) {
-		git__free(w);
-		return NULL;
+		/*
+		 * The first error might be down to memory fragmentation even if
+		 * we're below our soft limits, so free up what we can and try again.
+		 */
+
+		while (git_mwindow_close_lru(mwf) == 0)
+			/* nop */;
+
+		if (git_futils_mmap_ro(&w->window_map, fd, w->offset, (size_t)len) < 0) {
+			git__free(w);
+			return NULL;
+		}
 	}
 
 	ctl->mmap_calls++;
@@ -216,7 +324,7 @@ unsigned char *git_mwindow_open(
 	git_mwindow *w = *cursor;
 
 	if (git_mutex_lock(&git__mwindow_mutex)) {
-		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return NULL;
 	}
 
@@ -268,7 +376,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	int ret;
 
 	if (git_mutex_lock(&git__mwindow_mutex)) {
-		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return -1;
 	}
 
@@ -308,7 +416,7 @@ void git_mwindow_close(git_mwindow **window)
 	git_mwindow *w = *window;
 	if (w) {
 		if (git_mutex_lock(&git__mwindow_mutex)) {
-			giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+			git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 			return;
 		}