/*

* Copyright (C) the libgit2 contributors. All rights reserved.

*

* This file is part of libgit2, distributed under the GNU GPL v2 with

* a Linking Exception. For full terms see the included COPYING file.

*/

#include "filter.h"

#include "buf.h"

#include "common.h"

#include "futils.h"

#include "hash.h"

#include "repository.h"

#include "runtime.h"

#include "git2/sys/filter.h"

#include "git2/config.h"

#include "blob.h"

#include "attr_file.h"

#include "array.h"

#include "path.h"

struct git_filter_source {

git_repository *repo;

const char *path;

git_oid oid; /* zero if unknown (which is likely) */

uint16_t filemode; /* zero if unknown */

git_filter_mode_t mode;

git_filter_options options;

};

typedef struct {

const char *filter_name;

git_filter *filter;

void *payload;

} git_filter_entry;

struct git_filter_list {

git_array_t(git_filter_entry) filters;

git_filter_source source;

git_str *temp_buf;

char path[GIT_FLEX_ARRAY];

};

typedef struct {

char *filter_name;

git_filter *filter;

int priority;

int initialized;

size_t nattrs, nmatches;

char *attrdata;

const char *attrs[GIT_FLEX_ARRAY];

} git_filter_def;

static int filter_def_priority_cmp(const void *a, const void *b)

{

int pa = ((const git_filter_def *)a)->priority;

int pb = ((const git_filter_def *)b)->priority;

return (pa < pb) ? -1 : (pa > pb) ? 1 : 0;

}

struct git_filter_registry {

git_rwlock lock;

git_vector filters;

};

static struct git_filter_registry filter_registry;

static void git_filter_global_shutdown(void);

static int filter_def_scan_attrs(

git_str *attrs, size_t *nattr, size_t *nmatch, const char *attr_str)

{

const char *start, *scan = attr_str;

int has_eq;

*nattr = *nmatch = 0;

if (!scan)

return 0;

while (*scan) {

while (git__isspace(*scan)) scan++;

for (start = scan, has_eq = 0; *scan && !git__isspace(*scan); ++scan) {

if (*scan == '=')

has_eq = 1;

}

if (scan > start) {

(*nattr)++;

if (has_eq || *start == '-' || *start == '+' || *start == '!')

(*nmatch)++;

if (has_eq)

git_str_putc(attrs, '=');

git_str_put(attrs, start, scan - start);

git_str_putc(attrs, '\0');

}

}

return 0;

}

static void filter_def_set_attrs(git_filter_def *fdef)

{

char *scan = fdef->attrdata;

size_t i;

for (i = 0; i < fdef->nattrs; ++i) {

const char *name, *value;

switch (*scan) {

case '=':

name = scan + 1;

for (scan++; *scan != '='; scan++) /* find '=' */;

*scan++ = '\0';

value = scan;

break;

case '-':

name = scan + 1; value = git_attr__false; break;

case '+':

name = scan + 1; value = git_attr__true; break;

case '!':

name = scan + 1; value = git_attr__unset; break;

default:

name = scan; value = NULL; break;

}

fdef->attrs[i] = name;

fdef->attrs[i + fdef->nattrs] = value;

scan += strlen(scan) + 1;

}

}

static int filter_def_name_key_check(const void *key, const void *fdef)

{

const char *name =

fdef ? ((const git_filter_def *)fdef)->filter_name : NULL;

return name ? git__strcmp(key, name) : -1;

}

static int filter_def_filter_key_check(const void *key, const void *fdef)

{

const void *filter = fdef ? ((const git_filter_def *)fdef)->filter : NULL;

return (key == filter) ? 0 : -1;

}

/* Note: callers must lock the registry before calling this function */

static int filter_registry_insert(

const char *name, git_filter *filter, int priority)

{

git_filter_def *fdef;

size_t nattr = 0, nmatch = 0, alloc_len;

git_str attrs = GIT_STR_INIT;

if (filter_def_scan_attrs(&attrs, &nattr, &nmatch, filter->attributes) < 0)

return -1;

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);

GIT_ERROR_CHECK_ALLOC(fdef);

fdef->filter_name = git__strdup(name);

GIT_ERROR_CHECK_ALLOC(fdef->filter_name);

fdef->filter = filter;

fdef->priority = priority;

fdef->nattrs = nattr;

fdef->nmatches = nmatch;

fdef->attrdata = git_str_detach(&attrs);

filter_def_set_attrs(fdef);

if (git_vector_insert(&filter_registry.filters, fdef) < 0) {

git__free(fdef->filter_name);

git__free(fdef->attrdata);

git__free(fdef);

return -1;

}

git_vector_sort(&filter_registry.filters);

return 0;

}

int git_filter_global_init(void)

{

git_filter *crlf = NULL, *ident = NULL;

int error = 0;

if (git_rwlock_init(&filter_registry.lock) < 0)

return -1;

if ((error = git_vector_init(&filter_registry.filters, 2,

filter_def_priority_cmp)) < 0)

goto done;

if ((crlf = git_crlf_filter_new()) == NULL ||

filter_registry_insert(

GIT_FILTER_CRLF, crlf, GIT_FILTER_CRLF_PRIORITY) < 0 ||

(ident = git_ident_filter_new()) == NULL ||

filter_registry_insert(

GIT_FILTER_IDENT, ident, GIT_FILTER_IDENT_PRIORITY) < 0)

error = -1;

if (!error)

error = git_runtime_shutdown_register(git_filter_global_shutdown);

done:

if (error) {

git_filter_free(crlf);

git_filter_free(ident);

}

return error;

}

static void git_filter_global_shutdown(void)

{

size_t pos;

git_filter_def *fdef;

if (git_rwlock_wrlock(&filter_registry.lock) < 0)

return;

git_vector_foreach(&filter_registry.filters, pos, fdef) {

if (fdef->filter && fdef->filter->shutdown) {

fdef->filter->shutdown(fdef->filter);

fdef->initialized = false;

}

git__free(fdef->filter_name);

git__free(fdef->attrdata);

git__free(fdef);

}

git_vector_free(&filter_registry.filters);

git_rwlock_wrunlock(&filter_registry.lock);

git_rwlock_free(&filter_registry.lock);

}

/* Note: callers must lock the registry before calling this function */

static int filter_registry_find(size_t *pos, const char *name)

{

return git_vector_search2(

pos, &filter_registry.filters, filter_def_name_key_check, name);

}

/* Note: callers must lock the registry before calling this function */

static git_filter_def *filter_registry_lookup(size_t *pos, const char *name)

{

git_filter_def *fdef = NULL;

if (!filter_registry_find(pos, name))

fdef = git_vector_get(&filter_registry.filters, *pos);

return fdef;

}

int git_filter_register(

const char *name, git_filter *filter, int priority)

{

int error;

GIT_ASSERT_ARG(name);

GIT_ASSERT_ARG(filter);

if (git_rwlock_wrlock(&filter_registry.lock) < 0) {

git_error_set(GIT_ERROR_OS, "failed to lock filter registry");

return -1;

}

if (!filter_registry_find(NULL, name)) {

git_error_set(

GIT_ERROR_FILTER, "attempt to reregister existing filter '%s'", name);

error = GIT_EEXISTS;

goto done;

}

error = filter_registry_insert(name, filter, priority);

done:

git_rwlock_wrunlock(&filter_registry.lock);

return error;

}

int git_filter_unregister(const char *name)

{

size_t pos;

git_filter_def *fdef;

int error = 0;

GIT_ASSERT_ARG(name);

/* cannot unregister default filters */

if (!strcmp(GIT_FILTER_CRLF, name) || !strcmp(GIT_FILTER_IDENT, name)) {

git_error_set(GIT_ERROR_FILTER, "cannot unregister filter '%s'", name);

return -1;

}

if (git_rwlock_wrlock(&filter_registry.lock) < 0) {

git_error_set(GIT_ERROR_OS, "failed to lock filter registry");

return -1;

}

if ((fdef = filter_registry_lookup(&pos, name)) == NULL) {

git_error_set(GIT_ERROR_FILTER, "cannot find filter '%s' to unregister", name);

error = GIT_ENOTFOUND;

goto done;

}

git_vector_remove(&filter_registry.filters, pos);

if (fdef->initialized && fdef->filter && fdef->filter->shutdown) {

fdef->filter->shutdown(fdef->filter);

fdef->initialized = false;

}

git__free(fdef->filter_name);

git__free(fdef->attrdata);

git__free(fdef);

done:

git_rwlock_wrunlock(&filter_registry.lock);

return error;

}

static int filter_initialize(git_filter_def *fdef)

{

int error = 0;

if (!fdef->initialized && fdef->filter && fdef->filter->initialize) {

if ((error = fdef->filter->initialize(fdef->filter)) < 0)

return error;

}

fdef->initialized = true;

return 0;

}

git_filter *git_filter_lookup(const char *name)

{

size_t pos;

git_filter_def *fdef;

git_filter *filter = NULL;

if (git_rwlock_rdlock(&filter_registry.lock) < 0) {

git_error_set(GIT_ERROR_OS, "failed to lock filter registry");

return NULL;

}

if ((fdef = filter_registry_lookup(&pos, name)) == NULL ||

(!fdef->initialized && filter_initialize(fdef) < 0))

goto done;

filter = fdef->filter;

done:

git_rwlock_rdunlock(&filter_registry.lock);

return filter;

}

void git_filter_free(git_filter *filter)

{

git__free(filter);

}

git_repository *git_filter_source_repo(const git_filter_source *src)

{

return src->repo;

}

const char *git_filter_source_path(const git_filter_source *src)

{

return src->path;

}

uint16_t git_filter_source_filemode(const git_filter_source *src)

{

return src->filemode;

}

const git_oid *git_filter_source_id(const git_filter_source *src)

{

return git_oid_is_zero(&src->oid) ? NULL : &src->oid;

}

git_filter_mode_t git_filter_source_mode(const git_filter_source *src)

{

return src->mode;

}

uint32_t git_filter_source_flags(const git_filter_source *src)

{

return src->options.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, alloclen;

GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, sizeof(git_filter_list), pathlen);

GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);

fl = git__calloc(1, alloclen);

GIT_ERROR_CHECK_ALLOC(fl);

if (src->path)

memcpy(fl->path, src->path, pathlen);

fl->source.repo = src->repo;

fl->source.path = fl->path;

fl->source.mode = src->mode;

memcpy(&fl->source.options, &src->options, sizeof(git_filter_options));

*out = fl;

return 0;

}

static int filter_list_check_attributes(

const char ***out,

git_repository *repo,

git_filter_session *filter_session,

git_filter_def *fdef,

const git_filter_source *src)

{

const char **strs = git__calloc(fdef->nattrs, sizeof(const char *));

git_attr_options attr_opts = GIT_ATTR_OPTIONS_INIT;

size_t i;

int error;

GIT_ERROR_CHECK_ALLOC(strs);

if ((src->options.flags & GIT_FILTER_NO_SYSTEM_ATTRIBUTES) != 0)

attr_opts.flags |= GIT_ATTR_CHECK_NO_SYSTEM;

if ((src->options.flags & GIT_FILTER_ATTRIBUTES_FROM_HEAD) != 0)

attr_opts.flags |= GIT_ATTR_CHECK_INCLUDE_HEAD;

if ((src->options.flags & GIT_FILTER_ATTRIBUTES_FROM_COMMIT) != 0) {

attr_opts.flags |= GIT_ATTR_CHECK_INCLUDE_COMMIT;

#ifndef GIT_DEPRECATE_HARD

if (src->options.commit_id)

git_oid_cpy(&attr_opts.attr_commit_id, src->options.commit_id);

else

#endif

git_oid_cpy(&attr_opts.attr_commit_id, &src->options.attr_commit_id);

}

error = git_attr_get_many_with_session(

strs, repo, filter_session->attr_session, &attr_opts, 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) {

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_value_t want_type, found_type;

if (!want)

continue;

want_type = git_attr_value(want);

found_type = git_attr_value(strs[i]);

if (want_type != found_type)

error = GIT_ENOTFOUND;

else if (want_type == GIT_ATTR_VALUE_STRING &&

strcmp(want, strs[i]) &&

strcmp(want, "*"))

error = GIT_ENOTFOUND;

}

if (error)

git__free((void *)strs);

else

*out = strs;

return error;

}

int git_filter_list_new(

git_filter_list **out,

git_repository *repo,

git_filter_mode_t mode,

uint32_t flags)

{

git_filter_source src = { 0 };

src.repo = repo;

src.path = NULL;

src.mode = mode;

src.options.flags = flags;

return filter_list_new(out, &src);

}

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,

git_filter_session *filter_session)

{

int error = 0;

int i;

int disabled_filter_found;

git_filter_list *fl = NULL;

git_filter_source src = { 0 };

git_filter_entry *fe;

size_t idx;

git_filter_def *fdef;

if (git_rwlock_rdlock(&filter_registry.lock) < 0) {

git_error_set(GIT_ERROR_OS, "failed to lock filter registry");

return -1;

}

src.repo = repo;

src.path = path;

src.mode = mode;

memcpy(&src.options, &filter_session->options, sizeof(git_filter_options));

if (blob)

git_oid_cpy(&src.oid, git_blob_id(blob));

git_vector_foreach(&filter_registry.filters, idx, fdef) {

const char **values = NULL;

void *payload = NULL;

if (!fdef || !fdef->filter)

continue;

if (filter_session->disabled_filters) {

disabled_filter_found = 0;

for (i = 0; i < filter_session->disabled_filters->count; ++i) {

char *filter = filter_session->disabled_filters->strings[i];

if (!strcmp(filter, fdef->filter_name)) {

disabled_filter_found = 1;

break;

}

}

if (disabled_filter_found)

continue;

}

if (fdef->nattrs > 0) {

error = filter_list_check_attributes(

&values, repo,

filter_session, fdef, &src);

if (error == GIT_ENOTFOUND) {

error = 0;

continue;

} else if (error < 0)

break;

}

if (!fdef->initialized && (error = filter_initialize(fdef)) < 0)

break;

if (fdef->filter->check)

error = fdef->filter->check(

fdef->filter, &payload, &src, values);

git__free((void *)values);

if (error == GIT_PASSTHROUGH)

error = 0;

else if (error < 0)

break;

else {

if (!fl) {

if ((error = filter_list_new(&fl, &src)) < 0)

break;

fl->temp_buf = filter_session->temp_buf;

}

fe = git_array_alloc(fl->filters);

GIT_ERROR_CHECK_ALLOC(fe);

fe->filter = fdef->filter;

fe->filter_name = fdef->filter_name;

fe->payload = payload;

}

}

git_rwlock_rdunlock(&filter_registry.lock);

if (error && fl != NULL) {

git_array_clear(fl->filters);

git__free(fl);

fl = NULL;

}

*filters = fl;

return error;

}

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,

git_filter_options *opts)

{

git_filter_session filter_session = GIT_FILTER_SESSION_INIT;

if (opts)

memcpy(&filter_session.options, opts, sizeof(git_filter_options));

return git_filter_list__load(

filters, repo, blob, path, mode, &filter_session);

}

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_session filter_session = GIT_FILTER_SESSION_INIT;

filter_session.options.flags = flags;

return git_filter_list__load(

filters, repo, blob, path, mode, &filter_session);

}

void git_filter_list_free(git_filter_list *fl)

{

uint32_t i;

if (!fl)

return;

for (i = 0; i < git_array_size(fl->filters); ++i) {

git_filter_entry *fe = git_array_get(fl->filters, i);

if (fe->filter->cleanup)

fe->filter->cleanup(fe->filter, fe->payload);

}

git_array_clear(fl->filters);

git__free(fl);

}

int git_filter_list_contains(

git_filter_list *fl,

const char *name)

{

size_t i;

GIT_ASSERT_ARG(name);

if (!fl)

return 0;

for (i = 0; i < fl->filters.size; i++) {

if (strcmp(fl->filters.ptr[i].filter_name, name) == 0)

return 1;

}

return 0;

}

int git_filter_list_push(

git_filter_list *fl, git_filter *filter, void *payload)

{

int error = 0;

size_t pos;

git_filter_def *fdef = NULL;

git_filter_entry *fe;

GIT_ASSERT_ARG(fl);

GIT_ASSERT_ARG(filter);

if (git_rwlock_rdlock(&filter_registry.lock) < 0) {

git_error_set(GIT_ERROR_OS, "failed to lock filter registry");

return -1;

}

if (git_vector_search2(

&pos, &filter_registry.filters,

filter_def_filter_key_check, filter) == 0)

fdef = git_vector_get(&filter_registry.filters, pos);

git_rwlock_rdunlock(&filter_registry.lock);

if (fdef == NULL) {

git_error_set(GIT_ERROR_FILTER, "cannot use an unregistered filter");

return -1;

}

if (!fdef->initialized && (error = filter_initialize(fdef)) < 0)

return error;

fe = git_array_alloc(fl->filters);

GIT_ERROR_CHECK_ALLOC(fe);

fe->filter = filter;

fe->payload = payload;

return 0;

}

size_t git_filter_list_length(const git_filter_list *fl)

{

return fl ? git_array_size(fl->filters) : 0;

}

struct buf_stream {

git_writestream parent;

git_str *target;

bool complete;

};

static int buf_stream_write(

git_writestream *s, const char *buffer, size_t len)

{

struct buf_stream *buf_stream = (struct buf_stream *)s;

GIT_ASSERT_ARG(buf_stream);

GIT_ASSERT(buf_stream->complete == 0);

return git_str_put(buf_stream->target, buffer, len);

}

static int buf_stream_close(git_writestream *s)

{

struct buf_stream *buf_stream = (struct buf_stream *)s;

GIT_ASSERT_ARG(buf_stream);

GIT_ASSERT(buf_stream->complete == 0);

buf_stream->complete = 1;

return 0;

}

static void buf_stream_free(git_writestream *s)

{

GIT_UNUSED(s);

}

static void buf_stream_init(struct buf_stream *writer, git_str *target)

{

memset(writer, 0, sizeof(struct buf_stream));

writer->parent.write = buf_stream_write;

writer->parent.close = buf_stream_close;

writer->parent.free = buf_stream_free;

writer->target = target;

git_str_clear(target);

}

int git_filter_list_apply_to_buffer(

git_buf *out,

git_filter_list *filters,

const char *in,

size_t in_len)

{

GIT_BUF_WRAP_PRIVATE(out, git_filter_list__apply_to_buffer, filters, in, in_len);

}

int git_filter_list__apply_to_buffer(

git_str *out,

git_filter_list *filters,

const char *in,

size_t in_len)

{

struct buf_stream writer;

int error;

buf_stream_init(&writer, out);

if ((error = git_filter_list_stream_buffer(filters,

in, in_len, &writer.parent)) < 0)

return error;

GIT_ASSERT(writer.complete);

return error;

}

int git_filter_list__convert_buf(

git_str *out,

git_filter_list *filters,

git_str *in)

{

int error;

if (!filters || git_filter_list_length(filters) == 0) {

git_str_swap(out, in);

git_str_dispose(in);

return 0;

}

error = git_filter_list__apply_to_buffer(out, filters,

in->ptr, in->size);

if (!error)

git_str_dispose(in);

return error;

}

int git_filter_list_apply_to_file(

git_buf *out,

git_filter_list *filters,

git_repository *repo,

const char *path)

{

GIT_BUF_WRAP_PRIVATE(out, git_filter_list__apply_to_file, filters, repo, path);

}

int git_filter_list__apply_to_file(

git_str *out,

git_filter_list *filters,

git_repository *repo,

const char *path)

{

struct buf_stream writer;

int error;

buf_stream_init(&writer, out);

if ((error = git_filter_list_stream_file(

filters, repo, path, &writer.parent)) < 0)

return error;

GIT_ASSERT(writer.complete);

return error;

}

static int buf_from_blob(git_str *out, git_blob *blob)

{

git_object_size_t rawsize = git_blob_rawsize(blob);

if (!git__is_sizet(rawsize)) {

git_error_set(GIT_ERROR_OS, "blob is too large to filter");

return -1;

}

git_str_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)

{

GIT_BUF_WRAP_PRIVATE(out, git_filter_list__apply_to_blob, filters, blob);

}

int git_filter_list__apply_to_blob(

git_str *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, &writer.parent)) < 0)

return error;

GIT_ASSERT(writer.complete);

return error;

}

struct buffered_stream {

git_writestream parent;

git_filter *filter;

int (*write_fn)(git_filter *, void **, git_str *, const git_str *, const git_filter_source *);

int (*legacy_write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *);

const git_filter_source *source;

void **payload;

git_str input;

git_str temp_buf;

git_str *output;

git_writestream *target;

};

static int buffered_stream_write(

git_writestream *s, const char *buffer, size_t len)

{

struct buffered_stream *buffered_stream = (struct buffered_stream *)s;

GIT_ASSERT_ARG(buffered_stream);

return git_str_put(&buffered_stream->input, buffer, len);

}

#ifndef GIT_DEPRECATE_HARD

# define BUF_TO_STRUCT(b, s) \

(b)->ptr = (s)->ptr; \

(b)->size = (s)->size; \

(b)->reserved = (s)->asize;

# define STRUCT_TO_BUF(s, b) \

(s)->ptr = (b)->ptr; \

(s)->size = (b)->size; \

(s)->asize = (b)->reserved;

#endif

static int buffered_stream_close(git_writestream *s)

{

struct buffered_stream *buffered_stream = (struct buffered_stream *)s;

git_str *writebuf;

git_error_state error_state = {0};

int error;

GIT_ASSERT_ARG(buffered_stream);

#ifndef GIT_DEPRECATE_HARD

if (buffered_stream->write_fn == NULL) {

git_buf legacy_output = GIT_BUF_INIT,

legacy_input = GIT_BUF_INIT;

BUF_TO_STRUCT(&legacy_output, buffered_stream->output);

BUF_TO_STRUCT(&legacy_input, &buffered_stream->input);

error = buffered_stream->legacy_write_fn(

buffered_stream->filter,

buffered_stream->payload,

&legacy_output,

&legacy_input,

buffered_stream->source);

STRUCT_TO_BUF(buffered_stream->output, &legacy_output);

STRUCT_TO_BUF(&buffered_stream->input, &legacy_input);

} else

#endif

error = buffered_stream->write_fn(

buffered_stream->filter,

buffered_stream->payload,

buffered_stream->output,

&buffered_stream->input,

buffered_stream->source);

if (error == GIT_PASSTHROUGH) {

writebuf = &buffered_stream->input;

} else if (error == 0) {

writebuf = buffered_stream->output;

} else {

/* close stream before erroring out taking care

* to preserve the original error */

git_error_state_capture(&error_state, error);

buffered_stream->target->close(buffered_stream->target);

git_error_state_restore(&error_state);

return error;

}

if ((error = buffered_stream->target->write(

buffered_stream->target, writebuf->ptr, writebuf->size)) == 0)

error = buffered_stream->target->close(buffered_stream->target);

return error;

}

static void buffered_stream_free(git_writestream *s)

{

struct buffered_stream *buffered_stream = (struct buffered_stream *)s;

if (buffered_stream) {

git_str_dispose(&buffered_stream->input);

git_str_dispose(&buffered_stream->temp_buf);

git__free(buffered_stream);

}

}

int git_filter_buffered_stream_new(

git_writestream **out,

git_filter *filter,

int (*write_fn)(git_filter *, void **, git_str *, const git_str *, const git_filter_source *),

git_str *temp_buf,

void **payload,

const git_filter_source *source,

git_writestream *target)

{

struct buffered_stream *buffered_stream = git__calloc(1, sizeof(struct buffered_stream));

GIT_ERROR_CHECK_ALLOC(buffered_stream);

buffered_stream->parent.write = buffered_stream_write;