filter.c 22 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3 4 5 6 7
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */

8 9
#include "filter.h"

10 11 12
#include "common.h"
#include "fileops.h"
#include "hash.h"
13
#include "repository.h"
14
#include "global.h"
15
#include "git2/sys/filter.h"
16
#include "git2/config.h"
17
#include "blob.h"
18
#include "attr_file.h"
19
#include "array.h"
20

21 22 23 24 25
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 */
26
	git_filter_mode_t mode;
27
	uint32_t        flags;
28 29
};

30
typedef struct {
31
	const char *filter_name;
32 33 34 35 36 37 38
	git_filter *filter;
	void *payload;
} git_filter_entry;

struct git_filter_list {
	git_array_t(git_filter_entry) filters;
	git_filter_source source;
39
	git_buf *temp_buf;
40 41 42 43
	char path[GIT_FLEX_ARRAY];
};

typedef struct {
44
	char *filter_name;
45
	git_filter *filter;
46
	int priority;
47
	int initialized;
48 49 50
	size_t nattrs, nmatches;
	char *attrdata;
	const char *attrs[GIT_FLEX_ARRAY];
51 52
} git_filter_def;

53 54 55 56 57 58 59
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;
}

60 61
struct git_filter_registry {
	git_rwlock lock;
62
	git_vector filters;
63 64
};

65
static struct git_filter_registry filter_registry;
66

67
static void git_filter_global_shutdown(void);
Russell Belfer committed
68

69

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
static int filter_def_scan_attrs(
	git_buf *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)++;
Russell Belfer committed
91
			if (has_eq || *start == '-' || *start == '+' || *start == '!')
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
				(*nmatch)++;

			if (has_eq)
				git_buf_putc(attrs, '=');
			git_buf_put(attrs, start, scan - start);
			git_buf_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;
	}
}

136 137 138 139
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;
140 141 142 143 144 145 146
	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;
147 148
}

149 150
/* Note: callers must lock the registry before calling this function */
static int filter_registry_insert(
151 152 153
	const char *name, git_filter *filter, int priority)
{
	git_filter_def *fdef;
154
	size_t nattr = 0, nmatch = 0, alloc_len;
155 156 157 158 159
	git_buf attrs = GIT_BUF_INIT;

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

160 161 162
	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));
163 164

	fdef = git__calloc(1, alloc_len);
165 166
	GITERR_CHECK_ALLOC(fdef);

167 168 169
	fdef->filter_name = git__strdup(name);
	GITERR_CHECK_ALLOC(fdef->filter_name);

170 171 172 173 174 175 176 177
	fdef->filter      = filter;
	fdef->priority    = priority;
	fdef->nattrs      = nattr;
	fdef->nmatches    = nmatch;
	fdef->attrdata    = git_buf_detach(&attrs);

	filter_def_set_attrs(fdef);

178
	if (git_vector_insert(&filter_registry.filters, fdef) < 0) {
179
		git__free(fdef->filter_name);
180 181 182 183 184
		git__free(fdef->attrdata);
		git__free(fdef);
		return -1;
	}

185
	git_vector_sort(&filter_registry.filters);
186 187 188
	return 0;
}

189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
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;

	git__on_shutdown(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;

	assert(name && filter);

	if (git_rwlock_wrlock(&filter_registry.lock) < 0) {
		giterr_set(GITERR_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);
		error = GIT_EEXISTS;
		goto done;
	}

	error = filter_registry_insert(name, filter, priority);

done:
	git_rwlock_wrunlock(&filter_registry.lock);
	return error;
}

290 291 292 293
int git_filter_unregister(const char *name)
{
	size_t pos;
	git_filter_def *fdef;
294
	int error = 0;
295

296 297
	assert(name);

298
	/* cannot unregister default filters */
Russell Belfer committed
299
	if (!strcmp(GIT_FILTER_CRLF, name) || !strcmp(GIT_FILTER_IDENT, name)) {
300
		giterr_set(GITERR_FILTER, "cannot unregister filter '%s'", name);
301 302 303
		return -1;
	}

304 305 306 307 308
	if (git_rwlock_wrlock(&filter_registry.lock) < 0) {
		giterr_set(GITERR_OS, "failed to lock filter registry");
		return -1;
	}

309
	if ((fdef = filter_registry_lookup(&pos, name)) == NULL) {
310
		giterr_set(GITERR_FILTER, "cannot find filter '%s' to unregister", name);
311 312
		error = GIT_ENOTFOUND;
		goto done;
313 314
	}

315
	git_vector_remove(&filter_registry.filters, pos);
316

317
	if (fdef->initialized && fdef->filter && fdef->filter->shutdown) {
318
		fdef->filter->shutdown(fdef->filter);
319 320
		fdef->initialized = false;
	}
321

322
	git__free(fdef->filter_name);
323 324 325
	git__free(fdef->attrdata);
	git__free(fdef);

326 327 328
done:
	git_rwlock_wrunlock(&filter_registry.lock);
	return error;
329 330
}

331 332 333 334
static int filter_initialize(git_filter_def *fdef)
{
	int error = 0;

335 336 337
	if (!fdef->initialized && fdef->filter && fdef->filter->initialize) {
		if ((error = fdef->filter->initialize(fdef->filter)) < 0)
			return error;
338 339 340 341 342 343
	}

	fdef->initialized = true;
	return 0;
}

344 345 346
git_filter *git_filter_lookup(const char *name)
{
	size_t pos;
347
	git_filter_def *fdef;
348
	git_filter *filter = NULL;
349

350 351
	if (git_rwlock_rdlock(&filter_registry.lock) < 0) {
		giterr_set(GITERR_OS, "failed to lock filter registry");
352
		return NULL;
353
	}
354

355 356 357
	if ((fdef = filter_registry_lookup(&pos, name)) == NULL ||
		(!fdef->initialized && filter_initialize(fdef) < 0))
		goto done;
358

359
	filter = fdef->filter;
360

361 362 363
done:
	git_rwlock_rdunlock(&filter_registry.lock);
	return filter;
364 365
}

Russell Belfer committed
366 367 368 369 370
void git_filter_free(git_filter *filter)
{
	git__free(filter);
}

371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
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_iszero(&src->oid) ? NULL : &src->oid;
}

391 392 393 394 395
git_filter_mode_t git_filter_source_mode(const git_filter_source *src)
{
	return src->mode;
}

396
uint32_t git_filter_source_flags(const git_filter_source *src)
397
{
398
	return src->flags;
399 400
}

401
static int filter_list_new(
402
	git_filter_list **out, const git_filter_source *src)
403
{
404
	git_filter_list *fl = NULL;
405
	size_t pathlen = src->path ? strlen(src->path) : 0, alloclen;
406

407 408
	GITERR_CHECK_ALLOC_ADD(&alloclen, sizeof(git_filter_list), pathlen);
	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
409

410
	fl = git__calloc(1, alloclen);
411 412 413 414 415 416
	GITERR_CHECK_ALLOC(fl);

	if (src->path)
		memcpy(fl->path, src->path, pathlen);
	fl->source.repo = src->repo;
	fl->source.path = fl->path;
417
	fl->source.mode = src->mode;
418
	fl->source.flags = src->flags;
419 420 421 422 423

	*out = fl;
	return 0;
}

424
static int filter_list_check_attributes(
425 426 427 428 429
	const char ***out,
	git_repository *repo,
	git_attr_session *attr_session,
	git_filter_def *fdef,
	const git_filter_source *src)
430 431 432 433 434 435
{
	int error;
	size_t i;
	const char **strs = git__calloc(fdef->nattrs, sizeof(const char *));
	GITERR_CHECK_ALLOC(strs);

436 437
	error = git_attr_get_many_with_session(
		strs, repo, attr_session, 0, src->path, fdef->nattrs, fdef->attrs);
438 439 440 441

	/* if no values were found but no matches are needed, it's okay! */
	if (error == GIT_ENOTFOUND && !fdef->nmatches) {
		giterr_clear();
Russell Belfer committed
442
		git__free((void *)strs);
443 444 445 446 447 448 449 450 451 452 453 454 455
		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;

		if (!want)
			continue;

		want_type  = git_attr_value(want);
		found_type = git_attr_value(strs[i]);

456 457 458 459 460
		if (want_type != found_type)
			error = GIT_ENOTFOUND;
		else if (want_type == GIT_ATTR_VALUE_T &&
				strcmp(want, strs[i]) &&
				strcmp(want, "*"))
461 462 463 464
			error = GIT_ENOTFOUND;
	}

	if (error)
Russell Belfer committed
465
		git__free((void *)strs);
466 467 468 469 470 471
	else
		*out = strs;

	return error;
}

472
int git_filter_list_new(
473 474 475
	git_filter_list **out,
	git_repository *repo,
	git_filter_mode_t mode,
476
	uint32_t flags)
477 478 479 480 481
{
	git_filter_source src = { 0 };
	src.repo = repo;
	src.path = NULL;
	src.mode = mode;
482
	src.flags = flags;
483 484 485
	return filter_list_new(out, &src);
}

486
int git_filter_list__load_ext(
487 488
	git_filter_list **filters,
	git_repository *repo,
Russell Belfer committed
489
	git_blob *blob, /* can be NULL */
490
	const char *path,
491
	git_filter_mode_t mode,
492
	git_filter_options *filter_opts)
493 494 495 496 497
{
	int error = 0;
	git_filter_list *fl = NULL;
	git_filter_source src = { 0 };
	git_filter_entry *fe;
498 499
	size_t idx;
	git_filter_def *fdef;
500

501 502
	if (git_rwlock_rdlock(&filter_registry.lock) < 0) {
		giterr_set(GITERR_OS, "failed to lock filter registry");
503
		return -1;
504
	}
505 506 507

	src.repo = repo;
	src.path = path;
508
	src.mode = mode;
509 510
	src.flags = filter_opts->flags;

Russell Belfer committed
511 512
	if (blob)
		git_oid_cpy(&src.oid, git_blob_id(blob));
513

514
	git_vector_foreach(&filter_registry.filters, idx, fdef) {
515
		const char **values = NULL;
516 517 518 519
		void *payload = NULL;

		if (!fdef || !fdef->filter)
			continue;
520

521
		if (fdef->nattrs > 0) {
522
			error = filter_list_check_attributes(
523
				&values, repo, filter_opts->attr_session, fdef, &src);
524

525 526 527 528 529 530 531
			if (error == GIT_ENOTFOUND) {
				error = 0;
				continue;
			} else if (error < 0)
				break;
		}

532 533 534
		if (!fdef->initialized && (error = filter_initialize(fdef)) < 0)
			break;

535
		if (fdef->filter->check)
536
			error = fdef->filter->check(
537
				fdef->filter, &payload, &src, values);
538

Russell Belfer committed
539
		git__free((void *)values);
540

Russell Belfer committed
541
		if (error == GIT_PASSTHROUGH)
542 543 544 545
			error = 0;
		else if (error < 0)
			break;
		else {
546 547
			if (!fl) {
				if ((error = filter_list_new(&fl, &src)) < 0)
548
					break;
549 550 551

				fl->temp_buf = filter_opts->temp_buf;
			}
552 553 554

			fe = git_array_alloc(fl->filters);
			GITERR_CHECK_ALLOC(fe);
555 556 557

			fe->filter = fdef->filter;
			fe->filter_name = fdef->filter_name;
558 559 560 561
			fe->payload = payload;
		}
	}

562 563
	git_rwlock_rdunlock(&filter_registry.lock);

564 565 566 567 568 569 570 571 572 573
	if (error && fl != NULL) {
		git_array_clear(fl->filters);
		git__free(fl);
		fl = NULL;
	}

	*filters = fl;
	return error;
}

574 575 576 577 578 579
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,
580
	uint32_t flags)
581
{
582 583 584 585 586 587
	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);
588 589
}

590 591 592 593 594 595 596 597 598 599 600
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);
601 602
	}

603 604
	git_array_clear(fl->filters);
	git__free(fl);
605 606
}

607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
int git_filter_list_contains(
	git_filter_list *fl,
	const char *name)
{
	size_t i;

	assert(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;
}

626 627 628 629 630
int git_filter_list_push(
	git_filter_list *fl, git_filter *filter, void *payload)
{
	int error = 0;
	size_t pos;
631
	git_filter_def *fdef = NULL;
632 633 634 635
	git_filter_entry *fe;

	assert(fl && filter);

636 637 638 639 640
	if (git_rwlock_rdlock(&filter_registry.lock) < 0) {
		giterr_set(GITERR_OS, "failed to lock filter registry");
		return -1;
	}

641
	if (git_vector_search2(
642 643 644 645 646 647 648
			&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) {
649
		giterr_set(GITERR_FILTER, "cannot use an unregistered filter");
650 651 652 653 654 655 656 657 658 659 660 661 662 663
		return -1;
	}

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

	fe = git_array_alloc(fl->filters);
	GITERR_CHECK_ALLOC(fe);
	fe->filter  = filter;
	fe->payload = payload;

	return 0;
}

Russell Belfer committed
664 665 666 667 668
size_t git_filter_list_length(const git_filter_list *fl)
{
	return fl ? git_array_size(fl->filters) : 0;
}

669
struct buf_stream {
670
	git_writestream parent;
671 672 673 674 675
	git_buf *target;
	bool complete;
};

static int buf_stream_write(
676
	git_writestream *s, const char *buffer, size_t len)
677
{
678 679
	struct buf_stream *buf_stream = (struct buf_stream *)s;
	assert(buf_stream);
680

681
	assert(buf_stream->complete == 0);
682

683 684
	return git_buf_put(buf_stream->target, buffer, len);
}
685

686
static int buf_stream_close(git_writestream *s)
687 688 689
{
	struct buf_stream *buf_stream = (struct buf_stream *)s;
	assert(buf_stream);
690

691 692
	assert(buf_stream->complete == 0);
	buf_stream->complete = 1;
693

694 695
	return 0;
}
696

697
static void buf_stream_free(git_writestream *s)
698 699 700
{
	GIT_UNUSED(s);
}
701

702 703 704
static void buf_stream_init(struct buf_stream *writer, git_buf *target)
{
	memset(writer, 0, sizeof(struct buf_stream));
705

706 707 708
	writer->parent.write = buf_stream_write;
	writer->parent.close = buf_stream_close;
	writer->parent.free = buf_stream_free;
709
	writer->target = target;
710

711 712
	git_buf_clear(target);
}
713

714 715 716 717 718 719 720 721 722
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);

723 724 725 726
	if (!filters) {
		git_buf_attach_notowned(tgt, src->ptr, src->size);
		return 0;
	}
727 728 729 730

	buf_stream_init(&writer, tgt);

	if ((error = git_filter_list_stream_data(filters, src,
Leo Yang committed
731
		&writer.parent)) < 0)
732 733 734
			return error;

	assert(writer.complete);
735
	return error;
736
}
737 738

int git_filter_list_apply_to_file(
739
	git_buf *out,
740 741 742 743
	git_filter_list *filters,
	git_repository *repo,
	const char *path)
{
744
	struct buf_stream writer;
745 746
	int error;

747
	buf_stream_init(&writer, out);
748

749
	if ((error = git_filter_list_stream_file(
Leo Yang committed
750
		filters, repo, path, &writer.parent)) < 0)
751
			return error;
752

753
	assert(writer.complete);
754 755 756
	return error;
}

757 758 759 760 761
static int buf_from_blob(git_buf *out, git_blob *blob)
{
	git_off_t rawsize = git_blob_rawsize(blob);

	if (!git__is_sizet(rawsize)) {
762
		giterr_set(GITERR_OS, "blob is too large to filter");
763 764 765
		return -1;
	}

766
	git_buf_attach_notowned(out, git_blob_rawcontent(blob), (size_t)rawsize);
767 768 769
	return 0;
}

770
int git_filter_list_apply_to_blob(
771
	git_buf *out,
772 773 774
	git_filter_list *filters,
	git_blob *blob)
{
775 776
	struct buf_stream writer;
	int error;
777

778
	buf_stream_init(&writer, out);
779

780
	if ((error = git_filter_list_stream_blob(
Leo Yang committed
781
		filters, blob, &writer.parent)) < 0)
782
			return error;
783

784 785
	assert(writer.complete);
	return error;
786 787 788
}

struct proxy_stream {
789
	git_writestream parent;
790 791 792 793
	git_filter *filter;
	const git_filter_source *source;
	void **payload;
	git_buf input;
794 795
	git_buf temp_buf;
	git_buf *output;
796
	git_writestream *target;
797 798 799
};

static int proxy_stream_write(
800
	git_writestream *s, const char *buffer, size_t len)
801 802 803 804 805 806 807
{
	struct proxy_stream *proxy_stream = (struct proxy_stream *)s;
	assert(proxy_stream);

	return git_buf_put(&proxy_stream->input, buffer, len);
}

808
static int proxy_stream_close(git_writestream *s)
809 810 811 812 813 814 815 816 817 818
{
	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,
819
		proxy_stream->output,
820 821 822 823 824 825
		&proxy_stream->input,
		proxy_stream->source);

	if (error == GIT_PASSTHROUGH) {
		writebuf = &proxy_stream->input;
	} else if (error == 0) {
826 827
		git_buf_sanitize(proxy_stream->output);
		writebuf = proxy_stream->output;
828 829 830 831 832 833 834 835 836 837 838
	} 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;
}

839
static void proxy_stream_free(git_writestream *s)
840 841 842 843
{
	struct proxy_stream *proxy_stream = (struct proxy_stream *)s;
	assert(proxy_stream);

844 845
	git_buf_dispose(&proxy_stream->input);
	git_buf_dispose(&proxy_stream->temp_buf);
846 847 848 849
	git__free(proxy_stream);
}

static int proxy_stream_init(
850
	git_writestream **out,
851
	git_filter *filter,
852
	git_buf *temp_buf,
853 854
	void **payload,
	const git_filter_source *source,
855
	git_writestream *target)
856 857 858 859
{
	struct proxy_stream *proxy_stream = git__calloc(1, sizeof(struct proxy_stream));
	GITERR_CHECK_ALLOC(proxy_stream);

860 861 862
	proxy_stream->parent.write = proxy_stream_write;
	proxy_stream->parent.close = proxy_stream_close;
	proxy_stream->parent.free = proxy_stream_free;
863 864 865 866
	proxy_stream->filter = filter;
	proxy_stream->payload = payload;
	proxy_stream->source = source;
	proxy_stream->target = target;
867
	proxy_stream->output = temp_buf ? temp_buf : &proxy_stream->temp_buf;
868

869 870 871
	if (temp_buf)
		git_buf_clear(temp_buf);

872
	*out = (git_writestream *)proxy_stream;
873 874 875 876
	return 0;
}

static int stream_list_init(
877
	git_writestream **out,
878 879
	git_vector *streams,
	git_filter_list *filters,
880
	git_writestream *target)
881
{
882
	git_writestream *last_stream = target;
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
	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);
898
		git_writestream *filter_stream;
899

900 901
		assert(fe->filter->stream || fe->filter->apply);

902 903 904
		/* If necessary, create a stream that proxies the traditional
		 * application.
		 */
905 906
		if (fe->filter->stream)
			error = fe->filter->stream(&filter_stream, fe->filter,
907
				&fe->payload, &filters->source, last_stream);
908 909 910 911 912
		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);
913

914
		if (error < 0)
915
			goto out;
916 917

		git_vector_insert(streams, filter_stream);
918
		last_stream = filter_stream;
919 920
	}

921 922 923 924 925 926 927
out:
	if (error)
		last_stream->close(last_stream);
	else
		*out = last_stream;

	return error;
928 929 930 931
}

void stream_list_free(git_vector *streams)
{
932
	git_writestream *stream;
933 934 935 936
	size_t i;

	git_vector_foreach(streams, i, stream)
		stream->free(stream);
937
	git_vector_free(streams);
938 939 940 941 942 943
}

int git_filter_list_stream_file(
	git_filter_list *filters,
	git_repository *repo,
	const char *path,
944
	git_writestream *target)
945
{
946
	char buf[FILTERIO_BUFSIZE];
947
	git_buf abspath = GIT_BUF_INIT;
948 949
	const char *base = repo ? git_repository_workdir(repo) : NULL;
	git_vector filter_streams = GIT_VECTOR_INIT;
950
	git_writestream *stream_start;
951
	ssize_t readlen;
952
	int fd = -1, error, initialized = 0;
953 954 955 956 957

	if ((error = stream_list_init(
			&stream_start, &filter_streams, filters, target)) < 0 ||
		(error = git_path_join_unrooted(&abspath, path, base, NULL)) < 0)
		goto done;
958
	initialized = 1;
959

960
	if ((fd = git_futils_open_ro(abspath.ptr)) < 0) {
961 962 963 964
		error = fd;
		goto done;
	}

965
	while ((readlen = p_read(fd, buf, sizeof(buf))) > 0) {
966
		if ((error = stream_start->write(stream_start, buf, readlen)) < 0)
967 968 969
			goto done;
	}

970
	if (readlen < 0)
971 972 973
		error = readlen;

done:
974 975 976
	if (initialized)
		error |= stream_start->close(stream_start);

977 978
	if (fd >= 0)
		p_close(fd);
979
	stream_list_free(&filter_streams);
980
	git_buf_dispose(&abspath);
981 982 983 984 985 986
	return error;
}

int git_filter_list_stream_data(
	git_filter_list *filters,
	git_buf *data,
987
	git_writestream *target)
988 989
{
	git_vector filter_streams = GIT_VECTOR_INIT;
990
	git_writestream *stream_start;
991
	int error, initialized = 0;
992

993 994
	git_buf_sanitize(data);

995 996
	if ((error = stream_list_init(&stream_start, &filter_streams, filters, target)) < 0)
		goto out;
997
	initialized = 1;
998

999 1000 1001
	if ((error = stream_start->write(
			stream_start, data->ptr, data->size)) < 0)
		goto out;
1002 1003

out:
1004 1005 1006
	if (initialized)
		error |= stream_start->close(stream_start);

1007
	stream_list_free(&filter_streams);
1008
	return error;
1009 1010 1011 1012 1013
}

int git_filter_list_stream_blob(
	git_filter_list *filters,
	git_blob *blob,
1014
	git_writestream *target)
1015 1016 1017 1018 1019
{
	git_buf in = GIT_BUF_INIT;

	if (buf_from_blob(&in, blob) < 0)
		return -1;
1020

Russell Belfer committed
1021 1022 1023
	if (filters)
		git_oid_cpy(&filters->source.oid, git_blob_id(blob));

1024
	return git_filter_list_stream_data(filters, &in, target);
1025
}
1026 1027 1028 1029 1030 1031

int git_filter_init(git_filter *filter, unsigned int version)
{
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(filter, version, git_filter, GIT_FILTER_INIT);
	return 0;
}