rugged 0.22.2 → 0.23.0b1

data/vendor/libgit2/src/diff_file.c

@@ -302,7 +302,7 @@ static int diff_file_content_load_workdir_file(
 
 	if ((error = git_filter_list_load(
 			&fl, fc->repo, NULL, fc->file->path,
-			GIT_FILTER_TO_ODB, GIT_FILTER_OPT_ALLOW_UNSAFE)) < 0)
+			GIT_FILTER_TO_ODB, GIT_FILTER_ALLOW_UNSAFE)) < 0)
 		goto cleanup;
 
 	/* if there are no filters, try to mmap the file */

data/vendor/libgit2/src/diff_patch.c

@@ -284,11 +284,12 @@ int git_diff_foreach(
 		if (git_diff_delta__should_skip(&diff->opts, patch.delta))
 			continue;
 
-		if ((error = diff_patch_init_from_diff(&patch, diff, idx)) < 0)
-			break;
-
-		if (!(error = diff_patch_invoke_file_callback(&patch, &xo.output)))
-			error = diff_patch_generate(&patch, &xo.output);
+		if ((error = diff_patch_invoke_file_callback(&patch, &xo.output)) == 0) {
+			if (hunk_cb || data_cb) {
+				if ((error = diff_patch_init_from_diff(&patch, diff, idx)) == 0)
+					error = diff_patch_generate(&patch, &xo.output);
+			}
+		}
 
 		git_patch_free(&patch);
 
@@ -387,8 +388,13 @@ static int diff_patch_with_delta_alloc(
 	diff_patch_with_delta *pd;
 	size_t old_len = *old_path ? strlen(*old_path) : 0;
 	size_t new_len = *new_path ? strlen(*new_path) : 0;
+	size_t alloc_len;
+
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, sizeof(*pd), old_len);
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, new_len);
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 2);
 
-	*out = pd = git__calloc(1, sizeof(*pd) + old_len + new_len + 2);
+	*out = pd = git__calloc(1, alloc_len);
 	GITERR_CHECK_ALLOC(pd);
 
 	pd->patch.flags = GIT_DIFF_PATCH_ALLOCATED;

data/vendor/libgit2/src/diff_tform.c

@@ -219,34 +219,18 @@ int git_diff_find_similar__hashsig_for_file(
 	void **out, const git_diff_file *f, const char *path, void *p)
 {
 	git_hashsig_option_t opt = (git_hashsig_option_t)(intptr_t)p;
-	int error = 0;
 
 	GIT_UNUSED(f);
-	error = git_hashsig_create_fromfile((git_hashsig **)out, path, opt);
-
-	if (error == GIT_EBUFS) {
-		error = 0;
-		giterr_clear();
-	}
-
-	return error;
+	return git_hashsig_create_fromfile((git_hashsig **)out, path, opt);
 }
 
 int git_diff_find_similar__hashsig_for_buf(
 	void **out, const git_diff_file *f, const char *buf, size_t len, void *p)
 {
 	git_hashsig_option_t opt = (git_hashsig_option_t)(intptr_t)p;
-	int error = 0;
 
 	GIT_UNUSED(f);
-	error = git_hashsig_create((git_hashsig **)out, buf, len, opt);
-
-	if (error == GIT_EBUFS) {
-		error = 0;
-		giterr_clear();
-	}
-
-	return error;
+	return git_hashsig_create((git_hashsig **)out, buf, len, opt);
 }
 
 void git_diff_find_similar__hashsig_free(void *sig, void *payload)
@@ -258,8 +242,14 @@ void git_diff_find_similar__hashsig_free(void *sig, void *payload)
 int git_diff_find_similar__calc_similarity(
 	int *score, void *siga, void *sigb, void *payload)
 {
+	int error;
+
 	GIT_UNUSED(payload);
-	*score = git_hashsig_compare(siga, sigb);
+	error = git_hashsig_compare(siga, sigb);
+	if (error < 0)
+		return error;
+
+	*score = error;
 	return 0;
 }
 
@@ -273,6 +263,7 @@ static int normalize_find_opts(
 	const git_diff_find_options *given)
 {
 	git_config *cfg = NULL;
+	git_hashsig_option_t hashsig_opts;
 
 	GITERR_CHECK_VERSION(given, GIT_DIFF_FIND_OPTIONS_VERSION, "git_diff_find_options");
 
@@ -286,7 +277,7 @@ static int normalize_find_opts(
 	if (!given ||
 		 (given->flags & GIT_DIFF_FIND_ALL) == GIT_DIFF_FIND_BY_CONFIG)
 	{
-		const char *rule =
+		char *rule =
 			git_config__get_string_force(cfg, "diff.renames", "true");
 		int boolval;
 
@@ -296,6 +287,8 @@ static int normalize_find_opts(
 			opts->flags |= GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES;
 		else
 			opts->flags |= GIT_DIFF_FIND_RENAMES;
+
+		git__free(rule);
 	}
 
 	/* some flags imply others */
@@ -354,11 +347,13 @@ static int normalize_find_opts(
 		opts->metric->similarity = git_diff_find_similar__calc_similarity;
 
 		if (opts->flags & GIT_DIFF_FIND_IGNORE_WHITESPACE)
-			opts->metric->payload = (void *)GIT_HASHSIG_IGNORE_WHITESPACE;
+			hashsig_opts = GIT_HASHSIG_IGNORE_WHITESPACE;
 		else if (opts->flags & GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE)
-			opts->metric->payload = (void *)GIT_HASHSIG_NORMAL;
+			hashsig_opts = GIT_HASHSIG_NORMAL;
 		else
-			opts->metric->payload = (void *)GIT_HASHSIG_SMART_WHITESPACE;
+			hashsig_opts = GIT_HASHSIG_SMART_WHITESPACE;
+		hashsig_opts |= GIT_HASHSIG_ALLOW_SMALL_FILES;
+		opts->metric->payload = (void *)hashsig_opts;
 	}
 
 	return 0;
@@ -818,6 +813,7 @@ int git_diff_find_similar(
 	size_t num_deltas, num_srcs = 0, num_tgts = 0;
 	size_t tried_srcs = 0, tried_tgts = 0;
 	size_t num_rewrites = 0, num_updates = 0, num_bumped = 0;
+	size_t sigcache_size;
 	void **sigcache = NULL; /* cache of similarity metric file signatures */
 	diff_find_match *tgt2src = NULL;
 	diff_find_match *src2tgt = NULL;
@@ -838,7 +834,8 @@ int git_diff_find_similar(
 	if ((opts.flags & GIT_DIFF_FIND_ALL) == 0)
 		goto cleanup;
 
-	sigcache = git__calloc(num_deltas * 2, sizeof(void *));
+	GITERR_CHECK_ALLOC_MULTIPLY(&sigcache_size, num_deltas, 2);
+	sigcache = git__calloc(sigcache_size, sizeof(void *));
 	GITERR_CHECK_ALLOC(sigcache);
 
 	/* Label rename sources and targets

data/vendor/libgit2/src/filebuf.c

@@ -194,7 +194,7 @@ static int write_deflate(git_filebuf *file, void *source, size_t len)
 int git_filebuf_open(git_filebuf *file, const char *path, int flags, mode_t mode)
 {
 	int compression, error = -1;
-	size_t path_len;
+	size_t path_len, alloc_len;
 
 	/* opening an already open buffer is a programming error;
 	 * assert that this never happens instead of returning
@@ -271,7 +271,8 @@ int git_filebuf_open(git_filebuf *file, const char *path, int flags, mode_t mode
 		GITERR_CHECK_ALLOC(file->path_original);
 
 		/* create the locking path by appending ".lock" to the original */
-		file->path_lock = git__malloc(path_len + GIT_FILELOCK_EXTLENGTH);
+		GITERR_CHECK_ALLOC_ADD(&alloc_len, path_len, GIT_FILELOCK_EXTLENGTH);
+		file->path_lock = git__malloc(alloc_len);
 		GITERR_CHECK_ALLOC(file->path_lock);
 
 		memcpy(file->path_lock, file->path_original, path_len);
@@ -407,8 +408,8 @@ int git_filebuf_reserve(git_filebuf *file, void **buffer, size_t len)
 int git_filebuf_printf(git_filebuf *file, const char *format, ...)
 {
 	va_list arglist;
-	size_t space_left;
-	int len, res;
+	size_t space_left, len, alloclen;
+	int written, res;
 	char *tmp_buffer;
 
 	ENSURE_BUF_OK(file);
@@ -417,15 +418,16 @@ int git_filebuf_printf(git_filebuf *file, const char *format, ...)
 
 	do {
 		va_start(arglist, format);
-		len = p_vsnprintf((char *)file->buffer + file->buf_pos, space_left, format, arglist);
+		written = p_vsnprintf((char *)file->buffer + file->buf_pos, space_left, format, arglist);
 		va_end(arglist);
 
-		if (len < 0) {
+		if (written < 0) {
 			file->last_error = BUFERR_MEM;
 			return -1;
 		}
 
-		if ((size_t)len + 1 <= space_left) {
+		len = written;
+		if (len + 1 <= space_left) {
 			file->buf_pos += len;
 			return 0;
 		}
@@ -435,19 +437,19 @@ int git_filebuf_printf(git_filebuf *file, const char *format, ...)
 
 		space_left = file->buf_size - file->buf_pos;
 
-	} while ((size_t)len + 1 <= space_left);
+	} while (len + 1 <= space_left);
 
-	tmp_buffer = git__malloc(len + 1);
-	if (!tmp_buffer) {
+	if (GIT_ADD_SIZET_OVERFLOW(&alloclen, len, 1) ||
+		!(tmp_buffer = git__malloc(alloclen))) {
 		file->last_error = BUFERR_MEM;
 		return -1;
 	}
 
 	va_start(arglist, format);
-	len = p_vsnprintf(tmp_buffer, len + 1, format, arglist);
+	written = p_vsnprintf(tmp_buffer, len + 1, format, arglist);
 	va_end(arglist);
 
-	if (len < 0) {
+	if (written < 0) {
 		git__free(tmp_buffer);
 		file->last_error = BUFERR_MEM;
 		return -1;

data/vendor/libgit2/src/fileops.c

@@ -7,11 +7,14 @@
 #include "common.h"
 #include "fileops.h"
 #include "global.h"
+#include "strmap.h"
 #include <ctype.h>
 #if GIT_WIN32
 #include "win32/findfile.h"
 #endif
 
+GIT__USE_STRMAP
+
 int git_futils_mkpath2file(const char *file_path, const mode_t mode)
 {
 	return git_futils_mkdir(
@@ -121,10 +124,17 @@ mode_t git_futils_canonical_mode(mode_t raw_mode)
 int git_futils_readbuffer_fd(git_buf *buf, git_file fd, size_t len)
 {
 	ssize_t read_size = 0;
+	size_t alloc_len;
 
 	git_buf_clear(buf);
 
-	if (git_buf_grow(buf, len + 1) < 0)
+	if (!git__is_ssizet(len)) {
+		giterr_set(GITERR_INVALID, "Read too large.");
+		return -1;
+	}
+
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, len, 1);
+	if (git_buf_grow(buf, alloc_len) < 0)
 		return -1;
 
 	/* p_read loops internally to read len bytes */
@@ -174,7 +184,7 @@ int git_futils_readbuffer_updated(
 	 */
 	if (size && *size != (size_t)st.st_size)
 		changed = true;
-	if (mtime && *mtime != st.st_mtime)
+	if (mtime && *mtime != (time_t)st.st_mtime)
 		changed = true;
 	if (!size && !mtime)
 		changed = true;
@@ -313,7 +323,7 @@ GIT_INLINE(int) validate_existing(
 	}
 
 	else if (!S_ISDIR(st->st_mode)) {
-		giterr_set(GITERR_INVALID,
+		giterr_set(GITERR_FILESYSTEM,
 			"Failed to make directory '%s': directory exists", make_path);
 		return GIT_EEXISTS;
 	}
@@ -321,12 +331,12 @@ GIT_INLINE(int) validate_existing(
 	return 0;
 }
 
-int git_futils_mkdir_withperf(
+int git_futils_mkdir_ext(
 	const char *path,
 	const char *base,
 	mode_t mode,
 	uint32_t flags,
-	struct git_futils_mkdir_perfdata *perfdata)
+	struct git_futils_mkdir_options *opts)
 {
 	int error = -1;
 	git_buf make_path = GIT_BUF_INIT;
@@ -389,6 +399,7 @@ int git_futils_mkdir_withperf(
 
 	/* walk down tail of path making each directory */
 	for (tail = &make_path.ptr[root]; *tail; *tail = lastch) {
+		bool mkdir_attempted = false;
 
 		/* advance tail to include next path component */
 		while (*tail == '/')
@@ -401,29 +412,40 @@ int git_futils_mkdir_withperf(
 		*tail = '\0';
 		st.st_mode = 0;
 
+		if (opts->dir_map && git_strmap_exists(opts->dir_map, make_path.ptr))
+			continue;
+
 		/* See what's going on with this path component */
-		perfdata->stat_calls++;
+		opts->perfdata.stat_calls++;
 
+retry_lstat:
 		if (p_lstat(make_path.ptr, &st) < 0) {
-			perfdata->mkdir_calls++;
-
-			if (errno != ENOENT || p_mkdir(make_path.ptr, mode) < 0) {
-				giterr_set(GITERR_OS, "Failed to make directory '%s'", make_path.ptr);
-				error = GIT_EEXISTS;
+			if (mkdir_attempted || errno != ENOENT) {
+				giterr_set(GITERR_OS, "Cannot access component in path '%s'", make_path.ptr);
+				error = -1;
 				goto done;
 			}
 
 			giterr_clear();
+			opts->perfdata.mkdir_calls++;
+			mkdir_attempted = true;
+			if (p_mkdir(make_path.ptr, mode) < 0) {
+				if (errno == EEXIST)
+					goto retry_lstat;
+				giterr_set(GITERR_OS, "Failed to make directory '%s'", make_path.ptr);
+				error = -1;
+				goto done;
+			}
 		} else {
 			/* with exclusive create, existing dir is an error */
 			if ((flags & GIT_MKDIR_EXCL) != 0) {
-				giterr_set(GITERR_INVALID, "Failed to make directory '%s': directory exists", make_path.ptr);
+				giterr_set(GITERR_FILESYSTEM, "Failed to make directory '%s': directory exists", make_path.ptr);
 				error = GIT_EEXISTS;
 				goto done;
 			}
 
 			if ((error = validate_existing(
-				make_path.ptr, &st, mode, flags, perfdata)) < 0)
+				make_path.ptr, &st, mode, flags, &opts->perfdata)) < 0)
 					goto done;
 		}
 
@@ -432,7 +454,7 @@ int git_futils_mkdir_withperf(
 			 (lastch == '\0' && (flags & GIT_MKDIR_CHMOD) != 0)) &&
 			st.st_mode != mode) {
 
-			perfdata->chmod_calls++;
+			opts->perfdata.chmod_calls++;
 
 			if ((error = p_chmod(make_path.ptr, mode)) < 0 &&
 				lastch == '\0') {
@@ -441,6 +463,23 @@ int git_futils_mkdir_withperf(
 				goto done;
 			}
 		}
+
+		if (opts->dir_map && opts->pool) {
+			char *cache_path;
+			size_t alloc_size;
+
+			GITERR_CHECK_ALLOC_ADD(&alloc_size, make_path.size, 1);
+			if (!git__is_uint32(alloc_size))
+				return -1;
+			cache_path = git_pool_malloc(opts->pool, (uint32_t)alloc_size);
+			GITERR_CHECK_ALLOC(cache_path);
+
+			memcpy(cache_path, make_path.ptr, make_path.size + 1);
+
+			git_strmap_insert(opts->dir_map, cache_path, cache_path, error);
+			if (error < 0)
+				goto done;
+		}
 	}
 
 	error = 0;
@@ -448,7 +487,7 @@ int git_futils_mkdir_withperf(
 	/* check that full path really is a directory if requested & needed */
 	if ((flags & GIT_MKDIR_VERIFY_DIR) != 0 &&
 		lastch != '\0') {
-		perfdata->stat_calls++;
+		opts->perfdata.stat_calls++;
 
 		if (p_stat(make_path.ptr, &st) < 0 || !S_ISDIR(st.st_mode)) {
 			giterr_set(GITERR_OS, "Path is not a directory '%s'",
@@ -468,8 +507,8 @@ int git_futils_mkdir(
 	mode_t mode,
 	uint32_t flags)
 {
-	struct git_futils_mkdir_perfdata perfdata = {0};
-	return git_futils_mkdir_withperf(path, base, mode, flags, &perfdata);
+	struct git_futils_mkdir_options options = {0};
+	return git_futils_mkdir_ext(path, base, mode, flags, &options);
 }
 
 int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode)
@@ -691,7 +730,11 @@ static int cp_link(const char *from, const char *to, size_t link_size)
 {
 	int error = 0;
 	ssize_t read_len;
-	char *link_data = git__malloc(link_size + 1);
+	char *link_data;
+	size_t alloc_size;
+
+	GITERR_CHECK_ALLOC_ADD(&alloc_size, link_size, 1);
+	link_data = git__malloc(alloc_size);
 	GITERR_CHECK_ALLOC(link_data);
 
 	read_len = p_readlink(from, link_data, link_size);

data/vendor/libgit2/src/fileops.h

@@ -11,6 +11,8 @@
 #include "map.h"
 #include "posix.h"
 #include "path.h"
+#include "pool.h"
+#include "strmap.h"
 
 /**
  * Filebuffer methods
@@ -95,6 +97,13 @@ struct git_futils_mkdir_perfdata
 	size_t chmod_calls;
 };
 
+struct git_futils_mkdir_options
+{
+	git_strmap *dir_map;
+	git_pool *pool;
+	struct git_futils_mkdir_perfdata perfdata;
+};
+
 /**
  * Create a directory or entire path.
  *
@@ -106,10 +115,10 @@ struct git_futils_mkdir_perfdata
  * @param base Root for relative path.  These directories will never be made.
  * @param mode The mode to use for created directories.
  * @param flags Combination of the mkdir flags above.
- * @param perfdata Performance data, use `git_futils_mkdir` if you don't want this data.
+ * @param opts Extended options, use `git_futils_mkdir` if you are not interested.
  * @return 0 on success, else error code
  */
-extern int git_futils_mkdir_withperf(const char *path, const char *base, mode_t mode, uint32_t flags, struct git_futils_mkdir_perfdata *perfdata);
+extern int git_futils_mkdir_ext(const char *path, const char *base, mode_t mode, uint32_t flags, struct git_futils_mkdir_options *opts);
 
 /**
  * Create a directory or entire path.  Similar to `git_futils_mkdir_withperf`

data/vendor/libgit2/src/filter.c

@@ -23,7 +23,7 @@ struct git_filter_source {
 	git_oid         oid;  /* zero if unknown (which is likely) */
 	uint16_t        filemode; /* zero if unknown */
 	git_filter_mode_t mode;
-	uint32_t        options;
+	uint32_t        flags;
 };
 
 typedef struct {
@@ -34,6 +34,7 @@ typedef struct {
 struct git_filter_list {
 	git_array_t(git_filter_entry) filters;
 	git_filter_source source;
+	git_buf *temp_buf;
 	char path[GIT_FLEX_ARRAY];
 };
 
@@ -228,7 +229,7 @@ int git_filter_register(
 	const char *name, git_filter *filter, int priority)
 {
 	git_filter_def *fdef;
-	size_t nattr = 0, nmatch = 0;
+	size_t nattr = 0, nmatch = 0, alloc_len;
 	git_buf attrs = GIT_BUF_INIT;
 
 	assert(name && filter);
@@ -245,8 +246,11 @@ int git_filter_register(
 	if (filter_def_scan_attrs(&attrs, &nattr, &nmatch, filter->attributes) < 0)
 		return -1;
 
-	fdef = git__calloc(
-		sizeof(git_filter_def) + 2 * nattr * sizeof(char *), 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));
+
+	fdef = git__calloc(1, alloc_len);
 	GITERR_CHECK_ALLOC(fdef);
 
 	fdef->filter_name = git__strdup(name);
@@ -368,18 +372,21 @@ git_filter_mode_t git_filter_source_mode(const git_filter_source *src)
 	return src->mode;
 }
 
-uint32_t git_filter_source_options(const git_filter_source *src)
+uint32_t git_filter_source_flags(const git_filter_source *src)
 {
-	return src->options;
+	return src->flags;
 }
 
 static int filter_list_new(
 	git_filter_list **out, const git_filter_source *src)
 {
 	git_filter_list *fl = NULL;
-	size_t pathlen = src->path ? strlen(src->path) : 0;
+	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);
 
-	fl = git__calloc(1, sizeof(git_filter_list) + pathlen + 1);
+	fl = git__calloc(1, alloclen);
 	GITERR_CHECK_ALLOC(fl);
 
 	if (src->path)
@@ -387,22 +394,26 @@ static int filter_list_new(
 	fl->source.repo = src->repo;
 	fl->source.path = fl->path;
 	fl->source.mode = src->mode;
-	fl->source.options = src->options;
+	fl->source.flags = src->flags;
 
 	*out = fl;
 	return 0;
 }
 
 static int filter_list_check_attributes(
-	const char ***out, git_filter_def *fdef, const git_filter_source *src)
+	const char ***out,
+	git_repository *repo,
+	git_attr_session *attr_session,
+	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);
 
-	error = git_attr_get_many(
-		strs, src->repo, 0, src->path, fdef->nattrs, fdef->attrs);
+	error = git_attr_get_many_with_session(
+		strs, repo, attr_session, 0, 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) {
@@ -438,23 +449,23 @@ int git_filter_list_new(
 	git_filter_list **out,
 	git_repository *repo,
 	git_filter_mode_t mode,
-	uint32_t options)
+	uint32_t flags)
 {
 	git_filter_source src = { 0 };
 	src.repo = repo;
 	src.path = NULL;
 	src.mode = mode;
-	src.options = options;
+	src.flags = flags;
 	return filter_list_new(out, &src);
 }
 
-int git_filter_list_load(
+int git_filter_list__load_ext(
 	git_filter_list **filters,
 	git_repository *repo,
 	git_blob *blob, /* can be NULL */
 	const char *path,
 	git_filter_mode_t mode,
-	uint32_t options)
+	git_filter_options *filter_opts)
 {
 	int error = 0;
 	git_filter_list *fl = NULL;
@@ -469,7 +480,8 @@ int git_filter_list_load(
 	src.repo = repo;
 	src.path = path;
 	src.mode = mode;
-	src.options = options;
+	src.flags = filter_opts->flags;
+
 	if (blob)
 		git_oid_cpy(&src.oid, git_blob_id(blob));
 
@@ -481,7 +493,9 @@ int git_filter_list_load(
 			continue;
 
 		if (fdef->nattrs > 0) {
-			error = filter_list_check_attributes(&values, fdef, &src);
+			error = filter_list_check_attributes(
+				&values, repo, filter_opts->attr_session, fdef, &src);
+
 			if (error == GIT_ENOTFOUND) {
 				error = 0;
 				continue;
@@ -503,8 +517,12 @@ int git_filter_list_load(
 		else if (error < 0)
 			break;
 		else {
-			if (!fl && (error = filter_list_new(&fl, &src)) < 0)
-				return error;
+			if (!fl) {
+				if ((error = filter_list_new(&fl, &src)) < 0)
+					return error;
+
+				fl->temp_buf = filter_opts->temp_buf;
+			}
 
 			fe = git_array_alloc(fl->filters);
 			GITERR_CHECK_ALLOC(fe);
@@ -523,6 +541,22 @@ int git_filter_list_load(
 	return error;
 }
 
+int git_filter_list_load(
+	git_filter_list **filters,
+	git_repository *repo,
+	git_blob *blob, /* can be NULL */
+	const char *path,
+	git_filter_mode_t mode,
+	uint32_t flags)
+{
+	git_filter_options filter_opts = GIT_FILTER_OPTIONS_INIT;
+
+	filter_opts.flags = flags;
+
+	return git_filter_list__load_ext(
+		filters, repo, blob, path, mode, &filter_opts);
+}
+
 void git_filter_list_free(git_filter_list *fl)
 {
 	uint32_t i;
@@ -575,84 +609,72 @@ size_t git_filter_list_length(const git_filter_list *fl)
 	return fl ? git_array_size(fl->filters) : 0;
 }
 
-static int filter_list_out_buffer_from_raw(
-	git_buf *out, const void *ptr, size_t size)
+struct buf_stream {
+	git_writestream parent;
+	git_buf *target;
+	bool complete;
+};
+
+static int buf_stream_write(
+	git_writestream *s, const char *buffer, size_t len)
 {
-	if (git_buf_is_allocated(out))
-		git_buf_free(out);
+	struct buf_stream *buf_stream = (struct buf_stream *)s;
+	assert(buf_stream);
 
-	if (!size) {
-		git_buf_init(out, 0);
-	} else {
-		out->ptr   = (char *)ptr;
-		out->asize = 0;
-		out->size  = size;
-	}
+	assert(buf_stream->complete == 0);
 
-	return 0;
+	return git_buf_put(buf_stream->target, buffer, len);
 }
 
-int git_filter_list_apply_to_data(
-	git_buf *tgt, git_filter_list *fl, git_buf *src)
+static int buf_stream_close(git_writestream *s)
 {
-	int error = 0;
-	uint32_t i;
-	git_buf *dbuffer[2], local = GIT_BUF_INIT;
-	unsigned int si = 0;
+	struct buf_stream *buf_stream = (struct buf_stream *)s;
+	assert(buf_stream);
 
-	git_buf_sanitize(tgt);
-	git_buf_sanitize(src);
+	assert(buf_stream->complete == 0);
+	buf_stream->complete = 1;
 
-	if (!fl)
-		return filter_list_out_buffer_from_raw(tgt, src->ptr, src->size);
+	return 0;
+}
 
-	dbuffer[0] = src;
-	dbuffer[1] = tgt;
+static void buf_stream_free(git_writestream *s)
+{
+	GIT_UNUSED(s);
+}
 
-	/* if `src` buffer is reallocable, then use it, otherwise copy it */
-	if (!git_buf_is_allocated(src)) {
-		if (git_buf_set(&local, src->ptr, src->size) < 0)
-			return -1;
-		dbuffer[0] = &local;
-	}
+static void buf_stream_init(struct buf_stream *writer, git_buf *target)
+{
+	memset(writer, 0, sizeof(struct buf_stream));
 
-	for (i = 0; i < git_array_size(fl->filters); ++i) {
-		unsigned int di = 1 - si;
-		uint32_t fidx = (fl->source.mode == GIT_FILTER_TO_WORKTREE) ?
-			i : git_array_size(fl->filters) - 1 - i;
-		git_filter_entry *fe = git_array_get(fl->filters, fidx);
-
-		dbuffer[di]->size = 0;
-
-		/* Apply the filter from dbuffer[src] to the other buffer;
-		 * if the filtering is canceled by the user mid-filter,
-		 * we skip to the next filter without changing the source
-		 * of the double buffering (so that the text goes through
-		 * cleanly).
-		 */
+	writer->parent.write = buf_stream_write;
+	writer->parent.close = buf_stream_close;
+	writer->parent.free = buf_stream_free;
+	writer->target = target;
 
-		error = fe->filter->apply(
-			fe->filter, &fe->payload, dbuffer[di], dbuffer[si], &fl->source);
+	git_buf_clear(target);
+}
 
-		if (error == GIT_PASSTHROUGH) {
-			/* PASSTHROUGH means filter decided not to process the buffer */
-			error = 0;
-		} else if (!error) {
-			git_buf_sanitize(dbuffer[di]); /* force NUL termination */
-			si = di; /* swap buffers */
-		} else {
-			tgt->size = 0;
-			goto cleanup;
-		}
+int git_filter_list_apply_to_data(
+	git_buf *tgt, git_filter_list *filters, git_buf *src)
+{
+	struct buf_stream writer;
+	int error;
+
+	git_buf_sanitize(tgt);
+	git_buf_sanitize(src);
+
+	if (!filters) {
+		git_buf_attach_notowned(tgt, src->ptr, src->size);
+		return 0;
 	}
 
-	/* Ensure that the output ends up in dbuffer[1] (i.e. the dest) */
-	if (si != 1)
-		git_buf_swap(dbuffer[0], dbuffer[1]);
+	buf_stream_init(&writer, tgt);
 
-cleanup:
-	git_buf_free(&local); /* don't leak if we allocated locally */
+	if ((error = git_filter_list_stream_data(filters, src,
+		(git_writestream *)&writer)) < 0)
+			return error;
 
+	assert(writer.complete);
 	return error;
 }
 
@@ -662,28 +684,21 @@ int git_filter_list_apply_to_file(
 	git_repository *repo,
 	const char *path)
 {
+	struct buf_stream writer;
 	int error;
-	const char *base = repo ? git_repository_workdir(repo) : NULL;
-	git_buf abspath = GIT_BUF_INIT, raw = GIT_BUF_INIT;
 
-	if (!(error = git_path_join_unrooted(&abspath, path, base, NULL)) &&
-		!(error = git_futils_readbuffer(&raw, abspath.ptr)))
-	{
-		error = git_filter_list_apply_to_data(out, filters, &raw);
+	buf_stream_init(&writer, out);
 
-		git_buf_free(&raw);
-	}
+	if ((error = git_filter_list_stream_file(
+		filters, repo, path, (git_writestream *)&writer)) < 0)
+			return error;
 
-	git_buf_free(&abspath);
+	assert(writer.complete);
 	return error;
 }
 
-int git_filter_list_apply_to_blob(
-	git_buf *out,
-	git_filter_list *filters,
-	git_blob *blob)
+static int buf_from_blob(git_buf *out, git_blob *blob)
 {
-	git_buf in = GIT_BUF_INIT;
 	git_off_t rawsize = git_blob_rawsize(blob);
 
 	if (!git__is_sizet(rawsize)) {
@@ -691,12 +706,249 @@ int git_filter_list_apply_to_blob(
 		return -1;
 	}
 
-	in.ptr   = (char *)git_blob_rawcontent(blob);
-	in.asize = 0;
-	in.size  = (size_t)rawsize;
+	git_buf_attach_notowned(out, git_blob_rawcontent(blob), (size_t)rawsize);
+	return 0;
+}
+
+int git_filter_list_apply_to_blob(
+	git_buf *out,
+	git_filter_list *filters,
+	git_blob *blob)
+{
+	struct buf_stream writer;
+	int error;
+
+	buf_stream_init(&writer, out);
+
+	if ((error = git_filter_list_stream_blob(
+		filters, blob, (git_writestream *)&writer)) < 0)
+			return error;
+
+	assert(writer.complete);
+	return error;
+}
+
+struct proxy_stream {
+	git_writestream parent;
+	git_filter *filter;
+	const git_filter_source *source;
+	void **payload;
+	git_buf input;
+	git_buf temp_buf;
+	git_buf *output;
+	git_writestream *target;
+};
+
+static int proxy_stream_write(
+	git_writestream *s, const char *buffer, size_t len)
+{
+	struct proxy_stream *proxy_stream = (struct proxy_stream *)s;
+	assert(proxy_stream);
+
+	return git_buf_put(&proxy_stream->input, buffer, len);
+}
+
+static int proxy_stream_close(git_writestream *s)
+{
+	struct proxy_stream *proxy_stream = (struct proxy_stream *)s;
+	git_buf *writebuf;
+	int error;
+
+	assert(proxy_stream);
+
+	error = proxy_stream->filter->apply(
+		proxy_stream->filter,
+		proxy_stream->payload,
+		proxy_stream->output,
+		&proxy_stream->input,
+		proxy_stream->source);
+
+	if (error == GIT_PASSTHROUGH) {
+		writebuf = &proxy_stream->input;
+	} else if (error == 0) {
+		git_buf_sanitize(proxy_stream->output);
+		writebuf = proxy_stream->output;
+	} else {
+		return error;
+	}
+
+	if ((error = proxy_stream->target->write(
+			proxy_stream->target, writebuf->ptr, writebuf->size)) == 0)
+		error = proxy_stream->target->close(proxy_stream->target);
+
+	return error;
+}
+
+static void proxy_stream_free(git_writestream *s)
+{
+	struct proxy_stream *proxy_stream = (struct proxy_stream *)s;
+	assert(proxy_stream);
+
+	git_buf_free(&proxy_stream->input);
+	git_buf_free(&proxy_stream->temp_buf);
+	git__free(proxy_stream);
+}
+
+static int proxy_stream_init(
+	git_writestream **out,
+	git_filter *filter,
+	git_buf *temp_buf,
+	void **payload,
+	const git_filter_source *source,
+	git_writestream *target)
+{
+	struct proxy_stream *proxy_stream = git__calloc(1, sizeof(struct proxy_stream));
+	GITERR_CHECK_ALLOC(proxy_stream);
+
+	proxy_stream->parent.write = proxy_stream_write;
+	proxy_stream->parent.close = proxy_stream_close;
+	proxy_stream->parent.free = proxy_stream_free;
+	proxy_stream->filter = filter;
+	proxy_stream->payload = payload;
+	proxy_stream->source = source;
+	proxy_stream->target = target;
+	proxy_stream->output = temp_buf ? temp_buf : &proxy_stream->temp_buf;
+
+	*out = (git_writestream *)proxy_stream;
+	return 0;
+}
+
+static int stream_list_init(
+	git_writestream **out,
+	git_vector *streams,
+	git_filter_list *filters,
+	git_writestream *target)
+{
+	git_writestream *last_stream = target;
+	size_t i;
+	int error = 0;
+
+	*out = NULL;
+
+	if (!filters) {
+		*out = target;
+		return 0;
+	}
+
+	/* Create filters last to first to get the chaining direction */
+	for (i = 0; i < git_array_size(filters->filters); ++i) {
+		size_t filter_idx = (filters->source.mode == GIT_FILTER_TO_WORKTREE) ?
+			git_array_size(filters->filters) - 1 - i : i;
+		git_filter_entry *fe = git_array_get(filters->filters, filter_idx);
+		git_writestream *filter_stream;
+		
+		assert(fe->filter->stream || fe->filter->apply);
+
+		/* If necessary, create a stream that proxies the traditional
+		 * application.
+		 */
+		if (fe->filter->stream)
+			error = fe->filter->stream(&filter_stream, fe->filter,
+				&fe->payload, &filters->source, last_stream);
+		else
+			/* Create a stream that proxies the one-shot apply */
+			error = proxy_stream_init(&filter_stream, fe->filter,
+				filters->temp_buf, &fe->payload, &filters->source,
+				last_stream);
+
+		if (error < 0)
+			return error;
+
+		git_vector_insert(streams, filter_stream);
+		last_stream = filter_stream;
+	}
+
+	*out = last_stream;
+	return 0;
+}
+
+void stream_list_free(git_vector *streams)
+{
+	git_writestream *stream;
+	size_t i;
+
+	git_vector_foreach(streams, i, stream)
+		stream->free(stream);
+	git_vector_free(streams);
+}
+
+#define STREAM_BUFSIZE 10240
+
+int git_filter_list_stream_file(
+	git_filter_list *filters,
+	git_repository *repo,
+	const char *path,
+	git_writestream *target)
+{
+	char buf[STREAM_BUFSIZE];
+	git_buf abspath = GIT_BUF_INIT;
+	const char *base = repo ? git_repository_workdir(repo) : NULL;
+	git_vector filter_streams = GIT_VECTOR_INIT;
+	git_writestream *stream_start;
+	ssize_t readlen;
+	int fd, error;
+
+	if ((error = stream_list_init(
+			&stream_start, &filter_streams, filters, target)) < 0 ||
+		(error = git_path_join_unrooted(&abspath, path, base, NULL)) < 0)
+		goto done;
+
+	if ((fd = git_futils_open_ro(abspath.ptr)) < 0) {
+		error = fd;
+		goto done;
+	}
+
+	while ((readlen = p_read(fd, buf, STREAM_BUFSIZE)) > 0) {
+		if ((error = stream_start->write(stream_start, buf, readlen)) < 0)
+			goto done;
+	}
+
+	if (!readlen)
+		error = stream_start->close(stream_start);
+	else if (readlen < 0)
+		error = readlen;
+
+	p_close(fd);
+
+done:
+	stream_list_free(&filter_streams);
+	git_buf_free(&abspath);
+	return error;
+}
+
+int git_filter_list_stream_data(
+	git_filter_list *filters,
+	git_buf *data,
+	git_writestream *target)
+{
+	git_vector filter_streams = GIT_VECTOR_INIT;
+	git_writestream *stream_start;
+	int error = 0;
+
+	git_buf_sanitize(data);
+
+	if ((error = stream_list_init(
+			&stream_start, &filter_streams, filters, target)) == 0 &&
+		(error =
+			stream_start->write(stream_start, data->ptr, data->size)) == 0)
+		error = stream_start->close(stream_start);
+
+	stream_list_free(&filter_streams);
+	return error;
+}
+
+int git_filter_list_stream_blob(
+	git_filter_list *filters,
+	git_blob *blob,
+	git_writestream *target)
+{
+	git_buf in = GIT_BUF_INIT;
+
+	if (buf_from_blob(&in, blob) < 0)
+		return -1;
 
 	if (filters)
 		git_oid_cpy(&filters->source.oid, git_blob_id(blob));
 
-	return git_filter_list_apply_to_data(out, filters, &in);
+	return git_filter_list_stream_data(filters, &in, target);
 }