rugged 0.27.7 → 0.27.10

data/vendor/libgit2/src/fetch.c

@@ -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) {
-		giterr_set(GITERR_NET, "failed to filter the reference list for wants");
+		git_error_set(GIT_ERROR_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_transfer_progress_cb progress = NULL;
+	git_indexer_progress_cb progress = NULL;
 	void *payload = NULL;
 
 	if (!remote->need_pack)
@@ -148,9 +148,14 @@ 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_init_options(git_fetch_options *opts, unsigned int version)
+int git_fetch_options_init(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 "fileops.h"
+#include "futils.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));
-	GITERR_CHECK_ALLOC(fetchhead_ref);
+	GIT_ERROR_CHECK_ALLOC(fetchhead_ref);
 
 	memset(fetchhead_ref, 0x0, sizeof(git_fetchhead_ref));
 
@@ -148,7 +148,7 @@ static int fetchhead_ref_parse(
 	*remote_url = NULL;
 
 	if (!*line) {
-		giterr_set(GITERR_FETCHHEAD,
+		git_error_set(GIT_ERROR_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) {
-		giterr_set(GITERR_FETCHHEAD,
+		git_error_set(GIT_ERROR_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 = giterr_last();
+		const git_error *oid_err = git_error_last();
 		const char *err_msg = oid_err ? oid_err->message : "invalid object ID";
 
-		giterr_set(GITERR_FETCHHEAD, "%s in FETCH_HEAD line %"PRIuZ,
+		git_error_set(GIT_ERROR_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) {
-			giterr_set(GITERR_FETCHHEAD,
+			git_error_set(GIT_ERROR_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 {
-			giterr_set(GITERR_FETCHHEAD,
+			git_error_set(GIT_ERROR_FETCHHEAD,
 				"invalid for-merge entry in FETCH_HEAD line %"PRIuZ, line_num);
 			return -1;
 		}
 
 		if ((desc = line) == NULL) {
-			giterr_set(GITERR_FETCHHEAD,
+			git_error_set(GIT_ERROR_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) {
-				giterr_set(GITERR_FETCHHEAD,
+				git_error_set(GIT_ERROR_FETCHHEAD,
 					"invalid description in FETCH_HEAD line %"PRIuZ, line_num);
 				return -1;
 			}
@@ -271,13 +271,13 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 
 		error = cb(ref_name, remote_url, &oid, is_merge, payload);
 		if (error) {
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 			goto done;
 		}
 	}
 
 	if (*buffer) {
-		giterr_set(GITERR_FETCHHEAD, "no EOL at line %"PRIuZ, line_num+1);
+		git_error_set(GIT_ERROR_FETCHHEAD, "no EOL at line %"PRIuZ, line_num+1);
 		error = -1;
 		goto done;
 	}

data/vendor/libgit2/src/filebuf.c

@@ -7,7 +7,7 @@
 
 #include "filebuf.h"
 
-#include "fileops.h"
+#include "futils.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:
-		giterr_set(GITERR_OS, "failed to write out file");
+		git_error_set(GIT_ERROR_OS, "failed to write out file");
 		return -1;
 
 	case BUFERR_MEM:
-		giterr_set_oom();
+		git_error_set_oom();
 		return -1;
 
 	case BUFERR_ZLIB:
-		giterr_set(GITERR_ZLIB,
+		git_error_set(GIT_ERROR_ZLIB,
 			"Buffer error when writing out ZLib data");
 		return -1;
 
@@ -44,18 +44,14 @@ 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) {
-		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;
-		}
+		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;
 	}
 
 	/* create path to the file buffer is required */
-	if (flags & GIT_FILEBUF_FORCE) {
+	if (flags & GIT_FILEBUF_CREATE_LEADING_DIRS) {
 		/* XXX: Should dirmode here be configurable? Or is 0777 always fine? */
 		file->fd = git_futils_creat_locked_withpath(file->path_lock, 0777, mode);
 	} else {
@@ -75,7 +71,7 @@ static int lock_file(git_filebuf *file, int flags, mode_t mode)
 
 		source = p_open(file->path_original, O_RDONLY);
 		if (source < 0) {
-			giterr_set(GITERR_OS,
+			git_error_set(GIT_ERROR_OS,
 				"failed to open file '%s' for reading",
 				file->path_original);
 			return -1;
@@ -91,10 +87,10 @@ static int lock_file(git_filebuf *file, int flags, mode_t mode)
 		p_close(source);
 
 		if (read_bytes < 0) {
-			giterr_set(GITERR_OS, "failed to read file '%s'", file->path_original);
+			git_error_set(GIT_ERROR_OS, "failed to read file '%s'", file->path_original);
 			return -1;
 		} else if (error < 0) {
-			giterr_set(GITERR_OS, "failed to write file '%s'", file->path_lock);
+			git_error_set(GIT_ERROR_OS, "failed to write file '%s'", file->path_lock);
 			return -1;
 		}
 	}
@@ -218,7 +214,7 @@ static int resolve_symlink(git_buf *out, const char *path)
 		}
 
 		if (error < 0) {
-			giterr_set(GITERR_OS, "failed to stat '%s'", curpath.ptr);
+			git_error_set(GIT_ERROR_OS, "failed to stat '%s'", curpath.ptr);
 			error = -1;
 			goto cleanup;
 		}
@@ -230,13 +226,13 @@ static int resolve_symlink(git_buf *out, const char *path)
 
 		ret = p_readlink(curpath.ptr, target.ptr, GIT_PATH_MAX);
 		if (ret < 0) {
-			giterr_set(GITERR_OS, "failed to read symlink '%s'", curpath.ptr);
+			git_error_set(GIT_ERROR_OS, "failed to read symlink '%s'", curpath.ptr);
 			error = -1;
 			goto cleanup;
 		}
 
 		if (ret == GIT_PATH_MAX) {
-			giterr_set(GITERR_INVALID, "symlink target too long");
+			git_error_set(GIT_ERROR_INVALID, "symlink target too long");
 			error = -1;
 			goto cleanup;
 		}
@@ -263,7 +259,7 @@ static int resolve_symlink(git_buf *out, const char *path)
 		}
 	}
 
-	giterr_set(GITERR_INVALID, "maximum symlink depth reached");
+	git_error_set(GIT_ERROR_INVALID, "maximum symlink depth reached");
 	error = -1;
 
 cleanup:
@@ -303,7 +299,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);
-		GITERR_CHECK_ALLOC(file->buffer);
+		GIT_ERROR_CHECK_ALLOC(file->buffer);
 	}
 
 	/* If we are hashing on-write, allocate a new hash context */
@@ -320,13 +316,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) {
-			giterr_set(GITERR_ZLIB, "failed to initialize zlib");
+			git_error_set(GIT_ERROR_ZLIB, "failed to initialize zlib");
 			goto cleanup;
 		}
 
 		/* Allocate the Zlib cache buffer */
 		file->z_buf = git__malloc(file->buf_size);
-		GITERR_CHECK_ALLOC(file->z_buf);
+		GIT_ERROR_CHECK_ALLOC(file->z_buf);
 
 		/* Never flush */
 		file->flush_mode = Z_NO_FLUSH;
@@ -352,7 +348,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);
-		GITERR_CHECK_ALLOC(file->path_lock);
+		GIT_ERROR_CHECK_ALLOC(file->path_lock);
 	} else {
 		git_buf resolved_path = GIT_BUF_INIT;
 
@@ -364,15 +360,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 */
-		GITERR_CHECK_ALLOC_ADD(&alloc_len, path_len, GIT_FILELOCK_EXTLENGTH);
+		GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, path_len, GIT_FILELOCK_EXTLENGTH);
 		file->path_lock = git__malloc(alloc_len);
-		GITERR_CHECK_ALLOC(file->path_lock);
+		GIT_ERROR_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)) {
-			giterr_set(GITERR_FILESYSTEM, "path '%s' is a directory", file->path_original);
+			git_error_set(GIT_ERROR_FILESYSTEM, "path '%s' is a directory", file->path_original);
 			error = GIT_EDIRECTORY;
 			goto cleanup;
 		}
@@ -411,7 +407,7 @@ int git_filebuf_commit_at(git_filebuf *file, const char *path)
 {
 	git__free(file->path_original);
 	file->path_original = git__strdup(path);
-	GITERR_CHECK_ALLOC(file->path_original);
+	GIT_ERROR_CHECK_ALLOC(file->path_original);
 
 	return git_filebuf_commit(file);
 }
@@ -430,19 +426,19 @@ int git_filebuf_commit(git_filebuf *file)
 	file->fd_is_open = false;
 
 	if (file->do_fsync && p_fsync(file->fd) < 0) {
-		giterr_set(GITERR_OS, "failed to fsync '%s'", file->path_lock);
+		git_error_set(GIT_ERROR_OS, "failed to fsync '%s'", file->path_lock);
 		goto on_error;
 	}
 
 	if (p_close(file->fd) < 0) {
-		giterr_set(GITERR_OS, "failed to close file at '%s'", file->path_lock);
+		git_error_set(GIT_ERROR_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) {
-		giterr_set(GITERR_OS, "failed to rename lockfile to '%s'", file->path_original);
+		git_error_set(GIT_ERROR_OS, "failed to rename lockfile to '%s'", file->path_original);
 		goto on_error;
 	}
 
@@ -583,7 +579,7 @@ int git_filebuf_stats(time_t *mtime, size_t *size, git_filebuf *file)
 		res = p_stat(file->path_original, &st);
 
 	if (res < 0) {
-		giterr_set(GITERR_OS, "could not get stat info for '%s'",
+		git_error_set(GIT_ERROR_OS, "could not get stat info for '%s'",
 			file->path_original);
 		return res;
 	}

data/vendor/libgit2/src/filebuf.h

@@ -9,7 +9,7 @@
 
 #include "common.h"
 
-#include "fileops.h"
+#include "futils.h"
 #include "hash.h"
 #include <zlib.h>
 
@@ -19,7 +19,7 @@
 
 #define GIT_FILEBUF_HASH_CONTENTS		(1 << 0)
 #define GIT_FILEBUF_APPEND				(1 << 2)
-#define GIT_FILEBUF_FORCE				(1 << 3)
+#define GIT_FILEBUF_CREATE_LEADING_DIRS	(1 << 3)
 #define GIT_FILEBUF_TEMPORARY			(1 << 4)
 #define GIT_FILEBUF_DO_NOT_BUFFER		(1 << 5)
 #define GIT_FILEBUF_FSYNC				(1 << 6)

data/vendor/libgit2/src/filter.c

@@ -8,7 +8,7 @@
 #include "filter.h"
 
 #include "common.h"
-#include "fileops.h"
+#include "futils.h"
 #include "hash.h"
 #include "repository.h"
 #include "global.h"
@@ -157,15 +157,15 @@ static int filter_registry_insert(
 	if (filter_def_scan_attrs(&attrs, &nattr, &nmatch, filter->attributes) < 0)
 		return -1;
 
-	GITERR_CHECK_ALLOC_MULTIPLY(&alloc_len, nattr, 2);
-	GITERR_CHECK_ALLOC_MULTIPLY(&alloc_len, alloc_len, sizeof(char *));
-	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, sizeof(git_filter_def));
+	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&alloc_len, nattr, 2);
+	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&alloc_len, alloc_len, sizeof(char *));
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, sizeof(git_filter_def));
 
 	fdef = git__calloc(1, alloc_len);
-	GITERR_CHECK_ALLOC(fdef);
+	GIT_ERROR_CHECK_ALLOC(fdef);
 
 	fdef->filter_name = git__strdup(name);
-	GITERR_CHECK_ALLOC(fdef->filter_name);
+	GIT_ERROR_CHECK_ALLOC(fdef->filter_name);
 
 	fdef->filter      = filter;
 	fdef->priority    = priority;
@@ -269,13 +269,13 @@ int git_filter_register(
 	assert(name && filter);
 
 	if (git_rwlock_wrlock(&filter_registry.lock) < 0) {
-		giterr_set(GITERR_OS, "failed to lock filter registry");
+		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
 		return -1;
 	}
 
 	if (!filter_registry_find(NULL, name)) {
-		giterr_set(
-			GITERR_FILTER, "attempt to reregister existing filter '%s'", name);
+		git_error_set(
+			GIT_ERROR_FILTER, "attempt to reregister existing filter '%s'", name);
 		error = GIT_EEXISTS;
 		goto done;
 	}
@@ -297,17 +297,17 @@ int git_filter_unregister(const char *name)
 
 	/* cannot unregister default filters */
 	if (!strcmp(GIT_FILTER_CRLF, name) || !strcmp(GIT_FILTER_IDENT, name)) {
-		giterr_set(GITERR_FILTER, "cannot unregister filter '%s'", name);
+		git_error_set(GIT_ERROR_FILTER, "cannot unregister filter '%s'", name);
 		return -1;
 	}
 
 	if (git_rwlock_wrlock(&filter_registry.lock) < 0) {
-		giterr_set(GITERR_OS, "failed to lock filter registry");
+		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
 		return -1;
 	}
 
 	if ((fdef = filter_registry_lookup(&pos, name)) == NULL) {
-		giterr_set(GITERR_FILTER, "cannot find filter '%s' to unregister", name);
+		git_error_set(GIT_ERROR_FILTER, "cannot find filter '%s' to unregister", name);
 		error = GIT_ENOTFOUND;
 		goto done;
 	}
@@ -348,7 +348,7 @@ git_filter *git_filter_lookup(const char *name)
 	git_filter *filter = NULL;
 
 	if (git_rwlock_rdlock(&filter_registry.lock) < 0) {
-		giterr_set(GITERR_OS, "failed to lock filter registry");
+		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
 		return NULL;
 	}
 
@@ -385,7 +385,7 @@ uint16_t git_filter_source_filemode(const git_filter_source *src)
 
 const git_oid *git_filter_source_id(const git_filter_source *src)
 {
-	return git_oid_iszero(&src->oid) ? NULL : &src->oid;
+	return git_oid_is_zero(&src->oid) ? NULL : &src->oid;
 }
 
 git_filter_mode_t git_filter_source_mode(const git_filter_source *src)
@@ -404,11 +404,11 @@ static int filter_list_new(
 	git_filter_list *fl = NULL;
 	size_t pathlen = src->path ? strlen(src->path) : 0, alloclen;
 
-	GITERR_CHECK_ALLOC_ADD(&alloclen, sizeof(git_filter_list), pathlen);
-	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, sizeof(git_filter_list), pathlen);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
 
 	fl = git__calloc(1, alloclen);
-	GITERR_CHECK_ALLOC(fl);
+	GIT_ERROR_CHECK_ALLOC(fl);
 
 	if (src->path)
 		memcpy(fl->path, src->path, pathlen);
@@ -428,24 +428,32 @@ static int filter_list_check_attributes(
 	git_filter_def *fdef,
 	const git_filter_source *src)
 {
-	int error;
-	size_t i;
 	const char **strs = git__calloc(fdef->nattrs, sizeof(const char *));
-	GITERR_CHECK_ALLOC(strs);
+	uint32_t flags = 0;
+	size_t i;
+	int error;
+
+	GIT_ERROR_CHECK_ALLOC(strs);
+
+	if ((src->flags & GIT_FILTER_NO_SYSTEM_ATTRIBUTES) != 0)
+		flags |= GIT_ATTR_CHECK_NO_SYSTEM;
+
+	if ((src->flags & GIT_FILTER_ATTRIBUTES_FROM_HEAD) != 0)
+		flags |= GIT_ATTR_CHECK_INCLUDE_HEAD;
 
 	error = git_attr_get_many_with_session(
-		strs, repo, attr_session, 0, src->path, fdef->nattrs, fdef->attrs);
+		strs, repo, attr_session, flags, src->path, fdef->nattrs, fdef->attrs);
 
 	/* if no values were found but no matches are needed, it's okay! */
 	if (error == GIT_ENOTFOUND && !fdef->nmatches) {
-		giterr_clear();
+		git_error_clear();
 		git__free((void *)strs);
 		return 0;
 	}
 
 	for (i = 0; !error && i < fdef->nattrs; ++i) {
 		const char *want = fdef->attrs[fdef->nattrs + i];
-		git_attr_t want_type, found_type;
+		git_attr_value_t want_type, found_type;
 
 		if (!want)
 			continue;
@@ -455,7 +463,7 @@ static int filter_list_check_attributes(
 
 		if (want_type != found_type)
 			error = GIT_ENOTFOUND;
-		else if (want_type == GIT_ATTR_VALUE_T &&
+		else if (want_type == GIT_ATTR_VALUE_STRING &&
 				strcmp(want, strs[i]) &&
 				strcmp(want, "*"))
 			error = GIT_ENOTFOUND;
@@ -499,7 +507,7 @@ int git_filter_list__load_ext(
 	git_filter_def *fdef;
 
 	if (git_rwlock_rdlock(&filter_registry.lock) < 0) {
-		giterr_set(GITERR_OS, "failed to lock filter registry");
+		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
 		return -1;
 	}
 
@@ -551,7 +559,7 @@ int git_filter_list__load_ext(
 			}
 
 			fe = git_array_alloc(fl->filters);
-			GITERR_CHECK_ALLOC(fe);
+			GIT_ERROR_CHECK_ALLOC(fe);
 
 			fe->filter = fdef->filter;
 			fe->filter_name = fdef->filter_name;
@@ -634,7 +642,7 @@ int git_filter_list_push(
 	assert(fl && filter);
 
 	if (git_rwlock_rdlock(&filter_registry.lock) < 0) {
-		giterr_set(GITERR_OS, "failed to lock filter registry");
+		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
 		return -1;
 	}
 
@@ -646,7 +654,7 @@ int git_filter_list_push(
 	git_rwlock_rdunlock(&filter_registry.lock);
 
 	if (fdef == NULL) {
-		giterr_set(GITERR_FILTER, "cannot use an unregistered filter");
+		git_error_set(GIT_ERROR_FILTER, "cannot use an unregistered filter");
 		return -1;
 	}
 
@@ -654,7 +662,7 @@ int git_filter_list_push(
 		return error;
 
 	fe = git_array_alloc(fl->filters);
-	GITERR_CHECK_ALLOC(fe);
+	GIT_ERROR_CHECK_ALLOC(fe);
 	fe->filter  = filter;
 	fe->payload = payload;
 
@@ -756,10 +764,10 @@ int git_filter_list_apply_to_file(
 
 static int buf_from_blob(git_buf *out, git_blob *blob)
 {
-	git_off_t rawsize = git_blob_rawsize(blob);
+	git_object_size_t rawsize = git_blob_rawsize(blob);
 
 	if (!git__is_sizet(rawsize)) {
-		giterr_set(GITERR_OS, "blob is too large to filter");
+		git_error_set(GIT_ERROR_OS, "blob is too large to filter");
 		return -1;
 	}
 
@@ -809,6 +817,7 @@ static int proxy_stream_close(git_writestream *s)
 {
 	struct proxy_stream *proxy_stream = (struct proxy_stream *)s;
 	git_buf *writebuf;
+	git_error_state error_state = {0};
 	int error;
 
 	assert(proxy_stream);
@@ -826,6 +835,11 @@ static int proxy_stream_close(git_writestream *s)
 		git_buf_sanitize(proxy_stream->output);
 		writebuf = proxy_stream->output;
 	} else {
+		/* close stream before erroring out taking care
+		 * to preserve the original error */
+		git_error_state_capture(&error_state, error);
+		proxy_stream->target->close(proxy_stream->target);
+		git_error_state_restore(&error_state);
 		return error;
 	}
 
@@ -855,7 +869,7 @@ static int proxy_stream_init(
 	git_writestream *target)
 {
 	struct proxy_stream *proxy_stream = git__calloc(1, sizeof(struct proxy_stream));
-	GITERR_CHECK_ALLOC(proxy_stream);
+	GIT_ERROR_CHECK_ALLOC(proxy_stream);
 
 	proxy_stream->parent.write = proxy_stream_write;
 	proxy_stream->parent.close = proxy_stream_close;
@@ -968,7 +982,7 @@ int git_filter_list_stream_file(
 	}
 
 	if (readlen < 0)
-		error = readlen;
+		error = -1;
 
 done:
 	if (initialized)

data/vendor/libgit2/src/filter.h

@@ -15,16 +15,6 @@
 /* Amount of file to examine for NUL byte when checking binary-ness */
 #define GIT_FILTER_BYTES_TO_CHECK_NUL 8000
 
-/* Possible CRLF values */
-typedef enum {
-	GIT_CRLF_GUESS = -1,
-	GIT_CRLF_BINARY = 0,
-	GIT_CRLF_TEXT,
-	GIT_CRLF_INPUT,
-	GIT_CRLF_CRLF,
-	GIT_CRLF_AUTO,
-} git_crlf_t;
-
 typedef struct {
 	git_attr_session *attr_session;
 	git_buf *temp_buf;