rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/diff_xdiff.c

@@ -6,7 +6,6 @@
  */
 
 #include "diff_xdiff.h"
-#include "util.h"
 
 #include "git2/errors.h"
 #include "diff.h"
@@ -52,7 +51,7 @@ static int git_xdiff_parse_hunk(git_diff_hunk *hunk, const char *header)
 	return 0;
 
 fail:
-	git_error_set(GIT_ERROR_INVALID, "malformed hunk header from xdiff");
+	giterr_set(GITERR_INVALID, "malformed hunk header from xdiff");
 	return -1;
 }
 
@@ -101,7 +100,7 @@ static int diff_update_lines(
 		info->new_lineno += (int)line->num_lines;
 		break;
 	default:
-		git_error_set(GIT_ERROR_INVALID, "unknown diff line origin %02x",
+		giterr_set(GITERR_INVALID, "unknown diff line origin %02x",
 			(unsigned int)line->origin);
 		return -1;
 	}
@@ -116,7 +115,6 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 	const git_diff_delta *delta = patch->base.delta;
 	git_patch_generated_output *output = &info->xo->output;
 	git_diff_line line;
-	size_t buffer_len;
 
 	if (len == 1) {
 		output->error = git_xdiff_parse_hunk(&info->hunk, bufs[0].ptr);
@@ -126,16 +124,6 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 		info->hunk.header_len = bufs[0].size;
 		if (info->hunk.header_len >= sizeof(info->hunk.header))
 			info->hunk.header_len = sizeof(info->hunk.header) - 1;
-
-		/* Sanitize the hunk header in case there is invalid Unicode */
-		buffer_len = git__utf8_valid_buf_length((const uint8_t *) bufs[0].ptr, info->hunk.header_len);
-		/* Sanitizing the hunk header may delete the newline, so add it back again if there is room */
-		if (buffer_len < info->hunk.header_len) {
-			bufs[0].ptr[buffer_len] = '\n';
-			buffer_len += 1;
-			info->hunk.header_len = buffer_len;
-		}
-
 		memcpy(info->hunk.header, bufs[0].ptr, info->hunk.header_len);
 		info->hunk.header[info->hunk.header_len] = '\0';
 
@@ -224,7 +212,7 @@ static int git_xdiff(git_patch_generated_output *output, git_patch_generated *pa
 
 	if (info.xd_old_data.size > GIT_XDIFF_MAX_SIZE ||
 		info.xd_new_data.size > GIT_XDIFF_MAX_SIZE) {
-		git_error_set(GIT_ERROR_INVALID, "files too large for diff");
+		giterr_set(GITERR_INVALID, "files too large for diff");
 		return -1;
 	}
 

data/vendor/libgit2/src/errors.c

@@ -17,7 +17,7 @@
 
 static git_error g_git_oom_error = {
 	"Out of memory",
-	GIT_ERROR_NOMEMORY
+	GITERR_NOMEMORY
 };
 
 static void set_error_from_buffer(int error_class)
@@ -44,36 +44,31 @@ static void set_error(int error_class, char *string)
 	set_error_from_buffer(error_class);
 }
 
-void git_error_set_oom(void)
+void giterr_set_oom(void)
 {
 	GIT_GLOBAL->last_error = &g_git_oom_error;
 }
 
-void git_error_set(int error_class, const char *fmt, ...)
-{
-	va_list ap;
-
-	va_start(ap, fmt);
-	git_error_vset(error_class, fmt, ap);
-	va_end(ap);
-}
-
-void git_error_vset(int error_class, const char *fmt, va_list ap)
+void giterr_set(int error_class, const char *string, ...)
 {
+	va_list arglist;
 #ifdef GIT_WIN32
-	DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0;
+	DWORD win32_error_code = (error_class == GITERR_OS) ? GetLastError() : 0;
 #endif
-	int error_code = (error_class == GIT_ERROR_OS) ? errno : 0;
+	int error_code = (error_class == GITERR_OS) ? errno : 0;
 	git_buf *buf = &GIT_GLOBAL->error_buf;
 
 	git_buf_clear(buf);
-	if (fmt) {
-		git_buf_vprintf(buf, fmt, ap);
-		if (error_class == GIT_ERROR_OS)
+	if (string) {
+		va_start(arglist, string);
+		git_buf_vprintf(buf, string, arglist);
+		va_end(arglist);
+
+		if (error_class == GITERR_OS)
 			git_buf_PUTS(buf, ": ");
 	}
 
-	if (error_class == GIT_ERROR_OS) {
+	if (error_class == GITERR_OS) {
 #ifdef GIT_WIN32
 		char * win32_error = git_win32_get_error_message(win32_error_code);
 		if (win32_error) {
@@ -95,7 +90,7 @@ void git_error_vset(int error_class, const char *fmt, va_list ap)
 		set_error_from_buffer(error_class);
 }
 
-void git_error_set_str(int error_class, const char *string)
+void giterr_set_str(int error_class, const char *string)
 {
 	git_buf *buf = &GIT_GLOBAL->error_buf;
 
@@ -110,7 +105,22 @@ void git_error_set_str(int error_class, const char *string)
 		set_error_from_buffer(error_class);
 }
 
-void git_error_clear(void)
+int giterr_set_regex(const regex_t *regex, int error_code)
+{
+	char error_buf[1024];
+
+	assert(error_code);
+
+	regerror(error_code, regex, error_buf, sizeof(error_buf));
+	giterr_set_str(GITERR_REGEX, error_buf);
+
+	if (error_code == REG_NOMATCH)
+		return GIT_ENOTFOUND;
+
+	return GIT_EINVALIDSPEC;
+}
+
+void giterr_clear(void)
 {
 	if (GIT_GLOBAL->last_error != NULL) {
 		set_error(0, NULL);
@@ -123,12 +133,12 @@ void git_error_clear(void)
 #endif
 }
 
-const git_error *git_error_last(void)
+const git_error *giterr_last(void)
 {
 	return GIT_GLOBAL->last_error;
 }
 
-int git_error_state_capture(git_error_state *state, int error_code)
+int giterr_state_capture(git_error_state *state, int error_code)
 {
 	git_error *error = GIT_GLOBAL->last_error;
 	git_buf *error_buf = &GIT_GLOBAL->error_buf;
@@ -150,19 +160,19 @@ int git_error_state_capture(git_error_state *state, int error_code)
 			state->error_msg.message = git_buf_detach(error_buf);
 	}
 
-	git_error_clear();
+	giterr_clear();
 	return error_code;
 }
 
-int git_error_state_restore(git_error_state *state)
+int giterr_state_restore(git_error_state *state)
 {
 	int ret = 0;
 
-	git_error_clear();
+	giterr_clear();
 
 	if (state && state->error_msg.message) {
 		if (state->oom)
-			git_error_set_oom();
+			giterr_set_oom();
 		else
 			set_error(state->error_msg.klass, state->error_msg.message);
 
@@ -173,7 +183,7 @@ int git_error_state_restore(git_error_state *state)
 	return ret;
 }
 
-void git_error_state_free(git_error_state *state)
+void giterr_state_free(git_error_state *state)
 {
 	if (!state)
 		return;
@@ -184,7 +194,7 @@ void git_error_state_free(git_error_state *state)
 	memset(state, 0, sizeof(git_error_state));
 }
 
-int git_error_system_last(void)
+int giterr_system_last(void)
 {
 #ifdef GIT_WIN32
 	return GetLastError();
@@ -193,7 +203,7 @@ int git_error_system_last(void)
 #endif
 }
 
-void git_error_system_set(int code)
+void giterr_system_set(int code)
 {
 #ifdef GIT_WIN32
 	SetLastError(code);
@@ -201,25 +211,3 @@ void git_error_system_set(int code)
 	errno = code;
 #endif
 }
-
-/* Deprecated error values and functions */
-
-const git_error *giterr_last(void)
-{
-	return git_error_last();
-}
-
-void giterr_clear(void)
-{
-	git_error_clear();
-}
-
-void giterr_set_str(int error_class, const char *string)
-{
-	git_error_set_str(error_class, string);
-}
-
-void giterr_set_oom(void)
-{
-	git_error_set_oom();
-}

data/vendor/libgit2/src/features.h.in

@@ -15,30 +15,22 @@
 #cmakedefine GIT_USE_STAT_MTIMESPEC 1
 #cmakedefine GIT_USE_STAT_MTIME_NSEC 1
 #cmakedefine GIT_USE_FUTIMENS 1
-
-#cmakedefine GIT_REGEX_REGCOMP_L
-#cmakedefine GIT_REGEX_REGCOMP
-#cmakedefine GIT_REGEX_PCRE
-#cmakedefine GIT_REGEX_PCRE2
-#cmakedefine GIT_REGEX_BUILTIN 1
+#cmakedefine GIT_USE_REGCOMP_L 1
 
 #cmakedefine GIT_SSH 1
 #cmakedefine GIT_SSH_MEMORY_CREDENTIALS 1
 
-#cmakedefine GIT_NTLM 1
 #cmakedefine GIT_GSSAPI 1
-#cmakedefine GIT_GSSFRAMEWORK 1
-
 #cmakedefine GIT_WINHTTP 1
+#cmakedefine GIT_CURL 1
+
 #cmakedefine GIT_HTTPS 1
 #cmakedefine GIT_OPENSSL 1
 #cmakedefine GIT_SECURE_TRANSPORT 1
-#cmakedefine GIT_MBEDTLS 1
 
 #cmakedefine GIT_SHA1_COLLISIONDETECT 1
 #cmakedefine GIT_SHA1_WIN32 1
 #cmakedefine GIT_SHA1_COMMON_CRYPTO 1
 #cmakedefine GIT_SHA1_OPENSSL 1
-#cmakedefine GIT_SHA1_MBEDTLS 1
 
 #endif

data/vendor/libgit2/src/fetch.c

@@ -78,7 +78,7 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts)
 			goto cleanup;
 
 		error = git_refspec__dwim_one(&remote->active_refspecs, &head, &remote->refs);
-		git_refspec__dispose(&head);
+		git_refspec__free(&head);
 
 		if (error < 0)
 			goto cleanup;
@@ -96,7 +96,7 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts)
 	}
 
 cleanup:
-	git_refspec__dispose(&tagspec);
+	git_refspec__free(&tagspec);
 
 	return error;
 }
@@ -113,7 +113,7 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts)
 	remote->need_pack = 0;
 
 	if (filter_wants(remote, opts) < 0) {
-		git_error_set(GIT_ERROR_NET, "failed to filter the reference list for wants");
+		giterr_set(GITERR_NET, "failed to filter the reference list for wants");
 		return -1;
 	}
 
@@ -134,7 +134,7 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts)
 int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *callbacks)
 {
 	git_transport *t = remote->transport;
-	git_indexer_progress_cb progress = NULL;
+	git_transfer_progress_cb progress = NULL;
 	void *payload = NULL;
 
 	if (!remote->need_pack)
@@ -148,14 +148,9 @@ int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *call
 	return t->download_pack(t, remote->repo, &remote->stats, progress, payload);
 }
 
-int git_fetch_options_init(git_fetch_options *opts, unsigned int version)
+int git_fetch_init_options(git_fetch_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_fetch_options, GIT_FETCH_OPTIONS_INIT);
 	return 0;
 }
-
-int git_fetch_init_options(git_fetch_options *opts, unsigned int version)
-{
-	return git_fetch_options_init(opts, version);
-}

data/vendor/libgit2/src/fetchhead.c

@@ -11,7 +11,7 @@
 #include "git2/oid.h"
 
 #include "buffer.h"
-#include "futils.h"
+#include "fileops.h"
 #include "filebuf.h"
 #include "refs.h"
 #include "repository.h"
@@ -50,7 +50,7 @@ int git_fetchhead_ref_create(
 	*out = NULL;
 
 	fetchhead_ref = git__malloc(sizeof(git_fetchhead_ref));
-	GIT_ERROR_CHECK_ALLOC(fetchhead_ref);
+	GITERR_CHECK_ALLOC(fetchhead_ref);
 
 	memset(fetchhead_ref, 0x0, sizeof(git_fetchhead_ref));
 
@@ -119,11 +119,11 @@ int git_fetchhead_write(git_repository *repo, git_vector *fetchhead_refs)
 		return -1;
 
 	if (git_filebuf_open(&file, path.ptr, GIT_FILEBUF_APPEND, GIT_REFS_FILE_MODE) < 0) {
-		git_buf_dispose(&path);
+		git_buf_free(&path);
 		return -1;
 	}
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	git_vector_sort(fetchhead_refs);
 
@@ -148,7 +148,7 @@ static int fetchhead_ref_parse(
 	*remote_url = NULL;
 
 	if (!*line) {
-		git_error_set(GIT_ERROR_FETCHHEAD,
+		giterr_set(GITERR_FETCHHEAD,
 			"empty line in FETCH_HEAD line %"PRIuZ, line_num);
 		return -1;
 	}
@@ -162,16 +162,16 @@ static int fetchhead_ref_parse(
 	}
 
 	if (strlen(oid_str) != GIT_OID_HEXSZ) {
-		git_error_set(GIT_ERROR_FETCHHEAD,
+		giterr_set(GITERR_FETCHHEAD,
 			"invalid object ID in FETCH_HEAD line %"PRIuZ, line_num);
 		return -1;
 	}
 
 	if (git_oid_fromstr(oid, oid_str) < 0) {
-		const git_error *oid_err = git_error_last();
+		const git_error *oid_err = giterr_last();
 		const char *err_msg = oid_err ? oid_err->message : "invalid object ID";
 
-		git_error_set(GIT_ERROR_FETCHHEAD, "%s in FETCH_HEAD line %"PRIuZ,
+		giterr_set(GITERR_FETCHHEAD, "%s in FETCH_HEAD line %"PRIuZ,
 			err_msg, line_num);
 		return -1;
 	}
@@ -179,7 +179,7 @@ static int fetchhead_ref_parse(
 	/* Parse new data from newer git clients */
 	if (*line) {
 		if ((is_merge_str = git__strsep(&line, "\t")) == NULL) {
-			git_error_set(GIT_ERROR_FETCHHEAD,
+			giterr_set(GITERR_FETCHHEAD,
 				"invalid description data in FETCH_HEAD line %"PRIuZ, line_num);
 			return -1;
 		}
@@ -189,13 +189,13 @@ static int fetchhead_ref_parse(
 		else if (strcmp(is_merge_str, "not-for-merge") == 0)
 			*is_merge = 0;
 		else {
-			git_error_set(GIT_ERROR_FETCHHEAD,
+			giterr_set(GITERR_FETCHHEAD,
 				"invalid for-merge entry in FETCH_HEAD line %"PRIuZ, line_num);
 			return -1;
 		}
 
 		if ((desc = line) == NULL) {
-			git_error_set(GIT_ERROR_FETCHHEAD,
+			giterr_set(GITERR_FETCHHEAD,
 				"invalid description in FETCH_HEAD line %"PRIuZ, line_num);
 			return -1;
 		}
@@ -212,7 +212,7 @@ static int fetchhead_ref_parse(
 		if (name) {
 			if ((desc = strstr(name, "' ")) == NULL ||
 				git__prefixcmp(desc, "' of ") != 0) {
-				git_error_set(GIT_ERROR_FETCHHEAD,
+				giterr_set(GITERR_FETCHHEAD,
 					"invalid description in FETCH_HEAD line %"PRIuZ, line_num);
 				return -1;
 			}
@@ -271,21 +271,21 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 
 		error = cb(ref_name, remote_url, &oid, is_merge, payload);
 		if (error) {
-			git_error_set_after_callback(error);
+			giterr_set_after_callback(error);
 			goto done;
 		}
 	}
 
 	if (*buffer) {
-		git_error_set(GIT_ERROR_FETCHHEAD, "no EOL at line %"PRIuZ, line_num+1);
+		giterr_set(GITERR_FETCHHEAD, "no EOL at line %"PRIuZ, line_num+1);
 		error = -1;
 		goto done;
 	}
 
 done:
-	git_buf_dispose(&file);
-	git_buf_dispose(&path);
-	git_buf_dispose(&name);
+	git_buf_free(&file);
+	git_buf_free(&path);
+	git_buf_free(&name);
 
 	return error;
 }

data/vendor/libgit2/src/filebuf.c

@@ -7,7 +7,7 @@
 
 #include "filebuf.h"
 
-#include "futils.h"
+#include "fileops.h"
 
 static const size_t WRITE_BUFFER_SIZE = (4096 * 2);
 
@@ -24,15 +24,15 @@ static int verify_last_error(git_filebuf *file)
 {
 	switch (file->last_error) {
 	case BUFERR_WRITE:
-		git_error_set(GIT_ERROR_OS, "failed to write out file");
+		giterr_set(GITERR_OS, "failed to write out file");
 		return -1;
 
 	case BUFERR_MEM:
-		git_error_set_oom();
+		giterr_set_oom();
 		return -1;
 
 	case BUFERR_ZLIB:
-		git_error_set(GIT_ERROR_ZLIB,
+		giterr_set(GITERR_ZLIB,
 			"Buffer error when writing out ZLib data");
 		return -1;
 
@@ -44,14 +44,18 @@ static int verify_last_error(git_filebuf *file)
 static int lock_file(git_filebuf *file, int flags, mode_t mode)
 {
 	if (git_path_exists(file->path_lock) == true) {
-		git_error_clear(); /* actual OS error code just confuses */
-		git_error_set(GIT_ERROR_OS,
-			"failed to lock file '%s' for writing", file->path_lock);
-		return GIT_ELOCKED;
+		if (flags & GIT_FILEBUF_FORCE)
+			p_unlink(file->path_lock);
+		else {
+			giterr_clear(); /* actual OS error code just confuses */
+			giterr_set(GITERR_OS,
+				"failed to lock file '%s' for writing", file->path_lock);
+			return GIT_ELOCKED;
+		}
 	}
 
 	/* create path to the file buffer is required */
-	if (flags & GIT_FILEBUF_CREATE_LEADING_DIRS) {
+	if (flags & GIT_FILEBUF_FORCE) {
 		/* XXX: Should dirmode here be configurable? Or is 0777 always fine? */
 		file->fd = git_futils_creat_locked_withpath(file->path_lock, 0777, mode);
 	} else {
@@ -71,7 +75,7 @@ static int lock_file(git_filebuf *file, int flags, mode_t mode)
 
 		source = p_open(file->path_original, O_RDONLY);
 		if (source < 0) {
-			git_error_set(GIT_ERROR_OS,
+			giterr_set(GITERR_OS,
 				"failed to open file '%s' for reading",
 				file->path_original);
 			return -1;
@@ -87,10 +91,10 @@ static int lock_file(git_filebuf *file, int flags, mode_t mode)
 		p_close(source);
 
 		if (read_bytes < 0) {
-			git_error_set(GIT_ERROR_OS, "failed to read file '%s'", file->path_original);
+			giterr_set(GITERR_OS, "failed to read file '%s'", file->path_original);
 			return -1;
 		} else if (error < 0) {
-			git_error_set(GIT_ERROR_OS, "failed to write file '%s'", file->path_lock);
+			giterr_set(GITERR_OS, "failed to write file '%s'", file->path_lock);
 			return -1;
 		}
 	}
@@ -214,7 +218,7 @@ static int resolve_symlink(git_buf *out, const char *path)
 		}
 
 		if (error < 0) {
-			git_error_set(GIT_ERROR_OS, "failed to stat '%s'", curpath.ptr);
+			giterr_set(GITERR_OS, "failed to stat '%s'", curpath.ptr);
 			error = -1;
 			goto cleanup;
 		}
@@ -226,13 +230,13 @@ static int resolve_symlink(git_buf *out, const char *path)
 
 		ret = p_readlink(curpath.ptr, target.ptr, GIT_PATH_MAX);
 		if (ret < 0) {
-			git_error_set(GIT_ERROR_OS, "failed to read symlink '%s'", curpath.ptr);
+			giterr_set(GITERR_OS, "failed to read symlink '%s'", curpath.ptr);
 			error = -1;
 			goto cleanup;
 		}
 
 		if (ret == GIT_PATH_MAX) {
-			git_error_set(GIT_ERROR_INVALID, "symlink target too long");
+			giterr_set(GITERR_INVALID, "symlink target too long");
 			error = -1;
 			goto cleanup;
 		}
@@ -252,19 +256,19 @@ static int resolve_symlink(git_buf *out, const char *path)
 				goto cleanup;
 
 			git_buf_swap(&curpath, &dir);
-			git_buf_dispose(&dir);
+			git_buf_free(&dir);
 
 			if ((error = git_path_apply_relative(&curpath, target.ptr)) < 0)
 				goto cleanup;
 		}
 	}
 
-	git_error_set(GIT_ERROR_INVALID, "maximum symlink depth reached");
+	giterr_set(GITERR_INVALID, "maximum symlink depth reached");
 	error = -1;
 
 cleanup:
-	git_buf_dispose(&curpath);
-	git_buf_dispose(&target);
+	git_buf_free(&curpath);
+	git_buf_free(&target);
 	return error;
 }
 
@@ -299,7 +303,7 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 	/* Allocate the main cache buffer */
 	if (!file->do_not_buffer) {
 		file->buffer = git__malloc(file->buf_size);
-		GIT_ERROR_CHECK_ALLOC(file->buffer);
+		GITERR_CHECK_ALLOC(file->buffer);
 	}
 
 	/* If we are hashing on-write, allocate a new hash context */
@@ -316,13 +320,13 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 	if (compression != 0) {
 		/* Initialize the ZLib stream */
 		if (deflateInit(&file->zs, compression) != Z_OK) {
-			git_error_set(GIT_ERROR_ZLIB, "failed to initialize zlib");
+			giterr_set(GITERR_ZLIB, "failed to initialize zlib");
 			goto cleanup;
 		}
 
 		/* Allocate the Zlib cache buffer */
 		file->z_buf = git__malloc(file->buf_size);
-		GIT_ERROR_CHECK_ALLOC(file->z_buf);
+		GITERR_CHECK_ALLOC(file->z_buf);
 
 		/* Never flush */
 		file->flush_mode = Z_NO_FLUSH;
@@ -339,7 +343,7 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 		file->fd = git_futils_mktmp(&tmp_path, path, mode);
 
 		if (file->fd < 0) {
-			git_buf_dispose(&tmp_path);
+			git_buf_free(&tmp_path);
 			goto cleanup;
 		}
 		file->fd_is_open = true;
@@ -348,7 +352,7 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 		/* No original path */
 		file->path_original = NULL;
 		file->path_lock = git_buf_detach(&tmp_path);
-		GIT_ERROR_CHECK_ALLOC(file->path_lock);
+		GITERR_CHECK_ALLOC(file->path_lock);
 	} else {
 		git_buf resolved_path = GIT_BUF_INIT;
 
@@ -360,15 +364,15 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 		file->path_original = git_buf_detach(&resolved_path);
 
 		/* create the locking path by appending ".lock" to the original */
-		GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, path_len, GIT_FILELOCK_EXTLENGTH);
+		GITERR_CHECK_ALLOC_ADD(&alloc_len, path_len, GIT_FILELOCK_EXTLENGTH);
 		file->path_lock = git__malloc(alloc_len);
-		GIT_ERROR_CHECK_ALLOC(file->path_lock);
+		GITERR_CHECK_ALLOC(file->path_lock);
 
 		memcpy(file->path_lock, file->path_original, path_len);
 		memcpy(file->path_lock + path_len, GIT_FILELOCK_EXTENSION, GIT_FILELOCK_EXTLENGTH);
 
 		if (git_path_isdir(file->path_original)) {
-			git_error_set(GIT_ERROR_FILESYSTEM, "path '%s' is a directory", file->path_original);
+			giterr_set(GITERR_FILESYSTEM, "path '%s' is a directory", file->path_original);
 			error = GIT_EDIRECTORY;
 			goto cleanup;
 		}
@@ -407,7 +411,7 @@ int git_filebuf_commit_at(git_filebuf *file, const char *path)
 {
 	git__free(file->path_original);
 	file->path_original = git__strdup(path);
-	GIT_ERROR_CHECK_ALLOC(file->path_original);
+	GITERR_CHECK_ALLOC(file->path_original);
 
 	return git_filebuf_commit(file);
 }
@@ -426,19 +430,19 @@ int git_filebuf_commit(git_filebuf *file)
 	file->fd_is_open = false;
 
 	if (file->do_fsync && p_fsync(file->fd) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to fsync '%s'", file->path_lock);
+		giterr_set(GITERR_OS, "failed to fsync '%s'", file->path_lock);
 		goto on_error;
 	}
 
 	if (p_close(file->fd) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to close file at '%s'", file->path_lock);
+		giterr_set(GITERR_OS, "failed to close file at '%s'", file->path_lock);
 		goto on_error;
 	}
 
 	file->fd = -1;
 
 	if (p_rename(file->path_lock, file->path_original) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to rename lockfile to '%s'", file->path_original);
+		giterr_set(GITERR_OS, "failed to rename lockfile to '%s'", file->path_original);
 		goto on_error;
 	}
 
@@ -579,7 +583,7 @@ int git_filebuf_stats(time_t *mtime, size_t *size, git_filebuf *file)
 		res = p_stat(file->path_original, &st);
 
 	if (res < 0) {
-		git_error_set(GIT_ERROR_OS, "could not get stat info for '%s'",
+		giterr_set(GITERR_OS, "could not get stat info for '%s'",
 			file->path_original);
 		return res;
 	}