git

1
/*
2
 * apply.c
3
 *
4
 * Copyright (C) Linus Torvalds, 2005
5
 *
6
 * This applies patches on top of some (arbitrary) version of the SCM.
7
 *
8
 */
9

10
#define USE_THE_REPOSITORY_VARIABLE
11

12
#include "git-compat-util.h"
13
#include "abspath.h"
14
#include "base85.h"
15
#include "config.h"
16
#include "object-store-ll.h"
17
#include "delta.h"
18
#include "diff.h"
19
#include "dir.h"
20
#include "environment.h"
21
#include "gettext.h"
22
#include "hex.h"
23
#include "xdiff-interface.h"
24
#include "merge-ll.h"
25
#include "lockfile.h"
26
#include "name-hash.h"
27
#include "object-name.h"
28
#include "object-file.h"
29
#include "parse-options.h"
30
#include "path.h"
31
#include "quote.h"
32
#include "read-cache.h"
33
#include "rerere.h"
34
#include "apply.h"
35
#include "entry.h"
36
#include "setup.h"
37
#include "symlinks.h"
38
#include "wildmatch.h"
39
#include "ws.h"
40

41
struct gitdiff_data {
42
	struct strbuf *root;
43
	int linenr;
44
	int p_value;
45
};
46

47
static void git_apply_config(void)
48
{
49
	git_config_get_string("apply.whitespace", &apply_default_whitespace);
50
	git_config_get_string("apply.ignorewhitespace", &apply_default_ignorewhitespace);
51
	git_config(git_xmerge_config, NULL);
52
}
53

54
static int parse_whitespace_option(struct apply_state *state, const char *option)
55
{
56
	if (!option) {
57
		state->ws_error_action = warn_on_ws_error;
58
		return 0;
59
	}
60
	if (!strcmp(option, "warn")) {
61
		state->ws_error_action = warn_on_ws_error;
62
		return 0;
63
	}
64
	if (!strcmp(option, "nowarn")) {
65
		state->ws_error_action = nowarn_ws_error;
66
		return 0;
67
	}
68
	if (!strcmp(option, "error")) {
69
		state->ws_error_action = die_on_ws_error;
70
		return 0;
71
	}
72
	if (!strcmp(option, "error-all")) {
73
		state->ws_error_action = die_on_ws_error;
74
		state->squelch_whitespace_errors = 0;
75
		return 0;
76
	}
77
	if (!strcmp(option, "strip") || !strcmp(option, "fix")) {
78
		state->ws_error_action = correct_ws_error;
79
		return 0;
80
	}
81
	/*
82
	 * Please update $__git_whitespacelist in git-completion.bash,
83
	 * Documentation/git-apply.txt, and Documentation/git-am.txt
84
	 * when you add new options.
85
	 */
86
	return error(_("unrecognized whitespace option '%s'"), option);
87
}
88

89
static int parse_ignorewhitespace_option(struct apply_state *state,
90
						 const char *option)
91
{
92
	if (!option || !strcmp(option, "no") ||
93
	    !strcmp(option, "false") || !strcmp(option, "never") ||
94
	    !strcmp(option, "none")) {
95
		state->ws_ignore_action = ignore_ws_none;
96
		return 0;
97
	}
98
	if (!strcmp(option, "change")) {
99
		state->ws_ignore_action = ignore_ws_change;
100
		return 0;
101
	}
102
	return error(_("unrecognized whitespace ignore option '%s'"), option);
103
}
104

105
int init_apply_state(struct apply_state *state,
106
		     struct repository *repo,
107
		     const char *prefix)
108
{
109
	memset(state, 0, sizeof(*state));
110
	state->prefix = prefix;
111
	state->repo = repo;
112
	state->apply = 1;
113
	state->line_termination = '\n';
114
	state->p_value = 1;
115
	state->p_context = UINT_MAX;
116
	state->squelch_whitespace_errors = 5;
117
	state->ws_error_action = warn_on_ws_error;
118
	state->ws_ignore_action = ignore_ws_none;
119
	state->linenr = 1;
120
	string_list_init_nodup(&state->fn_table);
121
	string_list_init_nodup(&state->limit_by_name);
122
	strset_init(&state->removed_symlinks);
123
	strset_init(&state->kept_symlinks);
124
	strbuf_init(&state->root, 0);
125

126
	git_apply_config();
127
	if (apply_default_whitespace && parse_whitespace_option(state, apply_default_whitespace))
128
		return -1;
129
	if (apply_default_ignorewhitespace && parse_ignorewhitespace_option(state, apply_default_ignorewhitespace))
130
		return -1;
131
	return 0;
132
}
133

134
void clear_apply_state(struct apply_state *state)
135
{
136
	string_list_clear(&state->limit_by_name, 0);
137
	strset_clear(&state->removed_symlinks);
138
	strset_clear(&state->kept_symlinks);
139
	strbuf_release(&state->root);
140
	FREE_AND_NULL(state->fake_ancestor);
141

142
	/* &state->fn_table is cleared at the end of apply_patch() */
143
}
144

145
static void mute_routine(const char *msg UNUSED, va_list params UNUSED)
146
{
147
	/* do nothing */
148
}
149

150
int check_apply_state(struct apply_state *state, int force_apply)
151
{
152
	int is_not_gitdir = !startup_info->have_repository;
153

154
	if (state->apply_with_reject && state->threeway)
155
		return error(_("options '%s' and '%s' cannot be used together"), "--reject", "--3way");
156
	if (state->threeway) {
157
		if (is_not_gitdir)
158
			return error(_("'%s' outside a repository"), "--3way");
159
		state->check_index = 1;
160
	}
161
	if (state->apply_with_reject) {
162
		state->apply = 1;
163
		if (state->apply_verbosity == verbosity_normal)
164
			state->apply_verbosity = verbosity_verbose;
165
	}
166
	if (!force_apply && (state->diffstat || state->numstat || state->summary || state->check || state->fake_ancestor))
167
		state->apply = 0;
168
	if (state->check_index && is_not_gitdir)
169
		return error(_("'%s' outside a repository"), "--index");
170
	if (state->cached) {
171
		if (is_not_gitdir)
172
			return error(_("'%s' outside a repository"), "--cached");
173
		state->check_index = 1;
174
	}
175
	if (state->ita_only && (state->check_index || is_not_gitdir))
176
		state->ita_only = 0;
177
	if (state->check_index)
178
		state->unsafe_paths = 0;
179

180
	if (state->apply_verbosity <= verbosity_silent) {
181
		state->saved_error_routine = get_error_routine();
182
		state->saved_warn_routine = get_warn_routine();
183
		set_error_routine(mute_routine);
184
		set_warn_routine(mute_routine);
185
	}
186

187
	return 0;
188
}
189

190
static void set_default_whitespace_mode(struct apply_state *state)
191
{
192
	if (!state->whitespace_option && !apply_default_whitespace)
193
		state->ws_error_action = (state->apply ? warn_on_ws_error : nowarn_ws_error);
194
}
195

196
/*
197
 * This represents one "hunk" from a patch, starting with
198
 * "@@ -oldpos,oldlines +newpos,newlines @@" marker.  The
199
 * patch text is pointed at by patch, and its byte length
200
 * is stored in size.  leading and trailing are the number
201
 * of context lines.
202
 */
203
struct fragment {
204
	unsigned long leading, trailing;
205
	unsigned long oldpos, oldlines;
206
	unsigned long newpos, newlines;
207
	/*
208
	 * 'patch' is usually borrowed from buf in apply_patch(),
209
	 * but some codepaths store an allocated buffer.
210
	 */
211
	const char *patch;
212
	unsigned free_patch:1,
213
		rejected:1;
214
	int size;
215
	int linenr;
216
	struct fragment *next;
217
};
218

219
/*
220
 * When dealing with a binary patch, we reuse "leading" field
221
 * to store the type of the binary hunk, either deflated "delta"
222
 * or deflated "literal".
223
 */
224
#define binary_patch_method leading
225
#define BINARY_DELTA_DEFLATED	1
226
#define BINARY_LITERAL_DEFLATED 2
227

228
static void free_fragment_list(struct fragment *list)
229
{
230
	while (list) {
231
		struct fragment *next = list->next;
232
		if (list->free_patch)
233
			free((char *)list->patch);
234
		free(list);
235
		list = next;
236
	}
237
}
238

239
void release_patch(struct patch *patch)
240
{
241
	free_fragment_list(patch->fragments);
242
	free(patch->def_name);
243
	free(patch->old_name);
244
	free(patch->new_name);
245
	free(patch->result);
246
}
247

248
static void free_patch(struct patch *patch)
249
{
250
	release_patch(patch);
251
	free(patch);
252
}
253

254
static void free_patch_list(struct patch *list)
255
{
256
	while (list) {
257
		struct patch *next = list->next;
258
		free_patch(list);
259
		list = next;
260
	}
261
}
262

263
/*
264
 * A line in a file, len-bytes long (includes the terminating LF,
265
 * except for an incomplete line at the end if the file ends with
266
 * one), and its contents hashes to 'hash'.
267
 */
268
struct line {
269
	size_t len;
270
	unsigned hash : 24;
271
	unsigned flag : 8;
272
#define LINE_COMMON     1
273
#define LINE_PATCHED	2
274
};
275

276
/*
277
 * This represents a "file", which is an array of "lines".
278
 */
279
struct image {
280
	char *buf;
281
	size_t len;
282
	size_t nr;
283
	size_t alloc;
284
	struct line *line_allocated;
285
	struct line *line;
286
};
287

288
static uint32_t hash_line(const char *cp, size_t len)
289
{
290
	size_t i;
291
	uint32_t h;
292
	for (i = 0, h = 0; i < len; i++) {
293
		if (!isspace(cp[i])) {
294
			h = h * 3 + (cp[i] & 0xff);
295
		}
296
	}
297
	return h;
298
}
299

300
/*
301
 * Compare lines s1 of length n1 and s2 of length n2, ignoring
302
 * whitespace difference. Returns 1 if they match, 0 otherwise
303
 */
304
static int fuzzy_matchlines(const char *s1, size_t n1,
305
			    const char *s2, size_t n2)
306
{
307
	const char *end1 = s1 + n1;
308
	const char *end2 = s2 + n2;
309

310
	/* ignore line endings */
311
	while (s1 < end1 && (end1[-1] == '\r' || end1[-1] == '\n'))
312
		end1--;
313
	while (s2 < end2 && (end2[-1] == '\r' || end2[-1] == '\n'))
314
		end2--;
315

316
	while (s1 < end1 && s2 < end2) {
317
		if (isspace(*s1)) {
318
			/*
319
			 * Skip whitespace. We check on both buffers
320
			 * because we don't want "a b" to match "ab".
321
			 */
322
			if (!isspace(*s2))
323
				return 0;
324
			while (s1 < end1 && isspace(*s1))
325
				s1++;
326
			while (s2 < end2 && isspace(*s2))
327
				s2++;
328
		} else if (*s1++ != *s2++)
329
			return 0;
330
	}
331

332
	/* If we reached the end on one side only, lines don't match. */
333
	return s1 == end1 && s2 == end2;
334
}
335

336
static void add_line_info(struct image *img, const char *bol, size_t len, unsigned flag)
337
{
338
	ALLOC_GROW(img->line_allocated, img->nr + 1, img->alloc);
339
	img->line_allocated[img->nr].len = len;
340
	img->line_allocated[img->nr].hash = hash_line(bol, len);
341
	img->line_allocated[img->nr].flag = flag;
342
	img->nr++;
343
}
344

345
/*
346
 * "buf" has the file contents to be patched (read from various sources).
347
 * attach it to "image" and add line-based index to it.
348
 * "image" now owns the "buf".
349
 */
350
static void prepare_image(struct image *image, char *buf, size_t len,
351
			  int prepare_linetable)
352
{
353
	const char *cp, *ep;
354

355
	memset(image, 0, sizeof(*image));
356
	image->buf = buf;
357
	image->len = len;
358

359
	if (!prepare_linetable)
360
		return;
361

362
	ep = image->buf + image->len;
363
	cp = image->buf;
364
	while (cp < ep) {
365
		const char *next;
366
		for (next = cp; next < ep && *next != '\n'; next++)
367
			;
368
		if (next < ep)
369
			next++;
370
		add_line_info(image, cp, next - cp, 0);
371
		cp = next;
372
	}
373
	image->line = image->line_allocated;
374
}
375

376
static void clear_image(struct image *image)
377
{
378
	free(image->buf);
379
	free(image->line_allocated);
380
	memset(image, 0, sizeof(*image));
381
}
382

383
/* fmt must contain _one_ %s and no other substitution */
384
static void say_patch_name(FILE *output, const char *fmt, struct patch *patch)
385
{
386
	struct strbuf sb = STRBUF_INIT;
387

388
	if (patch->old_name && patch->new_name &&
389
	    strcmp(patch->old_name, patch->new_name)) {
390
		quote_c_style(patch->old_name, &sb, NULL, 0);
391
		strbuf_addstr(&sb, " => ");
392
		quote_c_style(patch->new_name, &sb, NULL, 0);
393
	} else {
394
		const char *n = patch->new_name;
395
		if (!n)
396
			n = patch->old_name;
397
		quote_c_style(n, &sb, NULL, 0);
398
	}
399
	fprintf(output, fmt, sb.buf);
400
	fputc('\n', output);
401
	strbuf_release(&sb);
402
}
403

404
#define SLOP (16)
405

406
/*
407
 * apply.c isn't equipped to handle arbitrarily large patches, because
408
 * it intermingles `unsigned long` with `int` for the type used to store
409
 * buffer lengths.
410
 *
411
 * Only process patches that are just shy of 1 GiB large in order to
412
 * avoid any truncation or overflow issues.
413
 */
414
#define MAX_APPLY_SIZE (1024UL * 1024 * 1023)
415

416
static int read_patch_file(struct strbuf *sb, int fd)
417
{
418
	if (strbuf_read(sb, fd, 0) < 0)
419
		return error_errno(_("failed to read patch"));
420
	else if (sb->len >= MAX_APPLY_SIZE)
421
		return error(_("patch too large"));
422
	/*
423
	 * Make sure that we have some slop in the buffer
424
	 * so that we can do speculative "memcmp" etc, and
425
	 * see to it that it is NUL-filled.
426
	 */
427
	strbuf_grow(sb, SLOP);
428
	memset(sb->buf + sb->len, 0, SLOP);
429
	return 0;
430
}
431

432
static unsigned long linelen(const char *buffer, unsigned long size)
433
{
434
	unsigned long len = 0;
435
	while (size--) {
436
		len++;
437
		if (*buffer++ == '\n')
438
			break;
439
	}
440
	return len;
441
}
442

443
static int is_dev_null(const char *str)
444
{
445
	return skip_prefix(str, "/dev/null", &str) && isspace(*str);
446
}
447

448
#define TERM_SPACE	1
449
#define TERM_TAB	2
450

451
static int name_terminate(int c, int terminate)
452
{
453
	if (c == ' ' && !(terminate & TERM_SPACE))
454
		return 0;
455
	if (c == '\t' && !(terminate & TERM_TAB))
456
		return 0;
457

458
	return 1;
459
}
460

461
/* remove double slashes to make --index work with such filenames */
462
static char *squash_slash(char *name)
463
{
464
	int i = 0, j = 0;
465

466
	if (!name)
467
		return NULL;
468

469
	while (name[i]) {
470
		if ((name[j++] = name[i++]) == '/')
471
			while (name[i] == '/')
472
				i++;
473
	}
474
	name[j] = '\0';
475
	return name;
476
}
477

478
static char *find_name_gnu(struct strbuf *root,
479
			   const char *line,
480
			   int p_value)
481
{
482
	struct strbuf name = STRBUF_INIT;
483
	char *cp;
484

485
	/*
486
	 * Proposed "new-style" GNU patch/diff format; see
487
	 * https://lore.kernel.org/git/7vll0wvb2a.fsf@assigned-by-dhcp.cox.net/
488
	 */
489
	if (unquote_c_style(&name, line, NULL)) {
490
		strbuf_release(&name);
491
		return NULL;
492
	}
493

494
	for (cp = name.buf; p_value; p_value--) {
495
		cp = strchr(cp, '/');
496
		if (!cp) {
497
			strbuf_release(&name);
498
			return NULL;
499
		}
500
		cp++;
501
	}
502

503
	strbuf_remove(&name, 0, cp - name.buf);
504
	if (root->len)
505
		strbuf_insert(&name, 0, root->buf, root->len);
506
	return squash_slash(strbuf_detach(&name, NULL));
507
}
508

509
static size_t sane_tz_len(const char *line, size_t len)
510
{
511
	const char *tz, *p;
512

513
	if (len < strlen(" +0500") || line[len-strlen(" +0500")] != ' ')
514
		return 0;
515
	tz = line + len - strlen(" +0500");
516

517
	if (tz[1] != '+' && tz[1] != '-')
518
		return 0;
519

520
	for (p = tz + 2; p != line + len; p++)
521
		if (!isdigit(*p))
522
			return 0;
523

524
	return line + len - tz;
525
}
526

527
static size_t tz_with_colon_len(const char *line, size_t len)
528
{
529
	const char *tz, *p;
530

531
	if (len < strlen(" +08:00") || line[len - strlen(":00")] != ':')
532
		return 0;
533
	tz = line + len - strlen(" +08:00");
534

535
	if (tz[0] != ' ' || (tz[1] != '+' && tz[1] != '-'))
536
		return 0;
537
	p = tz + 2;
538
	if (!isdigit(*p++) || !isdigit(*p++) || *p++ != ':' ||
539
	    !isdigit(*p++) || !isdigit(*p++))
540
		return 0;
541

542
	return line + len - tz;
543
}
544

545
static size_t date_len(const char *line, size_t len)
546
{
547
	const char *date, *p;
548

549
	if (len < strlen("72-02-05") || line[len-strlen("-05")] != '-')
550
		return 0;
551
	p = date = line + len - strlen("72-02-05");
552

553
	if (!isdigit(*p++) || !isdigit(*p++) || *p++ != '-' ||
554
	    !isdigit(*p++) || !isdigit(*p++) || *p++ != '-' ||
555
	    !isdigit(*p++) || !isdigit(*p++))	/* Not a date. */
556
		return 0;
557

558
	if (date - line >= strlen("19") &&
559
	    isdigit(date[-1]) && isdigit(date[-2]))	/* 4-digit year */
560
		date -= strlen("19");
561

562
	return line + len - date;
563
}
564

565
static size_t short_time_len(const char *line, size_t len)
566
{
567
	const char *time, *p;
568

569
	if (len < strlen(" 07:01:32") || line[len-strlen(":32")] != ':')
570
		return 0;
571
	p = time = line + len - strlen(" 07:01:32");
572

573
	/* Permit 1-digit hours? */
574
	if (*p++ != ' ' ||
575
	    !isdigit(*p++) || !isdigit(*p++) || *p++ != ':' ||
576
	    !isdigit(*p++) || !isdigit(*p++) || *p++ != ':' ||
577
	    !isdigit(*p++) || !isdigit(*p++))	/* Not a time. */
578
		return 0;
579

580
	return line + len - time;
581
}
582

583
static size_t fractional_time_len(const char *line, size_t len)
584
{
585
	const char *p;
586
	size_t n;
587

588
	/* Expected format: 19:41:17.620000023 */
589
	if (!len || !isdigit(line[len - 1]))
590
		return 0;
591
	p = line + len - 1;
592

593
	/* Fractional seconds. */
594
	while (p > line && isdigit(*p))
595
		p--;
596
	if (*p != '.')
597
		return 0;
598

599
	/* Hours, minutes, and whole seconds. */
600
	n = short_time_len(line, p - line);
601
	if (!n)
602
		return 0;
603

604
	return line + len - p + n;
605
}
606

607
static size_t trailing_spaces_len(const char *line, size_t len)
608
{
609
	const char *p;
610

611
	/* Expected format: ' ' x (1 or more)  */
612
	if (!len || line[len - 1] != ' ')
613
		return 0;
614

615
	p = line + len;
616
	while (p != line) {
617
		p--;
618
		if (*p != ' ')
619
			return line + len - (p + 1);
620
	}
621

622
	/* All spaces! */
623
	return len;
624
}
625

626
static size_t diff_timestamp_len(const char *line, size_t len)
627
{
628
	const char *end = line + len;
629
	size_t n;
630

631
	/*
632
	 * Posix: 2010-07-05 19:41:17
633
	 * GNU: 2010-07-05 19:41:17.620000023 -0500
634
	 */
635

636
	if (!isdigit(end[-1]))
637
		return 0;
638

639
	n = sane_tz_len(line, end - line);
640
	if (!n)
641
		n = tz_with_colon_len(line, end - line);
642
	end -= n;
643

644
	n = short_time_len(line, end - line);
645
	if (!n)
646
		n = fractional_time_len(line, end - line);
647
	end -= n;
648

649
	n = date_len(line, end - line);
650
	if (!n)	/* No date.  Too bad. */
651
		return 0;
652
	end -= n;
653

654
	if (end == line)	/* No space before date. */
655
		return 0;
656
	if (end[-1] == '\t') {	/* Success! */
657
		end--;
658
		return line + len - end;
659
	}
660
	if (end[-1] != ' ')	/* No space before date. */
661
		return 0;
662

663
	/* Whitespace damage. */
664
	end -= trailing_spaces_len(line, end - line);
665
	return line + len - end;
666
}
667

668
static char *find_name_common(struct strbuf *root,
669
			      const char *line,
670
			      const char *def,
671
			      int p_value,
672
			      const char *end,
673
			      int terminate)
674
{
675
	int len;
676
	const char *start = NULL;
677

678
	if (p_value == 0)
679
		start = line;
680
	while (line != end) {
681
		char c = *line;
682

683
		if (!end && isspace(c)) {
684
			if (c == '\n')
685
				break;
686
			if (name_terminate(c, terminate))
687
				break;
688
		}
689
		line++;
690
		if (c == '/' && !--p_value)
691
			start = line;
692
	}
693
	if (!start)
694
		return squash_slash(xstrdup_or_null(def));
695
	len = line - start;
696
	if (!len)
697
		return squash_slash(xstrdup_or_null(def));
698

699
	/*
700
	 * Generally we prefer the shorter name, especially
701
	 * if the other one is just a variation of that with
702
	 * something else tacked on to the end (ie "file.orig"
703
	 * or "file~").
704
	 */
705
	if (def) {
706
		int deflen = strlen(def);
707
		if (deflen < len && !strncmp(start, def, deflen))
708
			return squash_slash(xstrdup(def));
709
	}
710

711
	if (root->len) {
712
		char *ret = xstrfmt("%s%.*s", root->buf, len, start);
713
		return squash_slash(ret);
714
	}
715

716
	return squash_slash(xmemdupz(start, len));
717
}
718

719
static char *find_name(struct strbuf *root,
720
		       const char *line,
721
		       char *def,
722
		       int p_value,
723
		       int terminate)
724
{
725
	if (*line == '"') {
726
		char *name = find_name_gnu(root, line, p_value);
727
		if (name)
728
			return name;
729
	}
730

731
	return find_name_common(root, line, def, p_value, NULL, terminate);
732
}
733

734
static char *find_name_traditional(struct strbuf *root,
735
				   const char *line,
736
				   char *def,
737
				   int p_value)
738
{
739
	size_t len;
740
	size_t date_len;
741

742
	if (*line == '"') {
743
		char *name = find_name_gnu(root, line, p_value);
744
		if (name)
745
			return name;
746
	}
747

748
	len = strchrnul(line, '\n') - line;
749
	date_len = diff_timestamp_len(line, len);
750
	if (!date_len)
751
		return find_name_common(root, line, def, p_value, NULL, TERM_TAB);
752
	len -= date_len;
753

754
	return find_name_common(root, line, def, p_value, line + len, 0);
755
}
756

757
/*
758
 * Given the string after "--- " or "+++ ", guess the appropriate
759
 * p_value for the given patch.
760
 */
761
static int guess_p_value(struct apply_state *state, const char *nameline)
762
{
763
	char *name, *cp;
764
	int val = -1;
765

766
	if (is_dev_null(nameline))
767
		return -1;
768
	name = find_name_traditional(&state->root, nameline, NULL, 0);
769
	if (!name)
770
		return -1;
771
	cp = strchr(name, '/');
772
	if (!cp)
773
		val = 0;
774
	else if (state->prefix) {
775
		/*
776
		 * Does it begin with "a/$our-prefix" and such?  Then this is
777
		 * very likely to apply to our directory.
778
		 */
779
		if (starts_with(name, state->prefix))
780
			val = count_slashes(state->prefix);
781
		else {
782
			cp++;
783
			if (starts_with(cp, state->prefix))
784
				val = count_slashes(state->prefix) + 1;
785
		}
786
	}
787
	free(name);
788
	return val;
789
}
790

791
/*
792
 * Does the ---/+++ line have the POSIX timestamp after the last HT?
793
 * GNU diff puts epoch there to signal a creation/deletion event.  Is
794
 * this such a timestamp?
795
 */
796
static int has_epoch_timestamp(const char *nameline)
797
{
798
	/*
799
	 * We are only interested in epoch timestamp; any non-zero
800
	 * fraction cannot be one, hence "(\.0+)?" in the regexp below.
801
	 * For the same reason, the date must be either 1969-12-31 or
802
	 * 1970-01-01, and the seconds part must be "00".
803
	 */
804
	const char stamp_regexp[] =
805
		"^[0-2][0-9]:([0-5][0-9]):00(\\.0+)?"
806
		" "
807
		"([-+][0-2][0-9]:?[0-5][0-9])\n";
808
	const char *timestamp = NULL, *cp, *colon;
809
	static regex_t *stamp;
810
	regmatch_t m[10];
811
	int zoneoffset, epoch_hour, hour, minute;
812
	int status;
813

814
	for (cp = nameline; *cp != '\n'; cp++) {
815
		if (*cp == '\t')
816
			timestamp = cp + 1;
817
	}
818
	if (!timestamp)
819
		return 0;
820

821
	/*
822
	 * YYYY-MM-DD hh:mm:ss must be from either 1969-12-31
823
	 * (west of GMT) or 1970-01-01 (east of GMT)
824
	 */
825
	if (skip_prefix(timestamp, "1969-12-31 ", &timestamp))
826
		epoch_hour = 24;
827
	else if (skip_prefix(timestamp, "1970-01-01 ", &timestamp))
828
		epoch_hour = 0;
829
	else
830
		return 0;
831

832
	if (!stamp) {
833
		stamp = xmalloc(sizeof(*stamp));
834
		if (regcomp(stamp, stamp_regexp, REG_EXTENDED)) {
835
			warning(_("Cannot prepare timestamp regexp %s"),
836
				stamp_regexp);
837
			return 0;
838
		}
839
	}
840

841
	status = regexec(stamp, timestamp, ARRAY_SIZE(m), m, 0);
842
	if (status) {
843
		if (status != REG_NOMATCH)
844
			warning(_("regexec returned %d for input: %s"),
845
				status, timestamp);
846
		return 0;
847
	}
848

849
	hour = strtol(timestamp, NULL, 10);
850
	minute = strtol(timestamp + m[1].rm_so, NULL, 10);
851

852
	zoneoffset = strtol(timestamp + m[3].rm_so + 1, (char **) &colon, 10);
853
	if (*colon == ':')
854
		zoneoffset = zoneoffset * 60 + strtol(colon + 1, NULL, 10);
855
	else
856
		zoneoffset = (zoneoffset / 100) * 60 + (zoneoffset % 100);
857
	if (timestamp[m[3].rm_so] == '-')
858
		zoneoffset = -zoneoffset;
859

860
	return hour * 60 + minute - zoneoffset == epoch_hour * 60;
861
}
862

863
/*
864
 * Get the name etc info from the ---/+++ lines of a traditional patch header
865
 *
866
 * FIXME! The end-of-filename heuristics are kind of screwy. For existing
867
 * files, we can happily check the index for a match, but for creating a
868
 * new file we should try to match whatever "patch" does. I have no idea.
869
 */
870
static int parse_traditional_patch(struct apply_state *state,
871
				   const char *first,
872
				   const char *second,
873
				   struct patch *patch)
874
{
875
	char *name;
876

877
	first += 4;	/* skip "--- " */
878
	second += 4;	/* skip "+++ " */
879
	if (!state->p_value_known) {
880
		int p, q;
881
		p = guess_p_value(state, first);
882
		q = guess_p_value(state, second);
883
		if (p < 0) p = q;
884
		if (0 <= p && p == q) {
885
			state->p_value = p;
886
			state->p_value_known = 1;
887
		}
888
	}
889
	if (is_dev_null(first)) {
890
		patch->is_new = 1;
891
		patch->is_delete = 0;
892
		name = find_name_traditional(&state->root, second, NULL, state->p_value);
893
		patch->new_name = name;
894
	} else if (is_dev_null(second)) {
895
		patch->is_new = 0;
896
		patch->is_delete = 1;
897
		name = find_name_traditional(&state->root, first, NULL, state->p_value);
898
		patch->old_name = name;
899
	} else {
900
		char *first_name;
901
		first_name = find_name_traditional(&state->root, first, NULL, state->p_value);
902
		name = find_name_traditional(&state->root, second, first_name, state->p_value);
903
		free(first_name);
904
		if (has_epoch_timestamp(first)) {
905
			patch->is_new = 1;
906
			patch->is_delete = 0;
907
			patch->new_name = name;
908
		} else if (has_epoch_timestamp(second)) {
909
			patch->is_new = 0;
910
			patch->is_delete = 1;
911
			patch->old_name = name;
912
		} else {
913
			patch->old_name = name;
914
			patch->new_name = xstrdup_or_null(name);
915
		}
916
	}
917
	if (!name)
918
		return error(_("unable to find filename in patch at line %d"), state->linenr);
919

920
	return 0;
921
}
922

923
static int gitdiff_hdrend(struct gitdiff_data *state UNUSED,
924
			  const char *line UNUSED,
925
			  struct patch *patch UNUSED)
926
{
927
	return 1;
928
}
929

930
/*
931
 * We're anal about diff header consistency, to make
932
 * sure that we don't end up having strange ambiguous
933
 * patches floating around.
934
 *
935
 * As a result, gitdiff_{old|new}name() will check
936
 * their names against any previous information, just
937
 * to make sure..
938
 */
939
#define DIFF_OLD_NAME 0
940
#define DIFF_NEW_NAME 1
941

942
static int gitdiff_verify_name(struct gitdiff_data *state,
943
			       const char *line,
944
			       int isnull,
945
			       char **name,
946
			       int side)
947
{
948
	if (!*name && !isnull) {
949
		*name = find_name(state->root, line, NULL, state->p_value, TERM_TAB);
950
		return 0;
951
	}
952

953
	if (*name) {
954
		char *another;
955
		if (isnull)
956
			return error(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"),
957
				     *name, state->linenr);
958
		another = find_name(state->root, line, NULL, state->p_value, TERM_TAB);
959
		if (!another || strcmp(another, *name)) {
960
			free(another);
961
			return error((side == DIFF_NEW_NAME) ?
962
			    _("git apply: bad git-diff - inconsistent new filename on line %d") :
963
			    _("git apply: bad git-diff - inconsistent old filename on line %d"), state->linenr);
964
		}
965
		free(another);
966
	} else {
967
		if (!is_dev_null(line))
968
			return error(_("git apply: bad git-diff - expected /dev/null on line %d"), state->linenr);
969
	}
970

971
	return 0;
972
}
973

974
static int gitdiff_oldname(struct gitdiff_data *state,
975
			   const char *line,
976
			   struct patch *patch)
977
{
978
	return gitdiff_verify_name(state, line,
979
				   patch->is_new, &patch->old_name,
980
				   DIFF_OLD_NAME);
981
}
982

983
static int gitdiff_newname(struct gitdiff_data *state,
984
			   const char *line,
985
			   struct patch *patch)
986
{
987
	return gitdiff_verify_name(state, line,
988
				   patch->is_delete, &patch->new_name,
989
				   DIFF_NEW_NAME);
990
}
991

992
static int parse_mode_line(const char *line, int linenr, unsigned int *mode)
993
{
994
	char *end;
995
	*mode = strtoul(line, &end, 8);
996
	if (end == line || !isspace(*end))
997
		return error(_("invalid mode on line %d: %s"), linenr, line);
998
	*mode = canon_mode(*mode);
999
	return 0;
1000
}
1001

1002
static int gitdiff_oldmode(struct gitdiff_data *state,
1003
			   const char *line,
1004
			   struct patch *patch)
1005
{
1006
	return parse_mode_line(line, state->linenr, &patch->old_mode);
1007
}
1008

1009
static int gitdiff_newmode(struct gitdiff_data *state,
1010
			   const char *line,
1011
			   struct patch *patch)
1012
{
1013
	return parse_mode_line(line, state->linenr, &patch->new_mode);
1014
}
1015

1016
static int gitdiff_delete(struct gitdiff_data *state,
1017
			  const char *line,
1018
			  struct patch *patch)
1019
{
1020
	patch->is_delete = 1;
1021
	free(patch->old_name);
1022
	patch->old_name = xstrdup_or_null(patch->def_name);
1023
	return gitdiff_oldmode(state, line, patch);
1024
}
1025

1026
static int gitdiff_newfile(struct gitdiff_data *state,
1027
			   const char *line,
1028
			   struct patch *patch)
1029
{
1030
	patch->is_new = 1;
1031
	free(patch->new_name);
1032
	patch->new_name = xstrdup_or_null(patch->def_name);
1033
	return gitdiff_newmode(state, line, patch);
1034
}
1035

1036
static int gitdiff_copysrc(struct gitdiff_data *state,
1037
			   const char *line,
1038
			   struct patch *patch)
1039
{
1040
	patch->is_copy = 1;
1041
	free(patch->old_name);
1042
	patch->old_name = find_name(state->root, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
1043
	return 0;
1044
}
1045

1046
static int gitdiff_copydst(struct gitdiff_data *state,
1047
			   const char *line,
1048
			   struct patch *patch)
1049
{
1050
	patch->is_copy = 1;
1051
	free(patch->new_name);
1052
	patch->new_name = find_name(state->root, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
1053
	return 0;
1054
}
1055

1056
static int gitdiff_renamesrc(struct gitdiff_data *state,
1057
			     const char *line,
1058
			     struct patch *patch)
1059
{
1060
	patch->is_rename = 1;
1061
	free(patch->old_name);
1062
	patch->old_name = find_name(state->root, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
1063
	return 0;
1064
}
1065

1066
static int gitdiff_renamedst(struct gitdiff_data *state,
1067
			     const char *line,
1068
			     struct patch *patch)
1069
{
1070
	patch->is_rename = 1;
1071
	free(patch->new_name);
1072
	patch->new_name = find_name(state->root, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
1073
	return 0;
1074
}
1075

1076
static int gitdiff_similarity(struct gitdiff_data *state UNUSED,
1077
			      const char *line,
1078
			      struct patch *patch)
1079
{
1080
	unsigned long val = strtoul(line, NULL, 10);
1081
	if (val <= 100)
1082
		patch->score = val;
1083
	return 0;
1084
}
1085

1086
static int gitdiff_dissimilarity(struct gitdiff_data *state UNUSED,
1087
				 const char *line,
1088
				 struct patch *patch)
1089
{
1090
	unsigned long val = strtoul(line, NULL, 10);
1091
	if (val <= 100)
1092
		patch->score = val;
1093
	return 0;
1094
}
1095

1096
static int gitdiff_index(struct gitdiff_data *state,
1097
			 const char *line,
1098
			 struct patch *patch)
1099
{
1100
	/*
1101
	 * index line is N hexadecimal, "..", N hexadecimal,
1102
	 * and optional space with octal mode.
1103
	 */
1104
	const char *ptr, *eol;
1105
	int len;
1106
	const unsigned hexsz = the_hash_algo->hexsz;
1107

1108
	ptr = strchr(line, '.');
1109
	if (!ptr || ptr[1] != '.' || hexsz < ptr - line)
1110
		return 0;
1111
	len = ptr - line;
1112
	memcpy(patch->old_oid_prefix, line, len);
1113
	patch->old_oid_prefix[len] = 0;
1114

1115
	line = ptr + 2;
1116
	ptr = strchr(line, ' ');
1117
	eol = strchrnul(line, '\n');
1118

1119
	if (!ptr || eol < ptr)
1120
		ptr = eol;
1121
	len = ptr - line;
1122

1123
	if (hexsz < len)
1124
		return 0;
1125
	memcpy(patch->new_oid_prefix, line, len);
1126
	patch->new_oid_prefix[len] = 0;
1127
	if (*ptr == ' ')
1128
		return gitdiff_oldmode(state, ptr + 1, patch);
1129
	return 0;
1130
}
1131

1132
/*
1133
 * This is normal for a diff that doesn't change anything: we'll fall through
1134
 * into the next diff. Tell the parser to break out.
1135
 */
1136
static int gitdiff_unrecognized(struct gitdiff_data *state UNUSED,
1137
				const char *line UNUSED,
1138
				struct patch *patch UNUSED)
1139
{
1140
	return 1;
1141
}
1142

1143
/*
1144
 * Skip p_value leading components from "line"; as we do not accept
1145
 * absolute paths, return NULL in that case.
1146
 */
1147
static const char *skip_tree_prefix(int p_value,
1148
				    const char *line,
1149
				    int llen)
1150
{
1151
	int nslash;
1152
	int i;
1153

1154
	if (!p_value)
1155
		return (llen && line[0] == '/') ? NULL : line;
1156

1157
	nslash = p_value;
1158
	for (i = 0; i < llen; i++) {
1159
		int ch = line[i];
1160
		if (ch == '/' && --nslash <= 0)
1161
			return (i == 0) ? NULL : &line[i + 1];
1162
	}
1163
	return NULL;
1164
}
1165

1166
/*
1167
 * This is to extract the same name that appears on "diff --git"
1168
 * line.  We do not find and return anything if it is a rename
1169
 * patch, and it is OK because we will find the name elsewhere.
1170
 * We need to reliably find name only when it is mode-change only,
1171
 * creation or deletion of an empty file.  In any of these cases,
1172
 * both sides are the same name under a/ and b/ respectively.
1173
 */
1174
static char *git_header_name(int p_value,
1175
			     const char *line,
1176
			     int llen)
1177
{
1178
	const char *name;
1179
	const char *second = NULL;
1180
	size_t len, line_len;
1181

1182
	line += strlen("diff --git ");
1183
	llen -= strlen("diff --git ");
1184

1185
	if (*line == '"') {
1186
		const char *cp;
1187
		struct strbuf first = STRBUF_INIT;
1188
		struct strbuf sp = STRBUF_INIT;
1189

1190
		if (unquote_c_style(&first, line, &second))
1191
			goto free_and_fail1;
1192

1193
		/* strip the a/b prefix including trailing slash */
1194
		cp = skip_tree_prefix(p_value, first.buf, first.len);
1195
		if (!cp)
1196
			goto free_and_fail1;
1197
		strbuf_remove(&first, 0, cp - first.buf);
1198

1199
		/*
1200
		 * second points at one past closing dq of name.
1201
		 * find the second name.
1202
		 */
1203
		while ((second < line + llen) && isspace(*second))
1204
			second++;
1205

1206
		if (line + llen <= second)
1207
			goto free_and_fail1;
1208
		if (*second == '"') {
1209
			if (unquote_c_style(&sp, second, NULL))
1210
				goto free_and_fail1;
1211
			cp = skip_tree_prefix(p_value, sp.buf, sp.len);
1212
			if (!cp)
1213
				goto free_and_fail1;
1214
			/* They must match, otherwise ignore */
1215
			if (strcmp(cp, first.buf))
1216
				goto free_and_fail1;
1217
			strbuf_release(&sp);
1218
			return strbuf_detach(&first, NULL);
1219
		}
1220

1221
		/* unquoted second */
1222
		cp = skip_tree_prefix(p_value, second, line + llen - second);
1223
		if (!cp)
1224
			goto free_and_fail1;
1225
		if (line + llen - cp != first.len ||
1226
		    memcmp(first.buf, cp, first.len))
1227
			goto free_and_fail1;
1228
		return strbuf_detach(&first, NULL);
1229

1230
	free_and_fail1:
1231
		strbuf_release(&first);
1232
		strbuf_release(&sp);
1233
		return NULL;
1234
	}
1235

1236
	/* unquoted first name */
1237
	name = skip_tree_prefix(p_value, line, llen);
1238
	if (!name)
1239
		return NULL;
1240

1241
	/*
1242
	 * since the first name is unquoted, a dq if exists must be
1243
	 * the beginning of the second name.
1244
	 */
1245
	for (second = name; second < line + llen; second++) {
1246
		if (*second == '"') {
1247
			struct strbuf sp = STRBUF_INIT;
1248
			const char *np;
1249

1250
			if (unquote_c_style(&sp, second, NULL))
1251
				goto free_and_fail2;
1252

1253
			np = skip_tree_prefix(p_value, sp.buf, sp.len);
1254
			if (!np)
1255
				goto free_and_fail2;
1256

1257
			len = sp.buf + sp.len - np;
1258
			if (len < second - name &&
1259
			    !strncmp(np, name, len) &&
1260
			    isspace(name[len])) {
1261
				/* Good */
1262
				strbuf_remove(&sp, 0, np - sp.buf);
1263
				return strbuf_detach(&sp, NULL);
1264
			}
1265

1266
		free_and_fail2:
1267
			strbuf_release(&sp);
1268
			return NULL;
1269
		}
1270
	}
1271

1272
	/*
1273
	 * Accept a name only if it shows up twice, exactly the same
1274
	 * form.
1275
	 */
1276
	second = strchr(name, '\n');
1277
	if (!second)
1278
		return NULL;
1279
	line_len = second - name;
1280
	for (len = 0 ; ; len++) {
1281
		switch (name[len]) {
1282
		default:
1283
			continue;
1284
		case '\n':
1285
			return NULL;
1286
		case '\t': case ' ':
1287
			/*
1288
			 * Is this the separator between the preimage
1289
			 * and the postimage pathname?  Again, we are
1290
			 * only interested in the case where there is
1291
			 * no rename, as this is only to set def_name
1292
			 * and a rename patch has the names elsewhere
1293
			 * in an unambiguous form.
1294
			 */
1295
			if (!name[len + 1])
1296
				return NULL; /* no postimage name */
1297
			second = skip_tree_prefix(p_value, name + len + 1,
1298
						  line_len - (len + 1));
1299
			/*
1300
			 * If we are at the SP at the end of a directory,
1301
			 * skip_tree_prefix() may return NULL as that makes
1302
			 * it appears as if we have an absolute path.
1303
			 * Keep going to find another SP.
1304
			 */
1305
			if (!second)
1306
				continue;
1307

1308
			/*
1309
			 * Does len bytes starting at "name" and "second"
1310
			 * (that are separated by one HT or SP we just
1311
			 * found) exactly match?
1312
			 */
1313
			if (second[len] == '\n' && !strncmp(name, second, len))
1314
				return xmemdupz(name, len);
1315
		}
1316
	}
1317
}
1318

1319
static int check_header_line(int linenr, struct patch *patch)
1320
{
1321
	int extensions = (patch->is_delete == 1) + (patch->is_new == 1) +
1322
			 (patch->is_rename == 1) + (patch->is_copy == 1);
1323
	if (extensions > 1)
1324
		return error(_("inconsistent header lines %d and %d"),
1325
			     patch->extension_linenr, linenr);
1326
	if (extensions && !patch->extension_linenr)
1327
		patch->extension_linenr = linenr;
1328
	return 0;
1329
}
1330

1331
int parse_git_diff_header(struct strbuf *root,
1332
			  int *linenr,
1333
			  int p_value,
1334
			  const char *line,
1335
			  int len,
1336
			  unsigned int size,
1337
			  struct patch *patch)
1338
{
1339
	unsigned long offset;
1340
	struct gitdiff_data parse_hdr_state;
1341

1342
	/* A git diff has explicit new/delete information, so we don't guess */
1343
	patch->is_new = 0;
1344
	patch->is_delete = 0;
1345

1346
	/*
1347
	 * Some things may not have the old name in the
1348
	 * rest of the headers anywhere (pure mode changes,
1349
	 * or removing or adding empty files), so we get
1350
	 * the default name from the header.
1351
	 */
1352
	patch->def_name = git_header_name(p_value, line, len);
1353
	if (patch->def_name && root->len) {
1354
		char *s = xstrfmt("%s%s", root->buf, patch->def_name);
1355
		free(patch->def_name);
1356
		patch->def_name = s;
1357
	}
1358

1359
	line += len;
1360
	size -= len;
1361
	(*linenr)++;
1362
	parse_hdr_state.root = root;
1363
	parse_hdr_state.linenr = *linenr;
1364
	parse_hdr_state.p_value = p_value;
1365

1366
	for (offset = len ; size > 0 ; offset += len, size -= len, line += len, (*linenr)++) {
1367
		static const struct opentry {
1368
			const char *str;
1369
			int (*fn)(struct gitdiff_data *, const char *, struct patch *);
1370
		} optable[] = {
1371
			{ "@@ -", gitdiff_hdrend },
1372
			{ "--- ", gitdiff_oldname },
1373
			{ "+++ ", gitdiff_newname },
1374
			{ "old mode ", gitdiff_oldmode },
1375
			{ "new mode ", gitdiff_newmode },
1376
			{ "deleted file mode ", gitdiff_delete },
1377
			{ "new file mode ", gitdiff_newfile },
1378
			{ "copy from ", gitdiff_copysrc },
1379
			{ "copy to ", gitdiff_copydst },
1380
			{ "rename old ", gitdiff_renamesrc },
1381
			{ "rename new ", gitdiff_renamedst },
1382
			{ "rename from ", gitdiff_renamesrc },
1383
			{ "rename to ", gitdiff_renamedst },
1384
			{ "similarity index ", gitdiff_similarity },
1385
			{ "dissimilarity index ", gitdiff_dissimilarity },
1386
			{ "index ", gitdiff_index },
1387
			{ "", gitdiff_unrecognized },
1388
		};
1389
		int i;
1390

1391
		len = linelen(line, size);
1392
		if (!len || line[len-1] != '\n')
1393
			break;
1394
		for (i = 0; i < ARRAY_SIZE(optable); i++) {
1395
			const struct opentry *p = optable + i;
1396
			int oplen = strlen(p->str);
1397
			int res;
1398
			if (len < oplen || memcmp(p->str, line, oplen))
1399
				continue;
1400
			res = p->fn(&parse_hdr_state, line + oplen, patch);
1401
			if (res < 0)
1402
				return -1;
1403
			if (check_header_line(*linenr, patch))
1404
				return -1;
1405
			if (res > 0)
1406
				goto done;
1407
			break;
1408
		}
1409
	}
1410

1411
done:
1412
	if (!patch->old_name && !patch->new_name) {
1413
		if (!patch->def_name) {
1414
			error(Q_("git diff header lacks filename information when removing "
1415
				 "%d leading pathname component (line %d)",
1416
				 "git diff header lacks filename information when removing "
1417
				 "%d leading pathname components (line %d)",
1418
				 parse_hdr_state.p_value),
1419
			      parse_hdr_state.p_value, *linenr);
1420
			return -128;
1421
		}
1422
		patch->old_name = xstrdup(patch->def_name);
1423
		patch->new_name = xstrdup(patch->def_name);
1424
	}
1425
	if ((!patch->new_name && !patch->is_delete) ||
1426
	    (!patch->old_name && !patch->is_new)) {
1427
		error(_("git diff header lacks filename information "
1428
			"(line %d)"), *linenr);
1429
		return -128;
1430
	}
1431
	patch->is_toplevel_relative = 1;
1432
	return offset;
1433
}
1434

1435
static int parse_num(const char *line, unsigned long *p)
1436
{
1437
	char *ptr;
1438

1439
	if (!isdigit(*line))
1440
		return 0;
1441
	*p = strtoul(line, &ptr, 10);
1442
	return ptr - line;
1443
}
1444

1445
static int parse_range(const char *line, int len, int offset, const char *expect,
1446
		       unsigned long *p1, unsigned long *p2)
1447
{
1448
	int digits, ex;
1449

1450
	if (offset < 0 || offset >= len)
1451
		return -1;
1452
	line += offset;
1453
	len -= offset;
1454

1455
	digits = parse_num(line, p1);
1456
	if (!digits)
1457
		return -1;
1458

1459
	offset += digits;
1460
	line += digits;
1461
	len -= digits;
1462

1463
	*p2 = 1;
1464
	if (*line == ',') {
1465
		digits = parse_num(line+1, p2);
1466
		if (!digits)
1467
			return -1;
1468

1469
		offset += digits+1;
1470
		line += digits+1;
1471
		len -= digits+1;
1472
	}
1473

1474
	ex = strlen(expect);
1475
	if (ex > len)
1476
		return -1;
1477
	if (memcmp(line, expect, ex))
1478
		return -1;
1479

1480
	return offset + ex;
1481
}
1482

1483
static void recount_diff(const char *line, int size, struct fragment *fragment)
1484
{
1485
	int oldlines = 0, newlines = 0, ret = 0;
1486

1487
	if (size < 1) {
1488
		warning("recount: ignore empty hunk");
1489
		return;
1490
	}
1491

1492
	for (;;) {
1493
		int len = linelen(line, size);
1494
		size -= len;
1495
		line += len;
1496

1497
		if (size < 1)
1498
			break;
1499

1500
		switch (*line) {
1501
		case ' ': case '\n':
1502
			newlines++;
1503
			/* fall through */
1504
		case '-':
1505
			oldlines++;
1506
			continue;
1507
		case '+':
1508
			newlines++;
1509
			continue;
1510
		case '\\':
1511
			continue;
1512
		case '@':
1513
			ret = size < 3 || !starts_with(line, "@@ ");
1514
			break;
1515
		case 'd':
1516
			ret = size < 5 || !starts_with(line, "diff ");
1517
			break;
1518
		default:
1519
			ret = -1;
1520
			break;
1521
		}
1522
		if (ret) {
1523
			warning(_("recount: unexpected line: %.*s"),
1524
				(int)linelen(line, size), line);
1525
			return;
1526
		}
1527
		break;
1528
	}
1529
	fragment->oldlines = oldlines;
1530
	fragment->newlines = newlines;
1531
}
1532

1533
/*
1534
 * Parse a unified diff fragment header of the
1535
 * form "@@ -a,b +c,d @@"
1536
 */
1537
static int parse_fragment_header(const char *line, int len, struct fragment *fragment)
1538
{
1539
	int offset;
1540

1541
	if (!len || line[len-1] != '\n')
1542
		return -1;
1543

1544
	/* Figure out the number of lines in a fragment */
1545
	offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);
1546
	offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);
1547

1548
	return offset;
1549
}
1550

1551
/*
1552
 * Find file diff header
1553
 *
1554
 * Returns:
1555
 *  -1 if no header was found
1556
 *  -128 in case of error
1557
 *   the size of the header in bytes (called "offset") otherwise
1558
 */
1559
static int find_header(struct apply_state *state,
1560
		       const char *line,
1561
		       unsigned long size,
1562
		       int *hdrsize,
1563
		       struct patch *patch)
1564
{
1565
	unsigned long offset, len;
1566

1567
	patch->is_toplevel_relative = 0;
1568
	patch->is_rename = patch->is_copy = 0;
1569
	patch->is_new = patch->is_delete = -1;
1570
	patch->old_mode = patch->new_mode = 0;
1571
	patch->old_name = patch->new_name = NULL;
1572
	for (offset = 0; size > 0; offset += len, size -= len, line += len, state->linenr++) {
1573
		unsigned long nextlen;
1574

1575
		len = linelen(line, size);
1576
		if (!len)
1577
			break;
1578

1579
		/* Testing this early allows us to take a few shortcuts.. */
1580
		if (len < 6)
1581
			continue;
1582

1583
		/*
1584
		 * Make sure we don't find any unconnected patch fragments.
1585
		 * That's a sign that we didn't find a header, and that a
1586
		 * patch has become corrupted/broken up.
1587
		 */
1588
		if (!memcmp("@@ -", line, 4)) {
1589
			struct fragment dummy;
1590
			if (parse_fragment_header(line, len, &dummy) < 0)
1591
				continue;
1592
			error(_("patch fragment without header at line %d: %.*s"),
1593
				     state->linenr, (int)len-1, line);
1594
			return -128;
1595
		}
1596

1597
		if (size < len + 6)
1598
			break;
1599

1600
		/*
1601
		 * Git patch? It might not have a real patch, just a rename
1602
		 * or mode change, so we handle that specially
1603
		 */
1604
		if (!memcmp("diff --git ", line, 11)) {
1605
			int git_hdr_len = parse_git_diff_header(&state->root, &state->linenr,
1606
								state->p_value, line, len,
1607
								size, patch);
1608
			if (git_hdr_len < 0)
1609
				return -128;
1610
			if (git_hdr_len <= len)
1611
				continue;
1612
			*hdrsize = git_hdr_len;
1613
			return offset;
1614
		}
1615

1616
		/* --- followed by +++ ? */
1617
		if (memcmp("--- ", line,  4) || memcmp("+++ ", line + len, 4))
1618
			continue;
1619

1620
		/*
1621
		 * We only accept unified patches, so we want it to
1622
		 * at least have "@@ -a,b +c,d @@\n", which is 14 chars
1623
		 * minimum ("@@ -0,0 +1 @@\n" is the shortest).
1624
		 */
1625
		nextlen = linelen(line + len, size - len);
1626
		if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))
1627
			continue;
1628

1629
		/* Ok, we'll consider it a patch */
1630
		if (parse_traditional_patch(state, line, line+len, patch))
1631
			return -128;
1632
		*hdrsize = len + nextlen;
1633
		state->linenr += 2;
1634
		return offset;
1635
	}
1636
	return -1;
1637
}
1638

1639
static void record_ws_error(struct apply_state *state,
1640
			    unsigned result,
1641
			    const char *line,
1642
			    int len,
1643
			    int linenr)
1644
{
1645
	char *err;
1646

1647
	if (!result)
1648
		return;
1649

1650
	state->whitespace_error++;
1651
	if (state->squelch_whitespace_errors &&
1652
	    state->squelch_whitespace_errors < state->whitespace_error)
1653
		return;
1654

1655
	err = whitespace_error_string(result);
1656
	if (state->apply_verbosity > verbosity_silent)
1657
		fprintf(stderr, "%s:%d: %s.\n%.*s\n",
1658
			state->patch_input_file, linenr, err, len, line);
1659
	free(err);
1660
}
1661

1662
static void check_whitespace(struct apply_state *state,
1663
			     const char *line,
1664
			     int len,
1665
			     unsigned ws_rule)
1666
{
1667
	unsigned result = ws_check(line + 1, len - 1, ws_rule);
1668

1669
	record_ws_error(state, result, line + 1, len - 2, state->linenr);
1670
}
1671

1672
/*
1673
 * Check if the patch has context lines with CRLF or
1674
 * the patch wants to remove lines with CRLF.
1675
 */
1676
static void check_old_for_crlf(struct patch *patch, const char *line, int len)
1677
{
1678
	if (len >= 2 && line[len-1] == '\n' && line[len-2] == '\r') {
1679
		patch->ws_rule |= WS_CR_AT_EOL;
1680
		patch->crlf_in_old = 1;
1681
	}
1682
}
1683

1684

1685
/*
1686
 * Parse a unified diff. Note that this really needs to parse each
1687
 * fragment separately, since the only way to know the difference
1688
 * between a "---" that is part of a patch, and a "---" that starts
1689
 * the next patch is to look at the line counts..
1690
 */
1691
static int parse_fragment(struct apply_state *state,
1692
			  const char *line,
1693
			  unsigned long size,
1694
			  struct patch *patch,
1695
			  struct fragment *fragment)
1696
{
1697
	int added, deleted;
1698
	int len = linelen(line, size), offset;
1699
	unsigned long oldlines, newlines;
1700
	unsigned long leading, trailing;
1701

1702
	offset = parse_fragment_header(line, len, fragment);
1703
	if (offset < 0)
1704
		return -1;
1705
	if (offset > 0 && patch->recount)
1706
		recount_diff(line + offset, size - offset, fragment);
1707
	oldlines = fragment->oldlines;
1708
	newlines = fragment->newlines;
1709
	leading = 0;
1710
	trailing = 0;
1711

1712
	/* Parse the thing.. */
1713
	line += len;
1714
	size -= len;
1715
	state->linenr++;
1716
	added = deleted = 0;
1717
	for (offset = len;
1718
	     0 < size;
1719
	     offset += len, size -= len, line += len, state->linenr++) {
1720
		if (!oldlines && !newlines)
1721
			break;
1722
		len = linelen(line, size);
1723
		if (!len || line[len-1] != '\n')
1724
			return -1;
1725
		switch (*line) {
1726
		default:
1727
			return -1;
1728
		case '\n': /* newer GNU diff, an empty context line */
1729
		case ' ':
1730
			oldlines--;
1731
			newlines--;
1732
			if (!deleted && !added)
1733
				leading++;
1734
			trailing++;
1735
			check_old_for_crlf(patch, line, len);
1736
			if (!state->apply_in_reverse &&
1737
			    state->ws_error_action == correct_ws_error)
1738
				check_whitespace(state, line, len, patch->ws_rule);
1739
			break;
1740
		case '-':
1741
			if (!state->apply_in_reverse)
1742
				check_old_for_crlf(patch, line, len);
1743
			if (state->apply_in_reverse &&
1744
			    state->ws_error_action != nowarn_ws_error)
1745
				check_whitespace(state, line, len, patch->ws_rule);
1746
			deleted++;
1747
			oldlines--;
1748
			trailing = 0;
1749
			break;
1750
		case '+':
1751
			if (state->apply_in_reverse)
1752
				check_old_for_crlf(patch, line, len);
1753
			if (!state->apply_in_reverse &&
1754
			    state->ws_error_action != nowarn_ws_error)
1755
				check_whitespace(state, line, len, patch->ws_rule);
1756
			added++;
1757
			newlines--;
1758
			trailing = 0;
1759
			break;
1760

1761
		/*
1762
		 * We allow "\ No newline at end of file". Depending
1763
		 * on locale settings when the patch was produced we
1764
		 * don't know what this line looks like. The only
1765
		 * thing we do know is that it begins with "\ ".
1766
		 * Checking for 12 is just for sanity check -- any
1767
		 * l10n of "\ No newline..." is at least that long.
1768
		 */
1769
		case '\\':
1770
			if (len < 12 || memcmp(line, "\\ ", 2))
1771
				return -1;
1772
			break;
1773
		}
1774
	}
1775
	if (oldlines || newlines)
1776
		return -1;
1777
	if (!patch->recount && !deleted && !added)
1778
		return -1;
1779

1780
	fragment->leading = leading;
1781
	fragment->trailing = trailing;
1782

1783
	/*
1784
	 * If a fragment ends with an incomplete line, we failed to include
1785
	 * it in the above loop because we hit oldlines == newlines == 0
1786
	 * before seeing it.
1787
	 */
1788
	if (12 < size && !memcmp(line, "\\ ", 2))
1789
		offset += linelen(line, size);
1790

1791
	patch->lines_added += added;
1792
	patch->lines_deleted += deleted;
1793

1794
	if (0 < patch->is_new && oldlines)
1795
		return error(_("new file depends on old contents"));
1796
	if (0 < patch->is_delete && newlines)
1797
		return error(_("deleted file still has contents"));
1798
	return offset;
1799
}
1800

1801
/*
1802
 * We have seen "diff --git a/... b/..." header (or a traditional patch
1803
 * header).  Read hunks that belong to this patch into fragments and hang
1804
 * them to the given patch structure.
1805
 *
1806
 * The (fragment->patch, fragment->size) pair points into the memory given
1807
 * by the caller, not a copy, when we return.
1808
 *
1809
 * Returns:
1810
 *   -1 in case of error,
1811
 *   the number of bytes in the patch otherwise.
1812
 */
1813
static int parse_single_patch(struct apply_state *state,
1814
			      const char *line,
1815
			      unsigned long size,
1816
			      struct patch *patch)
1817
{
1818
	unsigned long offset = 0;
1819
	unsigned long oldlines = 0, newlines = 0, context = 0;
1820
	struct fragment **fragp = &patch->fragments;
1821

1822
	while (size > 4 && !memcmp(line, "@@ -", 4)) {
1823
		struct fragment *fragment;
1824
		int len;
1825

1826
		CALLOC_ARRAY(fragment, 1);
1827
		fragment->linenr = state->linenr;
1828
		len = parse_fragment(state, line, size, patch, fragment);
1829
		if (len <= 0) {
1830
			free(fragment);
1831
			return error(_("corrupt patch at line %d"), state->linenr);
1832
		}
1833
		fragment->patch = line;
1834
		fragment->size = len;
1835
		oldlines += fragment->oldlines;
1836
		newlines += fragment->newlines;
1837
		context += fragment->leading + fragment->trailing;
1838

1839
		*fragp = fragment;
1840
		fragp = &fragment->next;
1841

1842
		offset += len;
1843
		line += len;
1844
		size -= len;
1845
	}
1846

1847
	/*
1848
	 * If something was removed (i.e. we have old-lines) it cannot
1849
	 * be creation, and if something was added it cannot be
1850
	 * deletion.  However, the reverse is not true; --unified=0
1851
	 * patches that only add are not necessarily creation even
1852
	 * though they do not have any old lines, and ones that only
1853
	 * delete are not necessarily deletion.
1854
	 *
1855
	 * Unfortunately, a real creation/deletion patch do _not_ have
1856
	 * any context line by definition, so we cannot safely tell it
1857
	 * apart with --unified=0 insanity.  At least if the patch has
1858
	 * more than one hunk it is not creation or deletion.
1859
	 */
1860
	if (patch->is_new < 0 &&
1861
	    (oldlines || (patch->fragments && patch->fragments->next)))
1862
		patch->is_new = 0;
1863
	if (patch->is_delete < 0 &&
1864
	    (newlines || (patch->fragments && patch->fragments->next)))
1865
		patch->is_delete = 0;
1866

1867
	if (0 < patch->is_new && oldlines)
1868
		return error(_("new file %s depends on old contents"), patch->new_name);
1869
	if (0 < patch->is_delete && newlines)
1870
		return error(_("deleted file %s still has contents"), patch->old_name);
1871
	if (!patch->is_delete && !newlines && context && state->apply_verbosity > verbosity_silent)
1872
		fprintf_ln(stderr,
1873
			   _("** warning: "
1874
			     "file %s becomes empty but is not deleted"),
1875
			   patch->new_name);
1876

1877
	return offset;
1878
}
1879

1880
static inline int metadata_changes(struct patch *patch)
1881
{
1882
	return	patch->is_rename > 0 ||
1883
		patch->is_copy > 0 ||
1884
		patch->is_new > 0 ||
1885
		patch->is_delete ||
1886
		(patch->old_mode && patch->new_mode &&
1887
		 patch->old_mode != patch->new_mode);
1888
}
1889

1890
static char *inflate_it(const void *data, unsigned long size,
1891
			unsigned long inflated_size)
1892
{
1893
	git_zstream stream;
1894
	void *out;
1895
	int st;
1896

1897
	memset(&stream, 0, sizeof(stream));
1898

1899
	stream.next_in = (unsigned char *)data;
1900
	stream.avail_in = size;
1901
	stream.next_out = out = xmalloc(inflated_size);
1902
	stream.avail_out = inflated_size;
1903
	git_inflate_init(&stream);
1904
	st = git_inflate(&stream, Z_FINISH);
1905
	git_inflate_end(&stream);
1906
	if ((st != Z_STREAM_END) || stream.total_out != inflated_size) {
1907
		free(out);
1908
		return NULL;
1909
	}
1910
	return out;
1911
}
1912

1913
/*
1914
 * Read a binary hunk and return a new fragment; fragment->patch
1915
 * points at an allocated memory that the caller must free, so
1916
 * it is marked as "->free_patch = 1".
1917
 */
1918
static struct fragment *parse_binary_hunk(struct apply_state *state,
1919
					  char **buf_p,
1920
					  unsigned long *sz_p,
1921
					  int *status_p,
1922
					  int *used_p)
1923
{
1924
	/*
1925
	 * Expect a line that begins with binary patch method ("literal"
1926
	 * or "delta"), followed by the length of data before deflating.
1927
	 * a sequence of 'length-byte' followed by base-85 encoded data
1928
	 * should follow, terminated by a newline.
1929
	 *
1930
	 * Each 5-byte sequence of base-85 encodes up to 4 bytes,
1931
	 * and we would limit the patch line to 66 characters,
1932
	 * so one line can fit up to 13 groups that would decode
1933
	 * to 52 bytes max.  The length byte 'A'-'Z' corresponds
1934
	 * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.
1935
	 */
1936
	int llen, used;
1937
	unsigned long size = *sz_p;
1938
	char *buffer = *buf_p;
1939
	int patch_method;
1940
	unsigned long origlen;
1941
	char *data = NULL;
1942
	int hunk_size = 0;
1943
	struct fragment *frag;
1944

1945
	llen = linelen(buffer, size);
1946
	used = llen;
1947

1948
	*status_p = 0;
1949

1950
	if (starts_with(buffer, "delta ")) {
1951
		patch_method = BINARY_DELTA_DEFLATED;
1952
		origlen = strtoul(buffer + 6, NULL, 10);
1953
	}
1954
	else if (starts_with(buffer, "literal ")) {
1955
		patch_method = BINARY_LITERAL_DEFLATED;
1956
		origlen = strtoul(buffer + 8, NULL, 10);
1957
	}
1958
	else
1959
		return NULL;
1960

1961
	state->linenr++;
1962
	buffer += llen;
1963
	size -= llen;
1964
	while (1) {
1965
		int byte_length, max_byte_length, newsize;
1966
		llen = linelen(buffer, size);
1967
		used += llen;
1968
		state->linenr++;
1969
		if (llen == 1) {
1970
			/* consume the blank line */
1971
			buffer++;
1972
			size--;
1973
			break;
1974
		}
1975
		/*
1976
		 * Minimum line is "A00000\n" which is 7-byte long,
1977
		 * and the line length must be multiple of 5 plus 2.
1978
		 */
1979
		if ((llen < 7) || (llen-2) % 5)
1980
			goto corrupt;
1981
		max_byte_length = (llen - 2) / 5 * 4;
1982
		byte_length = *buffer;
1983
		if ('A' <= byte_length && byte_length <= 'Z')
1984
			byte_length = byte_length - 'A' + 1;
1985
		else if ('a' <= byte_length && byte_length <= 'z')
1986
			byte_length = byte_length - 'a' + 27;
1987
		else
1988
			goto corrupt;
1989
		/* if the input length was not multiple of 4, we would
1990
		 * have filler at the end but the filler should never
1991
		 * exceed 3 bytes
1992
		 */
1993
		if (max_byte_length < byte_length ||
1994
		    byte_length <= max_byte_length - 4)
1995
			goto corrupt;
1996
		newsize = hunk_size + byte_length;
1997
		data = xrealloc(data, newsize);
1998
		if (decode_85(data + hunk_size, buffer + 1, byte_length))
1999
			goto corrupt;
2000
		hunk_size = newsize;
2001
		buffer += llen;
2002
		size -= llen;
2003
	}
2004

2005
	CALLOC_ARRAY(frag, 1);
2006
	frag->patch = inflate_it(data, hunk_size, origlen);
2007
	frag->free_patch = 1;
2008
	if (!frag->patch)
2009
		goto corrupt;
2010
	free(data);
2011
	frag->size = origlen;
2012
	*buf_p = buffer;
2013
	*sz_p = size;
2014
	*used_p = used;
2015
	frag->binary_patch_method = patch_method;
2016
	return frag;
2017

2018
 corrupt:
2019
	free(data);
2020
	*status_p = -1;
2021
	error(_("corrupt binary patch at line %d: %.*s"),
2022
	      state->linenr-1, llen-1, buffer);
2023
	return NULL;
2024
}
2025

2026
/*
2027
 * Returns:
2028
 *   -1 in case of error,
2029
 *   the length of the parsed binary patch otherwise
2030
 */
2031
static int parse_binary(struct apply_state *state,
2032
			char *buffer,
2033
			unsigned long size,
2034
			struct patch *patch)
2035
{
2036
	/*
2037
	 * We have read "GIT binary patch\n"; what follows is a line
2038
	 * that says the patch method (currently, either "literal" or
2039
	 * "delta") and the length of data before deflating; a
2040
	 * sequence of 'length-byte' followed by base-85 encoded data
2041
	 * follows.
2042
	 *
2043
	 * When a binary patch is reversible, there is another binary
2044
	 * hunk in the same format, starting with patch method (either
2045
	 * "literal" or "delta") with the length of data, and a sequence
2046
	 * of length-byte + base-85 encoded data, terminated with another
2047
	 * empty line.  This data, when applied to the postimage, produces
2048
	 * the preimage.
2049
	 */
2050
	struct fragment *forward;
2051
	struct fragment *reverse;
2052
	int status;
2053
	int used, used_1;
2054

2055
	forward = parse_binary_hunk(state, &buffer, &size, &status, &used);
2056
	if (!forward && !status)
2057
		/* there has to be one hunk (forward hunk) */
2058
		return error(_("unrecognized binary patch at line %d"), state->linenr-1);
2059
	if (status)
2060
		/* otherwise we already gave an error message */
2061
		return status;
2062

2063
	reverse = parse_binary_hunk(state, &buffer, &size, &status, &used_1);
2064
	if (reverse)
2065
		used += used_1;
2066
	else if (status) {
2067
		/*
2068
		 * Not having reverse hunk is not an error, but having
2069
		 * a corrupt reverse hunk is.
2070
		 */
2071
		free((void*) forward->patch);
2072
		free(forward);
2073
		return status;
2074
	}
2075
	forward->next = reverse;
2076
	patch->fragments = forward;
2077
	patch->is_binary = 1;
2078
	return used;
2079
}
2080

2081
static void prefix_one(struct apply_state *state, char **name)
2082
{
2083
	char *old_name = *name;
2084
	if (!old_name)
2085
		return;
2086
	*name = prefix_filename(state->prefix, *name);
2087
	free(old_name);
2088
}
2089

2090
static void prefix_patch(struct apply_state *state, struct patch *p)
2091
{
2092
	if (!state->prefix || p->is_toplevel_relative)
2093
		return;
2094
	prefix_one(state, &p->new_name);
2095
	prefix_one(state, &p->old_name);
2096
}
2097

2098
/*
2099
 * include/exclude
2100
 */
2101

2102
static void add_name_limit(struct apply_state *state,
2103
			   const char *name,
2104
			   int exclude)
2105
{
2106
	struct string_list_item *it;
2107

2108
	it = string_list_append(&state->limit_by_name, name);
2109
	it->util = exclude ? NULL : (void *) 1;
2110
}
2111

2112
static int use_patch(struct apply_state *state, struct patch *p)
2113
{
2114
	const char *pathname = p->new_name ? p->new_name : p->old_name;
2115
	int i;
2116

2117
	/* Paths outside are not touched regardless of "--include" */
2118
	if (state->prefix && *state->prefix) {
2119
		const char *rest;
2120
		if (!skip_prefix(pathname, state->prefix, &rest) || !*rest)
2121
			return 0;
2122
	}
2123

2124
	/* See if it matches any of exclude/include rule */
2125
	for (i = 0; i < state->limit_by_name.nr; i++) {
2126
		struct string_list_item *it = &state->limit_by_name.items[i];
2127
		if (!wildmatch(it->string, pathname, 0))
2128
			return (it->util != NULL);
2129
	}
2130

2131
	/*
2132
	 * If we had any include, a path that does not match any rule is
2133
	 * not used.  Otherwise, we saw bunch of exclude rules (or none)
2134
	 * and such a path is used.
2135
	 */
2136
	return !state->has_include;
2137
}
2138

2139
/*
2140
 * Read the patch text in "buffer" that extends for "size" bytes; stop
2141
 * reading after seeing a single patch (i.e. changes to a single file).
2142
 * Create fragments (i.e. patch hunks) and hang them to the given patch.
2143
 *
2144
 * Returns:
2145
 *   -1 if no header was found or parse_binary() failed,
2146
 *   -128 on another error,
2147
 *   the number of bytes consumed otherwise,
2148
 *     so that the caller can call us again for the next patch.
2149
 */
2150
static int parse_chunk(struct apply_state *state, char *buffer, unsigned long size, struct patch *patch)
2151
{
2152
	int hdrsize, patchsize;
2153
	int offset = find_header(state, buffer, size, &hdrsize, patch);
2154

2155
	if (offset < 0)
2156
		return offset;
2157

2158
	prefix_patch(state, patch);
2159

2160
	if (!use_patch(state, patch))
2161
		patch->ws_rule = 0;
2162
	else if (patch->new_name)
2163
		patch->ws_rule = whitespace_rule(state->repo->index,
2164
						 patch->new_name);
2165
	else
2166
		patch->ws_rule = whitespace_rule(state->repo->index,
2167
						 patch->old_name);
2168

2169
	patchsize = parse_single_patch(state,
2170
				       buffer + offset + hdrsize,
2171
				       size - offset - hdrsize,
2172
				       patch);
2173

2174
	if (patchsize < 0)
2175
		return -128;
2176

2177
	if (!patchsize) {
2178
		static const char git_binary[] = "GIT binary patch\n";
2179
		int hd = hdrsize + offset;
2180
		unsigned long llen = linelen(buffer + hd, size - hd);
2181

2182
		if (llen == sizeof(git_binary) - 1 &&
2183
		    !memcmp(git_binary, buffer + hd, llen)) {
2184
			int used;
2185
			state->linenr++;
2186
			used = parse_binary(state, buffer + hd + llen,
2187
					    size - hd - llen, patch);
2188
			if (used < 0)
2189
				return -1;
2190
			if (used)
2191
				patchsize = used + llen;
2192
			else
2193
				patchsize = 0;
2194
		}
2195
		else if (!memcmp(" differ\n", buffer + hd + llen - 8, 8)) {
2196
			static const char *binhdr[] = {
2197
				"Binary files ",
2198
				"Files ",
2199
				NULL,
2200
			};
2201
			int i;
2202
			for (i = 0; binhdr[i]; i++) {
2203
				int len = strlen(binhdr[i]);
2204
				if (len < size - hd &&
2205
				    !memcmp(binhdr[i], buffer + hd, len)) {
2206
					state->linenr++;
2207
					patch->is_binary = 1;
2208
					patchsize = llen;
2209
					break;
2210
				}
2211
			}
2212
		}
2213

2214
		/* Empty patch cannot be applied if it is a text patch
2215
		 * without metadata change.  A binary patch appears
2216
		 * empty to us here.
2217
		 */
2218
		if ((state->apply || state->check) &&
2219
		    (!patch->is_binary && !metadata_changes(patch))) {
2220
			error(_("patch with only garbage at line %d"), state->linenr);
2221
			return -128;
2222
		}
2223
	}
2224

2225
	return offset + hdrsize + patchsize;
2226
}
2227

2228
static void reverse_patches(struct patch *p)
2229
{
2230
	for (; p; p = p->next) {
2231
		struct fragment *frag = p->fragments;
2232

2233
		SWAP(p->new_name, p->old_name);
2234
		if (p->new_mode)
2235
			SWAP(p->new_mode, p->old_mode);
2236
		SWAP(p->is_new, p->is_delete);
2237
		SWAP(p->lines_added, p->lines_deleted);
2238
		SWAP(p->old_oid_prefix, p->new_oid_prefix);
2239

2240
		for (; frag; frag = frag->next) {
2241
			SWAP(frag->newpos, frag->oldpos);
2242
			SWAP(frag->newlines, frag->oldlines);
2243
		}
2244
	}
2245
}
2246

2247
static const char pluses[] =
2248
"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
2249
static const char minuses[]=
2250
"----------------------------------------------------------------------";
2251

2252
static void show_stats(struct apply_state *state, struct patch *patch)
2253
{
2254
	struct strbuf qname = STRBUF_INIT;
2255
	char *cp = patch->new_name ? patch->new_name : patch->old_name;
2256
	int max, add, del;
2257

2258
	quote_c_style(cp, &qname, NULL, 0);
2259

2260
	/*
2261
	 * "scale" the filename
2262
	 */
2263
	max = state->max_len;
2264
	if (max > 50)
2265
		max = 50;
2266

2267
	if (qname.len > max) {
2268
		cp = strchr(qname.buf + qname.len + 3 - max, '/');
2269
		if (!cp)
2270
			cp = qname.buf + qname.len + 3 - max;
2271
		strbuf_splice(&qname, 0, cp - qname.buf, "...", 3);
2272
	}
2273

2274
	if (patch->is_binary) {
2275
		printf(" %-*s |  Bin\n", max, qname.buf);
2276
		strbuf_release(&qname);
2277
		return;
2278
	}
2279

2280
	printf(" %-*s |", max, qname.buf);
2281
	strbuf_release(&qname);
2282

2283
	/*
2284
	 * scale the add/delete
2285
	 */
2286
	max = max + state->max_change > 70 ? 70 - max : state->max_change;
2287
	add = patch->lines_added;
2288
	del = patch->lines_deleted;
2289

2290
	if (state->max_change > 0) {
2291
		int total = ((add + del) * max + state->max_change / 2) / state->max_change;
2292
		add = (add * max + state->max_change / 2) / state->max_change;
2293
		del = total - add;
2294
	}
2295
	printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,
2296
		add, pluses, del, minuses);
2297
}
2298

2299
static int read_old_data(struct stat *st, struct patch *patch,
2300
			 const char *path, struct strbuf *buf)
2301
{
2302
	int conv_flags = patch->crlf_in_old ?
2303
		CONV_EOL_KEEP_CRLF : CONV_EOL_RENORMALIZE;
2304
	switch (st->st_mode & S_IFMT) {
2305
	case S_IFLNK:
2306
		if (strbuf_readlink(buf, path, st->st_size) < 0)
2307
			return error(_("unable to read symlink %s"), path);
2308
		return 0;
2309
	case S_IFREG:
2310
		if (strbuf_read_file(buf, path, st->st_size) != st->st_size)
2311
			return error(_("unable to open or read %s"), path);
2312
		/*
2313
		 * "git apply" without "--index/--cached" should never look
2314
		 * at the index; the target file may not have been added to
2315
		 * the index yet, and we may not even be in any Git repository.
2316
		 * Pass NULL to convert_to_git() to stress this; the function
2317
		 * should never look at the index when explicit crlf option
2318
		 * is given.
2319
		 */
2320
		convert_to_git(NULL, path, buf->buf, buf->len, buf, conv_flags);
2321
		return 0;
2322
	default:
2323
		return -1;
2324
	}
2325
}
2326

2327
/*
2328
 * Update the preimage, and the common lines in postimage,
2329
 * from buffer buf of length len. If postlen is 0 the postimage
2330
 * is updated in place, otherwise it's updated on a new buffer
2331
 * of length postlen
2332
 */
2333

2334
static void update_pre_post_images(struct image *preimage,
2335
				   struct image *postimage,
2336
				   char *buf,
2337
				   size_t len, size_t postlen)
2338
{
2339
	int i, ctx, reduced;
2340
	char *new_buf, *old_buf, *fixed;
2341
	struct image fixed_preimage;
2342

2343
	/*
2344
	 * Update the preimage with whitespace fixes.  Note that we
2345
	 * are not losing preimage->buf -- apply_one_fragment() will
2346
	 * free "oldlines".
2347
	 */
2348
	prepare_image(&fixed_preimage, buf, len, 1);
2349
	assert(postlen
2350
	       ? fixed_preimage.nr == preimage->nr
2351
	       : fixed_preimage.nr <= preimage->nr);
2352
	for (i = 0; i < fixed_preimage.nr; i++)
2353
		fixed_preimage.line[i].flag = preimage->line[i].flag;
2354
	free(preimage->line_allocated);
2355
	*preimage = fixed_preimage;
2356

2357
	/*
2358
	 * Adjust the common context lines in postimage. This can be
2359
	 * done in-place when we are shrinking it with whitespace
2360
	 * fixing, but needs a new buffer when ignoring whitespace or
2361
	 * expanding leading tabs to spaces.
2362
	 *
2363
	 * We trust the caller to tell us if the update can be done
2364
	 * in place (postlen==0) or not.
2365
	 */
2366
	old_buf = postimage->buf;
2367
	if (postlen)
2368
		new_buf = postimage->buf = xmalloc(postlen);
2369
	else
2370
		new_buf = old_buf;
2371
	fixed = preimage->buf;
2372

2373
	for (i = reduced = ctx = 0; i < postimage->nr; i++) {
2374
		size_t l_len = postimage->line[i].len;
2375
		if (!(postimage->line[i].flag & LINE_COMMON)) {
2376
			/* an added line -- no counterparts in preimage */
2377
			memmove(new_buf, old_buf, l_len);
2378
			old_buf += l_len;
2379
			new_buf += l_len;
2380
			continue;
2381
		}
2382

2383
		/* a common context -- skip it in the original postimage */
2384
		old_buf += l_len;
2385

2386
		/* and find the corresponding one in the fixed preimage */
2387
		while (ctx < preimage->nr &&
2388
		       !(preimage->line[ctx].flag & LINE_COMMON)) {
2389
			fixed += preimage->line[ctx].len;
2390
			ctx++;
2391
		}
2392

2393
		/*
2394
		 * preimage is expected to run out, if the caller
2395
		 * fixed addition of trailing blank lines.
2396
		 */
2397
		if (preimage->nr <= ctx) {
2398
			reduced++;
2399
			continue;
2400
		}
2401

2402
		/* and copy it in, while fixing the line length */
2403
		l_len = preimage->line[ctx].len;
2404
		memcpy(new_buf, fixed, l_len);
2405
		new_buf += l_len;
2406
		fixed += l_len;
2407
		postimage->line[i].len = l_len;
2408
		ctx++;
2409
	}
2410

2411
	if (postlen
2412
	    ? postlen < new_buf - postimage->buf
2413
	    : postimage->len < new_buf - postimage->buf)
2414
		BUG("caller miscounted postlen: asked %d, orig = %d, used = %d",
2415
		    (int)postlen, (int) postimage->len, (int)(new_buf - postimage->buf));
2416

2417
	/* Fix the length of the whole thing */
2418
	postimage->len = new_buf - postimage->buf;
2419
	postimage->nr -= reduced;
2420
}
2421

2422
static int line_by_line_fuzzy_match(struct image *img,
2423
				    struct image *preimage,
2424
				    struct image *postimage,
2425
				    unsigned long current,
2426
				    int current_lno,
2427
				    int preimage_limit)
2428
{
2429
	int i;
2430
	size_t imgoff = 0;
2431
	size_t preoff = 0;
2432
	size_t postlen = postimage->len;
2433
	size_t extra_chars;
2434
	char *buf;
2435
	char *preimage_eof;
2436
	char *preimage_end;
2437
	struct strbuf fixed;
2438
	char *fixed_buf;
2439
	size_t fixed_len;
2440

2441
	for (i = 0; i < preimage_limit; i++) {
2442
		size_t prelen = preimage->line[i].len;
2443
		size_t imglen = img->line[current_lno+i].len;
2444

2445
		if (!fuzzy_matchlines(img->buf + current + imgoff, imglen,
2446
				      preimage->buf + preoff, prelen))
2447
			return 0;
2448
		if (preimage->line[i].flag & LINE_COMMON)
2449
			postlen += imglen - prelen;
2450
		imgoff += imglen;
2451
		preoff += prelen;
2452
	}
2453

2454
	/*
2455
	 * Ok, the preimage matches with whitespace fuzz.
2456
	 *
2457
	 * imgoff now holds the true length of the target that
2458
	 * matches the preimage before the end of the file.
2459
	 *
2460
	 * Count the number of characters in the preimage that fall
2461
	 * beyond the end of the file and make sure that all of them
2462
	 * are whitespace characters. (This can only happen if
2463
	 * we are removing blank lines at the end of the file.)
2464
	 */
2465
	buf = preimage_eof = preimage->buf + preoff;
2466
	for ( ; i < preimage->nr; i++)
2467
		preoff += preimage->line[i].len;
2468
	preimage_end = preimage->buf + preoff;
2469
	for ( ; buf < preimage_end; buf++)
2470
		if (!isspace(*buf))
2471
			return 0;
2472

2473
	/*
2474
	 * Update the preimage and the common postimage context
2475
	 * lines to use the same whitespace as the target.
2476
	 * If whitespace is missing in the target (i.e.
2477
	 * if the preimage extends beyond the end of the file),
2478
	 * use the whitespace from the preimage.
2479
	 */
2480
	extra_chars = preimage_end - preimage_eof;
2481
	strbuf_init(&fixed, imgoff + extra_chars);
2482
	strbuf_add(&fixed, img->buf + current, imgoff);
2483
	strbuf_add(&fixed, preimage_eof, extra_chars);
2484
	fixed_buf = strbuf_detach(&fixed, &fixed_len);
2485
	update_pre_post_images(preimage, postimage,
2486
			       fixed_buf, fixed_len, postlen);
2487
	return 1;
2488
}
2489

2490
static int match_fragment(struct apply_state *state,
2491
			  struct image *img,
2492
			  struct image *preimage,
2493
			  struct image *postimage,
2494
			  unsigned long current,
2495
			  int current_lno,
2496
			  unsigned ws_rule,
2497
			  int match_beginning, int match_end)
2498
{
2499
	int i;
2500
	const char *orig, *target;
2501
	struct strbuf fixed = STRBUF_INIT;
2502
	size_t postlen;
2503
	int preimage_limit;
2504
	int ret;
2505

2506
	if (preimage->nr + current_lno <= img->nr) {
2507
		/*
2508
		 * The hunk falls within the boundaries of img.
2509
		 */
2510
		preimage_limit = preimage->nr;
2511
		if (match_end && (preimage->nr + current_lno != img->nr)) {
2512
			ret = 0;
2513
			goto out;
2514
		}
2515
	} else if (state->ws_error_action == correct_ws_error &&
2516
		   (ws_rule & WS_BLANK_AT_EOF)) {
2517
		/*
2518
		 * This hunk extends beyond the end of img, and we are
2519
		 * removing blank lines at the end of the file.  This
2520
		 * many lines from the beginning of the preimage must
2521
		 * match with img, and the remainder of the preimage
2522
		 * must be blank.
2523
		 */
2524
		preimage_limit = img->nr - current_lno;
2525
	} else {
2526
		/*
2527
		 * The hunk extends beyond the end of the img and
2528
		 * we are not removing blanks at the end, so we
2529
		 * should reject the hunk at this position.
2530
		 */
2531
		ret = 0;
2532
		goto out;
2533
	}
2534

2535
	if (match_beginning && current_lno) {
2536
		ret = 0;
2537
		goto out;
2538
	}
2539

2540
	/* Quick hash check */
2541
	for (i = 0; i < preimage_limit; i++) {
2542
		if ((img->line[current_lno + i].flag & LINE_PATCHED) ||
2543
		    (preimage->line[i].hash != img->line[current_lno + i].hash)) {
2544
			ret = 0;
2545
			goto out;
2546
		}
2547
	}
2548

2549
	if (preimage_limit == preimage->nr) {
2550
		/*
2551
		 * Do we have an exact match?  If we were told to match
2552
		 * at the end, size must be exactly at current+fragsize,
2553
		 * otherwise current+fragsize must be still within the preimage,
2554
		 * and either case, the old piece should match the preimage
2555
		 * exactly.
2556
		 */
2557
		if ((match_end
2558
		     ? (current + preimage->len == img->len)
2559
		     : (current + preimage->len <= img->len)) &&
2560
		    !memcmp(img->buf + current, preimage->buf, preimage->len)) {
2561
			ret = 1;
2562
			goto out;
2563
		}
2564
	} else {
2565
		/*
2566
		 * The preimage extends beyond the end of img, so
2567
		 * there cannot be an exact match.
2568
		 *
2569
		 * There must be one non-blank context line that match
2570
		 * a line before the end of img.
2571
		 */
2572
		const char *buf, *buf_end;
2573

2574
		buf = preimage->buf;
2575
		buf_end = buf;
2576
		for (i = 0; i < preimage_limit; i++)
2577
			buf_end += preimage->line[i].len;
2578

2579
		for ( ; buf < buf_end; buf++)
2580
			if (!isspace(*buf))
2581
				break;
2582
		if (buf == buf_end) {
2583
			ret = 0;
2584
			goto out;
2585
		}
2586
	}
2587

2588
	/*
2589
	 * No exact match. If we are ignoring whitespace, run a line-by-line
2590
	 * fuzzy matching. We collect all the line length information because
2591
	 * we need it to adjust whitespace if we match.
2592
	 */
2593
	if (state->ws_ignore_action == ignore_ws_change) {
2594
		ret = line_by_line_fuzzy_match(img, preimage, postimage,
2595
					       current, current_lno, preimage_limit);
2596
		goto out;
2597
	}
2598

2599
	if (state->ws_error_action != correct_ws_error) {
2600
		ret = 0;
2601
		goto out;
2602
	}
2603

2604
	/*
2605
	 * The hunk does not apply byte-by-byte, but the hash says
2606
	 * it might with whitespace fuzz. We weren't asked to
2607
	 * ignore whitespace, we were asked to correct whitespace
2608
	 * errors, so let's try matching after whitespace correction.
2609
	 *
2610
	 * While checking the preimage against the target, whitespace
2611
	 * errors in both fixed, we count how large the corresponding
2612
	 * postimage needs to be.  The postimage prepared by
2613
	 * apply_one_fragment() has whitespace errors fixed on added
2614
	 * lines already, but the common lines were propagated as-is,
2615
	 * which may become longer when their whitespace errors are
2616
	 * fixed.
2617
	 */
2618

2619
	/* First count added lines in postimage */
2620
	postlen = 0;
2621
	for (i = 0; i < postimage->nr; i++) {
2622
		if (!(postimage->line[i].flag & LINE_COMMON))
2623
			postlen += postimage->line[i].len;
2624
	}
2625

2626
	/*
2627
	 * The preimage may extend beyond the end of the file,
2628
	 * but in this loop we will only handle the part of the
2629
	 * preimage that falls within the file.
2630
	 */
2631
	strbuf_grow(&fixed, preimage->len + 1);
2632
	orig = preimage->buf;
2633
	target = img->buf + current;
2634
	for (i = 0; i < preimage_limit; i++) {
2635
		size_t oldlen = preimage->line[i].len;
2636
		size_t tgtlen = img->line[current_lno + i].len;
2637
		size_t fixstart = fixed.len;
2638
		struct strbuf tgtfix;
2639
		int match;
2640

2641
		/* Try fixing the line in the preimage */
2642
		ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);
2643

2644
		/* Try fixing the line in the target */
2645
		strbuf_init(&tgtfix, tgtlen);
2646
		ws_fix_copy(&tgtfix, target, tgtlen, ws_rule, NULL);
2647

2648
		/*
2649
		 * If they match, either the preimage was based on
2650
		 * a version before our tree fixed whitespace breakage,
2651
		 * or we are lacking a whitespace-fix patch the tree
2652
		 * the preimage was based on already had (i.e. target
2653
		 * has whitespace breakage, the preimage doesn't).
2654
		 * In either case, we are fixing the whitespace breakages
2655
		 * so we might as well take the fix together with their
2656
		 * real change.
2657
		 */
2658
		match = (tgtfix.len == fixed.len - fixstart &&
2659
			 !memcmp(tgtfix.buf, fixed.buf + fixstart,
2660
					     fixed.len - fixstart));
2661

2662
		/* Add the length if this is common with the postimage */
2663
		if (preimage->line[i].flag & LINE_COMMON)
2664
			postlen += tgtfix.len;
2665

2666
		strbuf_release(&tgtfix);
2667
		if (!match) {
2668
			ret = 0;
2669
			goto out;
2670
		}
2671

2672
		orig += oldlen;
2673
		target += tgtlen;
2674
	}
2675

2676

2677
	/*
2678
	 * Now handle the lines in the preimage that falls beyond the
2679
	 * end of the file (if any). They will only match if they are
2680
	 * empty or only contain whitespace (if WS_BLANK_AT_EOL is
2681
	 * false).
2682
	 */
2683
	for ( ; i < preimage->nr; i++) {
2684
		size_t fixstart = fixed.len; /* start of the fixed preimage */
2685
		size_t oldlen = preimage->line[i].len;
2686
		int j;
2687

2688
		/* Try fixing the line in the preimage */
2689
		ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);
2690

2691
		for (j = fixstart; j < fixed.len; j++) {
2692
			if (!isspace(fixed.buf[j])) {
2693
				ret = 0;
2694
				goto out;
2695
			}
2696
		}
2697

2698

2699
		orig += oldlen;
2700
	}
2701

2702
	/*
2703
	 * Yes, the preimage is based on an older version that still
2704
	 * has whitespace breakages unfixed, and fixing them makes the
2705
	 * hunk match.  Update the context lines in the postimage.
2706
	 */
2707
	if (postlen < postimage->len)
2708
		postlen = 0;
2709
	update_pre_post_images(preimage, postimage,
2710
			       fixed.buf, fixed.len, postlen);
2711

2712
	ret = 1;
2713

2714
out:
2715
	strbuf_release(&fixed);
2716
	return ret;
2717
}
2718

2719
static int find_pos(struct apply_state *state,
2720
		    struct image *img,
2721
		    struct image *preimage,
2722
		    struct image *postimage,
2723
		    int line,
2724
		    unsigned ws_rule,
2725
		    int match_beginning, int match_end)
2726
{
2727
	int i;
2728
	unsigned long backwards, forwards, current;
2729
	int backwards_lno, forwards_lno, current_lno;
2730

2731
	/*
2732
	 * When running with --allow-overlap, it is possible that a hunk is
2733
	 * seen that pretends to start at the beginning (but no longer does),
2734
	 * and that *still* needs to match the end. So trust `match_end` more
2735
	 * than `match_beginning`.
2736
	 */
2737
	if (state->allow_overlap && match_beginning && match_end &&
2738
	    img->nr - preimage->nr != 0)
2739
		match_beginning = 0;
2740

2741
	/*
2742
	 * If match_beginning or match_end is specified, there is no
2743
	 * point starting from a wrong line that will never match and
2744
	 * wander around and wait for a match at the specified end.
2745
	 */
2746
	if (match_beginning)
2747
		line = 0;
2748
	else if (match_end)
2749
		line = img->nr - preimage->nr;
2750

2751
	/*
2752
	 * Because the comparison is unsigned, the following test
2753
	 * will also take care of a negative line number that can
2754
	 * result when match_end and preimage is larger than the target.
2755
	 */
2756
	if ((size_t) line > img->nr)
2757
		line = img->nr;
2758

2759
	current = 0;
2760
	for (i = 0; i < line; i++)
2761
		current += img->line[i].len;
2762

2763
	/*
2764
	 * There's probably some smart way to do this, but I'll leave
2765
	 * that to the smart and beautiful people. I'm simple and stupid.
2766
	 */
2767
	backwards = current;
2768
	backwards_lno = line;
2769
	forwards = current;
2770
	forwards_lno = line;
2771
	current_lno = line;
2772

2773
	for (i = 0; ; i++) {
2774
		if (match_fragment(state, img, preimage, postimage,
2775
				   current, current_lno, ws_rule,
2776
				   match_beginning, match_end))
2777
			return current_lno;
2778

2779
	again:
2780
		if (backwards_lno == 0 && forwards_lno == img->nr)
2781
			break;
2782

2783
		if (i & 1) {
2784
			if (backwards_lno == 0) {
2785
				i++;
2786
				goto again;
2787
			}
2788
			backwards_lno--;
2789
			backwards -= img->line[backwards_lno].len;
2790
			current = backwards;
2791
			current_lno = backwards_lno;
2792
		} else {
2793
			if (forwards_lno == img->nr) {
2794
				i++;
2795
				goto again;
2796
			}
2797
			forwards += img->line[forwards_lno].len;
2798
			forwards_lno++;
2799
			current = forwards;
2800
			current_lno = forwards_lno;
2801
		}
2802

2803
	}
2804
	return -1;
2805
}
2806

2807
static void remove_first_line(struct image *img)
2808
{
2809
	img->buf += img->line[0].len;
2810
	img->len -= img->line[0].len;
2811
	img->line++;
2812
	img->nr--;
2813
}
2814

2815
static void remove_last_line(struct image *img)
2816
{
2817
	img->len -= img->line[--img->nr].len;
2818
}
2819

2820
/*
2821
 * The change from "preimage" and "postimage" has been found to
2822
 * apply at applied_pos (counts in line numbers) in "img".
2823
 * Update "img" to remove "preimage" and replace it with "postimage".
2824
 */
2825
static void update_image(struct apply_state *state,
2826
			 struct image *img,
2827
			 int applied_pos,
2828
			 struct image *preimage,
2829
			 struct image *postimage)
2830
{
2831
	/*
2832
	 * remove the copy of preimage at offset in img
2833
	 * and replace it with postimage
2834
	 */
2835
	int i, nr;
2836
	size_t remove_count, insert_count, applied_at = 0;
2837
	char *result;
2838
	int preimage_limit;
2839

2840
	/*
2841
	 * If we are removing blank lines at the end of img,
2842
	 * the preimage may extend beyond the end.
2843
	 * If that is the case, we must be careful only to
2844
	 * remove the part of the preimage that falls within
2845
	 * the boundaries of img. Initialize preimage_limit
2846
	 * to the number of lines in the preimage that falls
2847
	 * within the boundaries.
2848
	 */
2849
	preimage_limit = preimage->nr;
2850
	if (preimage_limit > img->nr - applied_pos)
2851
		preimage_limit = img->nr - applied_pos;
2852

2853
	for (i = 0; i < applied_pos; i++)
2854
		applied_at += img->line[i].len;
2855

2856
	remove_count = 0;
2857
	for (i = 0; i < preimage_limit; i++)
2858
		remove_count += img->line[applied_pos + i].len;
2859
	insert_count = postimage->len;
2860

2861
	/* Adjust the contents */
2862
	result = xmalloc(st_add3(st_sub(img->len, remove_count), insert_count, 1));
2863
	memcpy(result, img->buf, applied_at);
2864
	memcpy(result + applied_at, postimage->buf, postimage->len);
2865
	memcpy(result + applied_at + postimage->len,
2866
	       img->buf + (applied_at + remove_count),
2867
	       img->len - (applied_at + remove_count));
2868
	free(img->buf);
2869
	img->buf = result;
2870
	img->len += insert_count - remove_count;
2871
	result[img->len] = '\0';
2872

2873
	/* Adjust the line table */
2874
	nr = img->nr + postimage->nr - preimage_limit;
2875
	if (preimage_limit < postimage->nr) {
2876
		/*
2877
		 * NOTE: this knows that we never call remove_first_line()
2878
		 * on anything other than pre/post image.
2879
		 */
2880
		REALLOC_ARRAY(img->line, nr);
2881
		img->line_allocated = img->line;
2882
	}
2883
	if (preimage_limit != postimage->nr)
2884
		MOVE_ARRAY(img->line + applied_pos + postimage->nr,
2885
			   img->line + applied_pos + preimage_limit,
2886
			   img->nr - (applied_pos + preimage_limit));
2887
	COPY_ARRAY(img->line + applied_pos, postimage->line, postimage->nr);
2888
	if (!state->allow_overlap)
2889
		for (i = 0; i < postimage->nr; i++)
2890
			img->line[applied_pos + i].flag |= LINE_PATCHED;
2891
	img->nr = nr;
2892
}
2893

2894
/*
2895
 * Use the patch-hunk text in "frag" to prepare two images (preimage and
2896
 * postimage) for the hunk.  Find lines that match "preimage" in "img" and
2897
 * replace the part of "img" with "postimage" text.
2898
 */
2899
static int apply_one_fragment(struct apply_state *state,
2900
			      struct image *img, struct fragment *frag,
2901
			      int inaccurate_eof, unsigned ws_rule,
2902
			      int nth_fragment)
2903
{
2904
	int match_beginning, match_end;
2905
	const char *patch = frag->patch;
2906
	int size = frag->size;
2907
	char *old, *oldlines;
2908
	struct strbuf newlines;
2909
	int new_blank_lines_at_end = 0;
2910
	int found_new_blank_lines_at_end = 0;
2911
	int hunk_linenr = frag->linenr;
2912
	unsigned long leading, trailing;
2913
	int pos, applied_pos;
2914
	struct image preimage;
2915
	struct image postimage;
2916

2917
	memset(&preimage, 0, sizeof(preimage));
2918
	memset(&postimage, 0, sizeof(postimage));
2919
	oldlines = xmalloc(size);
2920
	strbuf_init(&newlines, size);
2921

2922
	old = oldlines;
2923
	while (size > 0) {
2924
		char first;
2925
		int len = linelen(patch, size);
2926
		int plen;
2927
		int added_blank_line = 0;
2928
		int is_blank_context = 0;
2929
		size_t start;
2930

2931
		if (!len)
2932
			break;
2933

2934
		/*
2935
		 * "plen" is how much of the line we should use for
2936
		 * the actual patch data. Normally we just remove the
2937
		 * first character on the line, but if the line is
2938
		 * followed by "\ No newline", then we also remove the
2939
		 * last one (which is the newline, of course).
2940
		 */
2941
		plen = len - 1;
2942
		if (len < size && patch[len] == '\\')
2943
			plen--;
2944
		first = *patch;
2945
		if (state->apply_in_reverse) {
2946
			if (first == '-')
2947
				first = '+';
2948
			else if (first == '+')
2949
				first = '-';
2950
		}
2951

2952
		switch (first) {
2953
		case '\n':
2954
			/* Newer GNU diff, empty context line */
2955
			if (plen < 0)
2956
				/* ... followed by '\No newline'; nothing */
2957
				break;
2958
			*old++ = '\n';
2959
			strbuf_addch(&newlines, '\n');
2960
			add_line_info(&preimage, "\n", 1, LINE_COMMON);
2961
			add_line_info(&postimage, "\n", 1, LINE_COMMON);
2962
			is_blank_context = 1;
2963
			break;
2964
		case ' ':
2965
			if (plen && (ws_rule & WS_BLANK_AT_EOF) &&
2966
			    ws_blank_line(patch + 1, plen))
2967
				is_blank_context = 1;
2968
			/* fallthrough */
2969
		case '-':
2970
			memcpy(old, patch + 1, plen);
2971
			add_line_info(&preimage, old, plen,
2972
				      (first == ' ' ? LINE_COMMON : 0));
2973
			old += plen;
2974
			if (first == '-')
2975
				break;
2976
			/* fallthrough */
2977
		case '+':
2978
			/* --no-add does not add new lines */
2979
			if (first == '+' && state->no_add)
2980
				break;
2981

2982
			start = newlines.len;
2983
			if (first != '+' ||
2984
			    !state->whitespace_error ||
2985
			    state->ws_error_action != correct_ws_error) {
2986
				strbuf_add(&newlines, patch + 1, plen);
2987
			}
2988
			else {
2989
				ws_fix_copy(&newlines, patch + 1, plen, ws_rule, &state->applied_after_fixing_ws);
2990
			}
2991
			add_line_info(&postimage, newlines.buf + start, newlines.len - start,
2992
				      (first == '+' ? 0 : LINE_COMMON));
2993
			if (first == '+' &&
2994
			    (ws_rule & WS_BLANK_AT_EOF) &&
2995
			    ws_blank_line(patch + 1, plen))
2996
				added_blank_line = 1;
2997
			break;
2998
		case '@': case '\\':
2999
			/* Ignore it, we already handled it */
3000
			break;
3001
		default:
3002
			if (state->apply_verbosity > verbosity_normal)
3003
				error(_("invalid start of line: '%c'"), first);
3004
			applied_pos = -1;
3005
			goto out;
3006
		}
3007
		if (added_blank_line) {
3008
			if (!new_blank_lines_at_end)
3009
				found_new_blank_lines_at_end = hunk_linenr;
3010
			new_blank_lines_at_end++;
3011
		}
3012
		else if (is_blank_context)
3013
			;
3014
		else
3015
			new_blank_lines_at_end = 0;
3016
		patch += len;
3017
		size -= len;
3018
		hunk_linenr++;
3019
	}
3020
	if (inaccurate_eof &&
3021
	    old > oldlines && old[-1] == '\n' &&
3022
	    newlines.len > 0 && newlines.buf[newlines.len - 1] == '\n') {
3023
		old--;
3024
		strbuf_setlen(&newlines, newlines.len - 1);
3025
		preimage.line_allocated[preimage.nr - 1].len--;
3026
		postimage.line_allocated[postimage.nr - 1].len--;
3027
	}
3028

3029
	leading = frag->leading;
3030
	trailing = frag->trailing;
3031

3032
	/*
3033
	 * A hunk to change lines at the beginning would begin with
3034
	 * @@ -1,L +N,M @@
3035
	 * but we need to be careful.  -U0 that inserts before the second
3036
	 * line also has this pattern.
3037
	 *
3038
	 * And a hunk to add to an empty file would begin with
3039
	 * @@ -0,0 +N,M @@
3040
	 *
3041
	 * In other words, a hunk that is (frag->oldpos <= 1) with or
3042
	 * without leading context must match at the beginning.
3043
	 */
3044
	match_beginning = (!frag->oldpos ||
3045
			   (frag->oldpos == 1 && !state->unidiff_zero));
3046

3047
	/*
3048
	 * A hunk without trailing lines must match at the end.
3049
	 * However, we simply cannot tell if a hunk must match end
3050
	 * from the lack of trailing lines if the patch was generated
3051
	 * with unidiff without any context.
3052
	 */
3053
	match_end = !state->unidiff_zero && !trailing;
3054

3055
	pos = frag->newpos ? (frag->newpos - 1) : 0;
3056
	preimage.buf = oldlines;
3057
	preimage.len = old - oldlines;
3058
	postimage.buf = newlines.buf;
3059
	postimage.len = newlines.len;
3060
	preimage.line = preimage.line_allocated;
3061
	postimage.line = postimage.line_allocated;
3062

3063
	for (;;) {
3064

3065
		applied_pos = find_pos(state, img, &preimage, &postimage, pos,
3066
				       ws_rule, match_beginning, match_end);
3067

3068
		if (applied_pos >= 0)
3069
			break;
3070

3071
		/* Am I at my context limits? */
3072
		if ((leading <= state->p_context) && (trailing <= state->p_context))
3073
			break;
3074
		if (match_beginning || match_end) {
3075
			match_beginning = match_end = 0;
3076
			continue;
3077
		}
3078

3079
		/*
3080
		 * Reduce the number of context lines; reduce both
3081
		 * leading and trailing if they are equal otherwise
3082
		 * just reduce the larger context.
3083
		 */
3084
		if (leading >= trailing) {
3085
			remove_first_line(&preimage);
3086
			remove_first_line(&postimage);
3087
			pos--;
3088
			leading--;
3089
		}
3090
		if (trailing > leading) {
3091
			remove_last_line(&preimage);
3092
			remove_last_line(&postimage);
3093
			trailing--;
3094
		}
3095
	}
3096

3097
	if (applied_pos >= 0) {
3098
		if (new_blank_lines_at_end &&
3099
		    preimage.nr + applied_pos >= img->nr &&
3100
		    (ws_rule & WS_BLANK_AT_EOF) &&
3101
		    state->ws_error_action != nowarn_ws_error) {
3102
			record_ws_error(state, WS_BLANK_AT_EOF, "+", 1,
3103
					found_new_blank_lines_at_end);
3104
			if (state->ws_error_action == correct_ws_error) {
3105
				while (new_blank_lines_at_end--)
3106
					remove_last_line(&postimage);
3107
			}
3108
			/*
3109
			 * We would want to prevent write_out_results()
3110
			 * from taking place in apply_patch() that follows
3111
			 * the callchain led us here, which is:
3112
			 * apply_patch->check_patch_list->check_patch->
3113
			 * apply_data->apply_fragments->apply_one_fragment
3114
			 */
3115
			if (state->ws_error_action == die_on_ws_error)
3116
				state->apply = 0;
3117
		}
3118

3119
		if (state->apply_verbosity > verbosity_normal && applied_pos != pos) {
3120
			int offset = applied_pos - pos;
3121
			if (state->apply_in_reverse)
3122
				offset = 0 - offset;
3123
			fprintf_ln(stderr,
3124
				   Q_("Hunk #%d succeeded at %d (offset %d line).",
3125
				      "Hunk #%d succeeded at %d (offset %d lines).",
3126
				      offset),
3127
				   nth_fragment, applied_pos + 1, offset);
3128
		}
3129

3130
		/*
3131
		 * Warn if it was necessary to reduce the number
3132
		 * of context lines.
3133
		 */
3134
		if ((leading != frag->leading ||
3135
		     trailing != frag->trailing) && state->apply_verbosity > verbosity_silent)
3136
			fprintf_ln(stderr, _("Context reduced to (%ld/%ld)"
3137
					     " to apply fragment at %d"),
3138
				   leading, trailing, applied_pos+1);
3139
		update_image(state, img, applied_pos, &preimage, &postimage);
3140
	} else {
3141
		if (state->apply_verbosity > verbosity_normal)
3142
			error(_("while searching for:\n%.*s"),
3143
			      (int)(old - oldlines), oldlines);
3144
	}
3145

3146
out:
3147
	free(oldlines);
3148
	strbuf_release(&newlines);
3149
	free(preimage.line_allocated);
3150
	free(postimage.line_allocated);
3151

3152
	return (applied_pos < 0);
3153
}
3154

3155
static int apply_binary_fragment(struct apply_state *state,
3156
				 struct image *img,
3157
				 struct patch *patch)
3158
{
3159
	struct fragment *fragment = patch->fragments;
3160
	unsigned long len;
3161
	void *dst;
3162

3163
	if (!fragment)
3164
		return error(_("missing binary patch data for '%s'"),
3165
			     patch->new_name ?
3166
			     patch->new_name :
3167
			     patch->old_name);
3168

3169
	/* Binary patch is irreversible without the optional second hunk */
3170
	if (state->apply_in_reverse) {
3171
		if (!fragment->next)
3172
			return error(_("cannot reverse-apply a binary patch "
3173
				       "without the reverse hunk to '%s'"),
3174
				     patch->new_name
3175
				     ? patch->new_name : patch->old_name);
3176
		fragment = fragment->next;
3177
	}
3178
	switch (fragment->binary_patch_method) {
3179
	case BINARY_DELTA_DEFLATED:
3180
		dst = patch_delta(img->buf, img->len, fragment->patch,
3181
				  fragment->size, &len);
3182
		if (!dst)
3183
			return -1;
3184
		clear_image(img);
3185
		img->buf = dst;
3186
		img->len = len;
3187
		return 0;
3188
	case BINARY_LITERAL_DEFLATED:
3189
		clear_image(img);
3190
		img->len = fragment->size;
3191
		img->buf = xmemdupz(fragment->patch, img->len);
3192
		return 0;
3193
	}
3194
	return -1;
3195
}
3196

3197
/*
3198
 * Replace "img" with the result of applying the binary patch.
3199
 * The binary patch data itself in patch->fragment is still kept
3200
 * but the preimage prepared by the caller in "img" is freed here
3201
 * or in the helper function apply_binary_fragment() this calls.
3202
 */
3203
static int apply_binary(struct apply_state *state,
3204
			struct image *img,
3205
			struct patch *patch)
3206
{
3207
	const char *name = patch->old_name ? patch->old_name : patch->new_name;
3208
	struct object_id oid;
3209
	const unsigned hexsz = the_hash_algo->hexsz;
3210

3211
	/*
3212
	 * For safety, we require patch index line to contain
3213
	 * full hex textual object ID for old and new, at least for now.
3214
	 */
3215
	if (strlen(patch->old_oid_prefix) != hexsz ||
3216
	    strlen(patch->new_oid_prefix) != hexsz ||
3217
	    get_oid_hex(patch->old_oid_prefix, &oid) ||
3218
	    get_oid_hex(patch->new_oid_prefix, &oid))
3219
		return error(_("cannot apply binary patch to '%s' "
3220
			       "without full index line"), name);
3221

3222
	if (patch->old_name) {
3223
		/*
3224
		 * See if the old one matches what the patch
3225
		 * applies to.
3226
		 */
3227
		hash_object_file(the_hash_algo, img->buf, img->len, OBJ_BLOB,
3228
				 &oid);
3229
		if (strcmp(oid_to_hex(&oid), patch->old_oid_prefix))
3230
			return error(_("the patch applies to '%s' (%s), "
3231
				       "which does not match the "
3232
				       "current contents."),
3233
				     name, oid_to_hex(&oid));
3234
	}
3235
	else {
3236
		/* Otherwise, the old one must be empty. */
3237
		if (img->len)
3238
			return error(_("the patch applies to an empty "
3239
				       "'%s' but it is not empty"), name);
3240
	}
3241

3242
	get_oid_hex(patch->new_oid_prefix, &oid);
3243
	if (is_null_oid(&oid)) {
3244
		clear_image(img);
3245
		return 0; /* deletion patch */
3246
	}
3247

3248
	if (has_object(the_repository, &oid, 0)) {
3249
		/* We already have the postimage */
3250
		enum object_type type;
3251
		unsigned long size;
3252
		char *result;
3253

3254
		result = repo_read_object_file(the_repository, &oid, &type,
3255
					       &size);
3256
		if (!result)
3257
			return error(_("the necessary postimage %s for "
3258
				       "'%s' cannot be read"),
3259
				     patch->new_oid_prefix, name);
3260
		clear_image(img);
3261
		img->buf = result;
3262
		img->len = size;
3263
	} else {
3264
		/*
3265
		 * We have verified buf matches the preimage;
3266
		 * apply the patch data to it, which is stored
3267
		 * in the patch->fragments->{patch,size}.
3268
		 */
3269
		if (apply_binary_fragment(state, img, patch))
3270
			return error(_("binary patch does not apply to '%s'"),
3271
				     name);
3272

3273
		/* verify that the result matches */
3274
		hash_object_file(the_hash_algo, img->buf, img->len, OBJ_BLOB,
3275
				 &oid);
3276
		if (strcmp(oid_to_hex(&oid), patch->new_oid_prefix))
3277
			return error(_("binary patch to '%s' creates incorrect result (expecting %s, got %s)"),
3278
				name, patch->new_oid_prefix, oid_to_hex(&oid));
3279
	}
3280

3281
	return 0;
3282
}
3283

3284
static int apply_fragments(struct apply_state *state, struct image *img, struct patch *patch)
3285
{
3286
	struct fragment *frag = patch->fragments;
3287
	const char *name = patch->old_name ? patch->old_name : patch->new_name;
3288
	unsigned ws_rule = patch->ws_rule;
3289
	unsigned inaccurate_eof = patch->inaccurate_eof;
3290
	int nth = 0;
3291

3292
	if (patch->is_binary)
3293
		return apply_binary(state, img, patch);
3294

3295
	while (frag) {
3296
		nth++;
3297
		if (apply_one_fragment(state, img, frag, inaccurate_eof, ws_rule, nth)) {
3298
			error(_("patch failed: %s:%ld"), name, frag->oldpos);
3299
			if (!state->apply_with_reject)
3300
				return -1;
3301
			frag->rejected = 1;
3302
		}
3303
		frag = frag->next;
3304
	}
3305
	return 0;
3306
}
3307

3308
static int read_blob_object(struct strbuf *buf, const struct object_id *oid, unsigned mode)
3309
{
3310
	if (S_ISGITLINK(mode)) {
3311
		strbuf_grow(buf, 100);
3312
		strbuf_addf(buf, "Subproject commit %s\n", oid_to_hex(oid));
3313
	} else {
3314
		enum object_type type;
3315
		unsigned long sz;
3316
		char *result;
3317

3318
		result = repo_read_object_file(the_repository, oid, &type,
3319
					       &sz);
3320
		if (!result)
3321
			return -1;
3322
		/* XXX read_sha1_file NUL-terminates */
3323
		strbuf_attach(buf, result, sz, sz + 1);
3324
	}
3325
	return 0;
3326
}
3327

3328
static int read_file_or_gitlink(const struct cache_entry *ce, struct strbuf *buf)
3329
{
3330
	if (!ce)
3331
		return 0;
3332
	return read_blob_object(buf, &ce->oid, ce->ce_mode);
3333
}
3334

3335
static struct patch *in_fn_table(struct apply_state *state, const char *name)
3336
{
3337
	struct string_list_item *item;
3338

3339
	if (!name)
3340
		return NULL;
3341

3342
	item = string_list_lookup(&state->fn_table, name);
3343
	if (item)
3344
		return (struct patch *)item->util;
3345

3346
	return NULL;
3347
}
3348

3349
/*
3350
 * item->util in the filename table records the status of the path.
3351
 * Usually it points at a patch (whose result records the contents
3352
 * of it after applying it), but it could be PATH_WAS_DELETED for a
3353
 * path that a previously applied patch has already removed, or
3354
 * PATH_TO_BE_DELETED for a path that a later patch would remove.
3355
 *
3356
 * The latter is needed to deal with a case where two paths A and B
3357
 * are swapped by first renaming A to B and then renaming B to A;
3358
 * moving A to B should not be prevented due to presence of B as we
3359
 * will remove it in a later patch.
3360
 */
3361
#define PATH_TO_BE_DELETED ((struct patch *) -2)
3362
#define PATH_WAS_DELETED ((struct patch *) -1)
3363

3364
static int to_be_deleted(struct patch *patch)
3365
{
3366
	return patch == PATH_TO_BE_DELETED;
3367
}
3368

3369
static int was_deleted(struct patch *patch)
3370
{
3371
	return patch == PATH_WAS_DELETED;
3372
}
3373

3374
static void add_to_fn_table(struct apply_state *state, struct patch *patch)
3375
{
3376
	struct string_list_item *item;
3377

3378
	/*
3379
	 * Always add new_name unless patch is a deletion
3380
	 * This should cover the cases for normal diffs,
3381
	 * file creations and copies
3382
	 */
3383
	if (patch->new_name) {
3384
		item = string_list_insert(&state->fn_table, patch->new_name);
3385
		item->util = patch;
3386
	}
3387

3388
	/*
3389
	 * store a failure on rename/deletion cases because
3390
	 * later chunks shouldn't patch old names
3391
	 */
3392
	if ((patch->new_name == NULL) || (patch->is_rename)) {
3393
		item = string_list_insert(&state->fn_table, patch->old_name);
3394
		item->util = PATH_WAS_DELETED;
3395
	}
3396
}
3397

3398
static void prepare_fn_table(struct apply_state *state, struct patch *patch)
3399
{
3400
	/*
3401
	 * store information about incoming file deletion
3402
	 */
3403
	while (patch) {
3404
		if ((patch->new_name == NULL) || (patch->is_rename)) {
3405
			struct string_list_item *item;
3406
			item = string_list_insert(&state->fn_table, patch->old_name);
3407
			item->util = PATH_TO_BE_DELETED;
3408
		}
3409
		patch = patch->next;
3410
	}
3411
}
3412

3413
static int checkout_target(struct index_state *istate,
3414
			   struct cache_entry *ce, struct stat *st)
3415
{
3416
	struct checkout costate = CHECKOUT_INIT;
3417

3418
	costate.refresh_cache = 1;
3419
	costate.istate = istate;
3420
	if (checkout_entry(ce, &costate, NULL, NULL) ||
3421
	    lstat(ce->name, st))
3422
		return error(_("cannot checkout %s"), ce->name);
3423
	return 0;
3424
}
3425

3426
static struct patch *previous_patch(struct apply_state *state,
3427
				    struct patch *patch,
3428
				    int *gone)
3429
{
3430
	struct patch *previous;
3431

3432
	*gone = 0;
3433
	if (patch->is_copy || patch->is_rename)
3434
		return NULL; /* "git" patches do not depend on the order */
3435

3436
	previous = in_fn_table(state, patch->old_name);
3437
	if (!previous)
3438
		return NULL;
3439

3440
	if (to_be_deleted(previous))
3441
		return NULL; /* the deletion hasn't happened yet */
3442

3443
	if (was_deleted(previous))
3444
		*gone = 1;
3445

3446
	return previous;
3447
}
3448

3449
static int verify_index_match(struct apply_state *state,
3450
			      const struct cache_entry *ce,
3451
			      struct stat *st)
3452
{
3453
	if (S_ISGITLINK(ce->ce_mode)) {
3454
		if (!S_ISDIR(st->st_mode))
3455
			return -1;
3456
		return 0;
3457
	}
3458
	return ie_match_stat(state->repo->index, ce, st,
3459
			     CE_MATCH_IGNORE_VALID | CE_MATCH_IGNORE_SKIP_WORKTREE);
3460
}
3461

3462
#define SUBMODULE_PATCH_WITHOUT_INDEX 1
3463

3464
static int load_patch_target(struct apply_state *state,
3465
			     struct strbuf *buf,
3466
			     const struct cache_entry *ce,
3467
			     struct stat *st,
3468
			     struct patch *patch,
3469
			     const char *name,
3470
			     unsigned expected_mode)
3471
{
3472
	if (state->cached || state->check_index) {
3473
		if (read_file_or_gitlink(ce, buf))
3474
			return error(_("failed to read %s"), name);
3475
	} else if (name) {
3476
		if (S_ISGITLINK(expected_mode)) {
3477
			if (ce)
3478
				return read_file_or_gitlink(ce, buf);
3479
			else
3480
				return SUBMODULE_PATCH_WITHOUT_INDEX;
3481
		} else if (has_symlink_leading_path(name, strlen(name))) {
3482
			return error(_("reading from '%s' beyond a symbolic link"), name);
3483
		} else {
3484
			if (read_old_data(st, patch, name, buf))
3485
				return error(_("failed to read %s"), name);
3486
		}
3487
	}
3488
	return 0;
3489
}
3490

3491
/*
3492
 * We are about to apply "patch"; populate the "image" with the
3493
 * current version we have, from the working tree or from the index,
3494
 * depending on the situation e.g. --cached/--index.  If we are
3495
 * applying a non-git patch that incrementally updates the tree,
3496
 * we read from the result of a previous diff.
3497
 */
3498
static int load_preimage(struct apply_state *state,
3499
			 struct image *image,
3500
			 struct patch *patch, struct stat *st,
3501
			 const struct cache_entry *ce)
3502
{
3503
	struct strbuf buf = STRBUF_INIT;
3504
	size_t len;
3505
	char *img;
3506
	struct patch *previous;
3507
	int status;
3508

3509
	previous = previous_patch(state, patch, &status);
3510
	if (status)
3511
		return error(_("path %s has been renamed/deleted"),
3512
			     patch->old_name);
3513
	if (previous) {
3514
		/* We have a patched copy in memory; use that. */
3515
		strbuf_add(&buf, previous->result, previous->resultsize);
3516
	} else {
3517
		status = load_patch_target(state, &buf, ce, st, patch,
3518
					   patch->old_name, patch->old_mode);
3519
		if (status < 0)
3520
			return status;
3521
		else if (status == SUBMODULE_PATCH_WITHOUT_INDEX) {
3522
			/*
3523
			 * There is no way to apply subproject
3524
			 * patch without looking at the index.
3525
			 * NEEDSWORK: shouldn't this be flagged
3526
			 * as an error???
3527
			 */
3528
			free_fragment_list(patch->fragments);
3529
			patch->fragments = NULL;
3530
		} else if (status) {
3531
			return error(_("failed to read %s"), patch->old_name);
3532
		}
3533
	}
3534

3535
	img = strbuf_detach(&buf, &len);
3536
	prepare_image(image, img, len, !patch->is_binary);
3537
	return 0;
3538
}
3539

3540
static int resolve_to(struct image *image, const struct object_id *result_id)
3541
{
3542
	unsigned long size;
3543
	enum object_type type;
3544

3545
	clear_image(image);
3546

3547
	image->buf = repo_read_object_file(the_repository, result_id, &type,
3548
					   &size);
3549
	if (!image->buf || type != OBJ_BLOB)
3550
		die("unable to read blob object %s", oid_to_hex(result_id));
3551
	image->len = size;
3552

3553
	return 0;
3554
}
3555

3556
static int three_way_merge(struct apply_state *state,
3557
			   struct image *image,
3558
			   char *path,
3559
			   const struct object_id *base,
3560
			   const struct object_id *ours,
3561
			   const struct object_id *theirs)
3562
{
3563
	mmfile_t base_file, our_file, their_file;
3564
	mmbuffer_t result = { NULL };
3565
	enum ll_merge_result status;
3566

3567
	/* resolve trivial cases first */
3568
	if (oideq(base, ours))
3569
		return resolve_to(image, theirs);
3570
	else if (oideq(base, theirs) || oideq(ours, theirs))
3571
		return resolve_to(image, ours);
3572

3573
	read_mmblob(&base_file, base);
3574
	read_mmblob(&our_file, ours);
3575
	read_mmblob(&their_file, theirs);
3576
	status = ll_merge(&result, path,
3577
			  &base_file, "base",
3578
			  &our_file, "ours",
3579
			  &their_file, "theirs",
3580
			  state->repo->index,
3581
			  NULL);
3582
	if (status == LL_MERGE_BINARY_CONFLICT)
3583
		warning("Cannot merge binary files: %s (%s vs. %s)",
3584
			path, "ours", "theirs");
3585
	free(base_file.ptr);
3586
	free(our_file.ptr);
3587
	free(their_file.ptr);
3588
	if (status < 0 || !result.ptr) {
3589
		free(result.ptr);
3590
		return -1;
3591
	}
3592
	clear_image(image);
3593
	image->buf = result.ptr;
3594
	image->len = result.size;
3595

3596
	return status;
3597
}
3598

3599
/*
3600
 * When directly falling back to add/add three-way merge, we read from
3601
 * the current contents of the new_name.  In no cases other than that
3602
 * this function will be called.
3603
 */
3604
static int load_current(struct apply_state *state,
3605
			struct image *image,
3606
			struct patch *patch)
3607
{
3608
	struct strbuf buf = STRBUF_INIT;
3609
	int status, pos;
3610
	size_t len;
3611
	char *img;
3612
	struct stat st;
3613
	struct cache_entry *ce;
3614
	char *name = patch->new_name;
3615
	unsigned mode = patch->new_mode;
3616

3617
	if (!patch->is_new)
3618
		BUG("patch to %s is not a creation", patch->old_name);
3619

3620
	pos = index_name_pos(state->repo->index, name, strlen(name));
3621
	if (pos < 0)
3622
		return error(_("%s: does not exist in index"), name);
3623
	ce = state->repo->index->cache[pos];
3624
	if (lstat(name, &st)) {
3625
		if (errno != ENOENT)
3626
			return error_errno("%s", name);
3627
		if (checkout_target(state->repo->index, ce, &st))
3628
			return -1;
3629
	}
3630
	if (verify_index_match(state, ce, &st))
3631
		return error(_("%s: does not match index"), name);
3632

3633
	status = load_patch_target(state, &buf, ce, &st, patch, name, mode);
3634
	if (status < 0)
3635
		return status;
3636
	else if (status)
3637
		return -1;
3638
	img = strbuf_detach(&buf, &len);
3639
	prepare_image(image, img, len, !patch->is_binary);
3640
	return 0;
3641
}
3642

3643
static int try_threeway(struct apply_state *state,
3644
			struct image *image,
3645
			struct patch *patch,
3646
			struct stat *st,
3647
			const struct cache_entry *ce)
3648
{
3649
	struct object_id pre_oid, post_oid, our_oid;
3650
	struct strbuf buf = STRBUF_INIT;
3651
	size_t len;
3652
	int status;
3653
	char *img;
3654
	struct image tmp_image;
3655

3656
	/* No point falling back to 3-way merge in these cases */
3657
	if (patch->is_delete ||
3658
	    S_ISGITLINK(patch->old_mode) || S_ISGITLINK(patch->new_mode) ||
3659
	    (patch->is_new && !patch->direct_to_threeway) ||
3660
	    (patch->is_rename && !patch->lines_added && !patch->lines_deleted))
3661
		return -1;
3662

3663
	/* Preimage the patch was prepared for */
3664
	if (patch->is_new)
3665
		write_object_file("", 0, OBJ_BLOB, &pre_oid);
3666
	else if (repo_get_oid(the_repository, patch->old_oid_prefix, &pre_oid) ||
3667
		 read_blob_object(&buf, &pre_oid, patch->old_mode))
3668
		return error(_("repository lacks the necessary blob to perform 3-way merge."));
3669

3670
	if (state->apply_verbosity > verbosity_silent && patch->direct_to_threeway)
3671
		fprintf(stderr, _("Performing three-way merge...\n"));
3672

3673
	img = strbuf_detach(&buf, &len);
3674
	prepare_image(&tmp_image, img, len, 1);
3675
	/* Apply the patch to get the post image */
3676
	if (apply_fragments(state, &tmp_image, patch) < 0) {
3677
		clear_image(&tmp_image);
3678
		return -1;
3679
	}
3680
	/* post_oid is theirs */
3681
	write_object_file(tmp_image.buf, tmp_image.len, OBJ_BLOB, &post_oid);
3682
	clear_image(&tmp_image);
3683

3684
	/* our_oid is ours */
3685
	if (patch->is_new) {
3686
		if (load_current(state, &tmp_image, patch))
3687
			return error(_("cannot read the current contents of '%s'"),
3688
				     patch->new_name);
3689
	} else {
3690
		if (load_preimage(state, &tmp_image, patch, st, ce))
3691
			return error(_("cannot read the current contents of '%s'"),
3692
				     patch->old_name);
3693
	}
3694
	write_object_file(tmp_image.buf, tmp_image.len, OBJ_BLOB, &our_oid);
3695
	clear_image(&tmp_image);
3696

3697
	/* in-core three-way merge between post and our using pre as base */
3698
	status = three_way_merge(state, image, patch->new_name,
3699
				 &pre_oid, &our_oid, &post_oid);
3700
	if (status < 0) {
3701
		if (state->apply_verbosity > verbosity_silent)
3702
			fprintf(stderr,
3703
				_("Failed to perform three-way merge...\n"));
3704
		return status;
3705
	}
3706

3707
	if (status) {
3708
		patch->conflicted_threeway = 1;
3709
		if (patch->is_new)
3710
			oidclr(&patch->threeway_stage[0], the_repository->hash_algo);
3711
		else
3712
			oidcpy(&patch->threeway_stage[0], &pre_oid);
3713
		oidcpy(&patch->threeway_stage[1], &our_oid);
3714
		oidcpy(&patch->threeway_stage[2], &post_oid);
3715
		if (state->apply_verbosity > verbosity_silent)
3716
			fprintf(stderr,
3717
				_("Applied patch to '%s' with conflicts.\n"),
3718
				patch->new_name);
3719
	} else {
3720
		if (state->apply_verbosity > verbosity_silent)
3721
			fprintf(stderr,
3722
				_("Applied patch to '%s' cleanly.\n"),
3723
				patch->new_name);
3724
	}
3725
	return 0;
3726
}
3727

3728
static int apply_data(struct apply_state *state, struct patch *patch,
3729
		      struct stat *st, const struct cache_entry *ce)
3730
{
3731
	struct image image;
3732

3733
	if (load_preimage(state, &image, patch, st, ce) < 0)
3734
		return -1;
3735

3736
	if (!state->threeway || try_threeway(state, &image, patch, st, ce) < 0) {
3737
		if (state->apply_verbosity > verbosity_silent &&
3738
		    state->threeway && !patch->direct_to_threeway)
3739
			fprintf(stderr, _("Falling back to direct application...\n"));
3740

3741
		/* Note: with --reject, apply_fragments() returns 0 */
3742
		if (patch->direct_to_threeway || apply_fragments(state, &image, patch) < 0) {
3743
			clear_image(&image);
3744
			return -1;
3745
		}
3746
	}
3747
	patch->result = image.buf;
3748
	patch->resultsize = image.len;
3749
	add_to_fn_table(state, patch);
3750
	free(image.line_allocated);
3751

3752
	if (0 < patch->is_delete && patch->resultsize)
3753
		return error(_("removal patch leaves file contents"));
3754

3755
	return 0;
3756
}
3757

3758
/*
3759
 * If "patch" that we are looking at modifies or deletes what we have,
3760
 * we would want it not to lose any local modification we have, either
3761
 * in the working tree or in the index.
3762
 *
3763
 * This also decides if a non-git patch is a creation patch or a
3764
 * modification to an existing empty file.  We do not check the state
3765
 * of the current tree for a creation patch in this function; the caller
3766
 * check_patch() separately makes sure (and errors out otherwise) that
3767
 * the path the patch creates does not exist in the current tree.
3768
 */
3769
static int check_preimage(struct apply_state *state,
3770
			  struct patch *patch,
3771
			  struct cache_entry **ce,
3772
			  struct stat *st)
3773
{
3774
	const char *old_name = patch->old_name;
3775
	struct patch *previous = NULL;
3776
	int stat_ret = 0, status;
3777
	unsigned st_mode = 0;
3778

3779
	if (!old_name)
3780
		return 0;
3781

3782
	assert(patch->is_new <= 0);
3783
	previous = previous_patch(state, patch, &status);
3784

3785
	if (status)
3786
		return error(_("path %s has been renamed/deleted"), old_name);
3787
	if (previous) {
3788
		st_mode = previous->new_mode;
3789
	} else if (!state->cached) {
3790
		stat_ret = lstat(old_name, st);
3791
		if (stat_ret && errno != ENOENT)
3792
			return error_errno("%s", old_name);
3793
	}
3794

3795
	if (state->check_index && !previous) {
3796
		int pos = index_name_pos(state->repo->index, old_name,
3797
					 strlen(old_name));
3798
		if (pos < 0) {
3799
			if (patch->is_new < 0)
3800
				goto is_new;
3801
			return error(_("%s: does not exist in index"), old_name);
3802
		}
3803
		*ce = state->repo->index->cache[pos];
3804
		if (stat_ret < 0) {
3805
			if (checkout_target(state->repo->index, *ce, st))
3806
				return -1;
3807
		}
3808
		if (!state->cached && verify_index_match(state, *ce, st))
3809
			return error(_("%s: does not match index"), old_name);
3810
		if (state->cached)
3811
			st_mode = (*ce)->ce_mode;
3812
	} else if (stat_ret < 0) {
3813
		if (patch->is_new < 0)
3814
			goto is_new;
3815
		return error_errno("%s", old_name);
3816
	}
3817

3818
	if (!state->cached && !previous) {
3819
		if (*ce && !(*ce)->ce_mode)
3820
			BUG("ce_mode == 0 for path '%s'", old_name);
3821

3822
		if (trust_executable_bit)
3823
			st_mode = ce_mode_from_stat(*ce, st->st_mode);
3824
		else if (*ce)
3825
			st_mode = (*ce)->ce_mode;
3826
		else
3827
			st_mode = patch->old_mode;
3828
	}
3829

3830
	if (patch->is_new < 0)
3831
		patch->is_new = 0;
3832
	if (!patch->old_mode)
3833
		patch->old_mode = st_mode;
3834
	if ((st_mode ^ patch->old_mode) & S_IFMT)
3835
		return error(_("%s: wrong type"), old_name);
3836
	if (st_mode != patch->old_mode)
3837
		warning(_("%s has type %o, expected %o"),
3838
			old_name, st_mode, patch->old_mode);
3839
	if (!patch->new_mode && !patch->is_delete)
3840
		patch->new_mode = st_mode;
3841
	return 0;
3842

3843
 is_new:
3844
	patch->is_new = 1;
3845
	patch->is_delete = 0;
3846
	FREE_AND_NULL(patch->old_name);
3847
	return 0;
3848
}
3849

3850

3851
#define EXISTS_IN_INDEX 1
3852
#define EXISTS_IN_WORKTREE 2
3853
#define EXISTS_IN_INDEX_AS_ITA 3
3854

3855
static int check_to_create(struct apply_state *state,
3856
			   const char *new_name,
3857
			   int ok_if_exists)
3858
{
3859
	struct stat nst;
3860

3861
	if (state->check_index && (!ok_if_exists || !state->cached)) {
3862
		int pos;
3863

3864
		pos = index_name_pos(state->repo->index, new_name, strlen(new_name));
3865
		if (pos >= 0) {
3866
			struct cache_entry *ce = state->repo->index->cache[pos];
3867

3868
			/* allow ITA, as they do not yet exist in the index */
3869
			if (!ok_if_exists && !(ce->ce_flags & CE_INTENT_TO_ADD))
3870
				return EXISTS_IN_INDEX;
3871

3872
			/* ITA entries can never match working tree files */
3873
			if (!state->cached && (ce->ce_flags & CE_INTENT_TO_ADD))
3874
				return EXISTS_IN_INDEX_AS_ITA;
3875
		}
3876
	}
3877

3878
	if (state->cached)
3879
		return 0;
3880

3881
	if (!lstat(new_name, &nst)) {
3882
		if (S_ISDIR(nst.st_mode) || ok_if_exists)
3883
			return 0;
3884
		/*
3885
		 * A leading component of new_name might be a symlink
3886
		 * that is going to be removed with this patch, but
3887
		 * still pointing at somewhere that has the path.
3888
		 * In such a case, path "new_name" does not exist as
3889
		 * far as git is concerned.
3890
		 */
3891
		if (has_symlink_leading_path(new_name, strlen(new_name)))
3892
			return 0;
3893

3894
		return EXISTS_IN_WORKTREE;
3895
	} else if (!is_missing_file_error(errno)) {
3896
		return error_errno("%s", new_name);
3897
	}
3898
	return 0;
3899
}
3900

3901
static void prepare_symlink_changes(struct apply_state *state, struct patch *patch)
3902
{
3903
	for ( ; patch; patch = patch->next) {
3904
		if ((patch->old_name && S_ISLNK(patch->old_mode)) &&
3905
		    (patch->is_rename || patch->is_delete))
3906
			/* the symlink at patch->old_name is removed */
3907
			strset_add(&state->removed_symlinks, patch->old_name);
3908

3909
		if (patch->new_name && S_ISLNK(patch->new_mode))
3910
			/* the symlink at patch->new_name is created or remains */
3911
			strset_add(&state->kept_symlinks, patch->new_name);
3912
	}
3913
}
3914

3915
static int path_is_beyond_symlink_1(struct apply_state *state, struct strbuf *name)
3916
{
3917
	do {
3918
		while (--name->len && name->buf[name->len] != '/')
3919
			; /* scan backwards */
3920
		if (!name->len)
3921
			break;
3922
		name->buf[name->len] = '\0';
3923
		if (strset_contains(&state->kept_symlinks, name->buf))
3924
			return 1;
3925
		if (strset_contains(&state->removed_symlinks, name->buf))
3926
			/*
3927
			 * This cannot be "return 0", because we may
3928
			 * see a new one created at a higher level.
3929
			 */
3930
			continue;
3931

3932
		/* otherwise, check the preimage */
3933
		if (state->check_index) {
3934
			struct cache_entry *ce;
3935

3936
			ce = index_file_exists(state->repo->index, name->buf,
3937
					       name->len, ignore_case);
3938
			if (ce && S_ISLNK(ce->ce_mode))
3939
				return 1;
3940
		} else {
3941
			struct stat st;
3942
			if (!lstat(name->buf, &st) && S_ISLNK(st.st_mode))
3943
				return 1;
3944
		}
3945
	} while (1);
3946
	return 0;
3947
}
3948

3949
static int path_is_beyond_symlink(struct apply_state *state, const char *name_)
3950
{
3951
	int ret;
3952
	struct strbuf name = STRBUF_INIT;
3953

3954
	assert(*name_ != '\0');
3955
	strbuf_addstr(&name, name_);
3956
	ret = path_is_beyond_symlink_1(state, &name);
3957
	strbuf_release(&name);
3958

3959
	return ret;
3960
}
3961

3962
static int check_unsafe_path(struct patch *patch)
3963
{
3964
	const char *old_name = NULL;
3965
	const char *new_name = NULL;
3966
	if (patch->is_delete)
3967
		old_name = patch->old_name;
3968
	else if (!patch->is_new && !patch->is_copy)
3969
		old_name = patch->old_name;
3970
	if (!patch->is_delete)
3971
		new_name = patch->new_name;
3972

3973
	if (old_name && !verify_path(old_name, patch->old_mode))
3974
		return error(_("invalid path '%s'"), old_name);
3975
	if (new_name && !verify_path(new_name, patch->new_mode))
3976
		return error(_("invalid path '%s'"), new_name);
3977
	return 0;
3978
}
3979

3980
/*
3981
 * Check and apply the patch in-core; leave the result in patch->result
3982
 * for the caller to write it out to the final destination.
3983
 */
3984
static int check_patch(struct apply_state *state, struct patch *patch)
3985
{
3986
	struct stat st;
3987
	const char *old_name = patch->old_name;
3988
	const char *new_name = patch->new_name;
3989
	const char *name = old_name ? old_name : new_name;
3990
	struct cache_entry *ce = NULL;
3991
	struct patch *tpatch;
3992
	int ok_if_exists;
3993
	int status;
3994

3995
	patch->rejected = 1; /* we will drop this after we succeed */
3996

3997
	status = check_preimage(state, patch, &ce, &st);
3998
	if (status)
3999
		return status;
4000
	old_name = patch->old_name;
4001

4002
	/*
4003
	 * A type-change diff is always split into a patch to delete
4004
	 * old, immediately followed by a patch to create new (see
4005
	 * diff.c::run_diff()); in such a case it is Ok that the entry
4006
	 * to be deleted by the previous patch is still in the working
4007
	 * tree and in the index.
4008
	 *
4009
	 * A patch to swap-rename between A and B would first rename A
4010
	 * to B and then rename B to A.  While applying the first one,
4011
	 * the presence of B should not stop A from getting renamed to
4012
	 * B; ask to_be_deleted() about the later rename.  Removal of
4013
	 * B and rename from A to B is handled the same way by asking
4014
	 * was_deleted().
4015
	 */
4016
	if ((tpatch = in_fn_table(state, new_name)) &&
4017
	    (was_deleted(tpatch) || to_be_deleted(tpatch)))
4018
		ok_if_exists = 1;
4019
	else
4020
		ok_if_exists = 0;
4021

4022
	if (new_name &&
4023
	    ((0 < patch->is_new) || patch->is_rename || patch->is_copy)) {
4024
		int err = check_to_create(state, new_name, ok_if_exists);
4025

4026
		if (err && state->threeway) {
4027
			patch->direct_to_threeway = 1;
4028
		} else switch (err) {
4029
		case 0:
4030
			break; /* happy */
4031
		case EXISTS_IN_INDEX:
4032
			return error(_("%s: already exists in index"), new_name);
4033
		case EXISTS_IN_INDEX_AS_ITA:
4034
			return error(_("%s: does not match index"), new_name);
4035
		case EXISTS_IN_WORKTREE:
4036
			return error(_("%s: already exists in working directory"),
4037
				     new_name);
4038
		default:
4039
			return err;
4040
		}
4041

4042
		if (!patch->new_mode) {
4043
			if (0 < patch->is_new)
4044
				patch->new_mode = S_IFREG | 0644;
4045
			else
4046
				patch->new_mode = patch->old_mode;
4047
		}
4048
	}
4049

4050
	if (new_name && old_name) {
4051
		int same = !strcmp(old_name, new_name);
4052
		if (!patch->new_mode)
4053
			patch->new_mode = patch->old_mode;
4054
		if ((patch->old_mode ^ patch->new_mode) & S_IFMT) {
4055
			if (same)
4056
				return error(_("new mode (%o) of %s does not "
4057
					       "match old mode (%o)"),
4058
					patch->new_mode, new_name,
4059
					patch->old_mode);
4060
			else
4061
				return error(_("new mode (%o) of %s does not "
4062
					       "match old mode (%o) of %s"),
4063
					patch->new_mode, new_name,
4064
					patch->old_mode, old_name);
4065
		}
4066
	}
4067

4068
	if (!state->unsafe_paths && check_unsafe_path(patch))
4069
		return -128;
4070

4071
	/*
4072
	 * An attempt to read from or delete a path that is beyond a
4073
	 * symbolic link will be prevented by load_patch_target() that
4074
	 * is called at the beginning of apply_data() so we do not
4075
	 * have to worry about a patch marked with "is_delete" bit
4076
	 * here.  We however need to make sure that the patch result
4077
	 * is not deposited to a path that is beyond a symbolic link
4078
	 * here.
4079
	 */
4080
	if (!patch->is_delete && path_is_beyond_symlink(state, patch->new_name))
4081
		return error(_("affected file '%s' is beyond a symbolic link"),
4082
			     patch->new_name);
4083

4084
	if (apply_data(state, patch, &st, ce) < 0)
4085
		return error(_("%s: patch does not apply"), name);
4086
	patch->rejected = 0;
4087
	return 0;
4088
}
4089

4090
static int check_patch_list(struct apply_state *state, struct patch *patch)
4091
{
4092
	int err = 0;
4093

4094
	prepare_symlink_changes(state, patch);
4095
	prepare_fn_table(state, patch);
4096
	while (patch) {
4097
		int res;
4098
		if (state->apply_verbosity > verbosity_normal)
4099
			say_patch_name(stderr,
4100
				       _("Checking patch %s..."), patch);
4101
		res = check_patch(state, patch);
4102
		if (res == -128)
4103
			return -128;
4104
		err |= res;
4105
		patch = patch->next;
4106
	}
4107
	return err;
4108
}
4109

4110
static int read_apply_cache(struct apply_state *state)
4111
{
4112
	if (state->index_file)
4113
		return read_index_from(state->repo->index, state->index_file,
4114
				       get_git_dir());
4115
	else
4116
		return repo_read_index(state->repo);
4117
}
4118

4119
/* This function tries to read the object name from the current index */
4120
static int get_current_oid(struct apply_state *state, const char *path,
4121
			   struct object_id *oid)
4122
{
4123
	int pos;
4124

4125
	if (read_apply_cache(state) < 0)
4126
		return -1;
4127
	pos = index_name_pos(state->repo->index, path, strlen(path));
4128
	if (pos < 0)
4129
		return -1;
4130
	oidcpy(oid, &state->repo->index->cache[pos]->oid);
4131
	return 0;
4132
}
4133

4134
static int preimage_oid_in_gitlink_patch(struct patch *p, struct object_id *oid)
4135
{
4136
	/*
4137
	 * A usable gitlink patch has only one fragment (hunk) that looks like:
4138
	 * @@ -1 +1 @@
4139
	 * -Subproject commit <old sha1>
4140
	 * +Subproject commit <new sha1>
4141
	 * or
4142
	 * @@ -1 +0,0 @@
4143
	 * -Subproject commit <old sha1>
4144
	 * for a removal patch.
4145
	 */
4146
	struct fragment *hunk = p->fragments;
4147
	static const char heading[] = "-Subproject commit ";
4148
	char *preimage;
4149

4150
	if (/* does the patch have only one hunk? */
4151
	    hunk && !hunk->next &&
4152
	    /* is its preimage one line? */
4153
	    hunk->oldpos == 1 && hunk->oldlines == 1 &&
4154
	    /* does preimage begin with the heading? */
4155
	    (preimage = memchr(hunk->patch, '\n', hunk->size)) != NULL &&
4156
	    starts_with(++preimage, heading) &&
4157
	    /* does it record full SHA-1? */
4158
	    !get_oid_hex(preimage + sizeof(heading) - 1, oid) &&
4159
	    preimage[sizeof(heading) + the_hash_algo->hexsz - 1] == '\n' &&
4160
	    /* does the abbreviated name on the index line agree with it? */
4161
	    starts_with(preimage + sizeof(heading) - 1, p->old_oid_prefix))
4162
		return 0; /* it all looks fine */
4163

4164
	/* we may have full object name on the index line */
4165
	return get_oid_hex(p->old_oid_prefix, oid);
4166
}
4167

4168
/* Build an index that contains just the files needed for a 3way merge */
4169
static int build_fake_ancestor(struct apply_state *state, struct patch *list)
4170
{
4171
	struct patch *patch;
4172
	struct index_state result = INDEX_STATE_INIT(state->repo);
4173
	struct lock_file lock = LOCK_INIT;
4174
	int res;
4175

4176
	/* Once we start supporting the reverse patch, it may be
4177
	 * worth showing the new sha1 prefix, but until then...
4178
	 */
4179
	for (patch = list; patch; patch = patch->next) {
4180
		struct object_id oid;
4181
		struct cache_entry *ce;
4182
		const char *name;
4183

4184
		name = patch->old_name ? patch->old_name : patch->new_name;
4185
		if (0 < patch->is_new)
4186
			continue;
4187

4188
		if (S_ISGITLINK(patch->old_mode)) {
4189
			if (!preimage_oid_in_gitlink_patch(patch, &oid))
4190
				; /* ok, the textual part looks sane */
4191
			else
4192
				return error(_("sha1 information is lacking or "
4193
					       "useless for submodule %s"), name);
4194
		} else if (!repo_get_oid_blob(the_repository, patch->old_oid_prefix, &oid)) {
4195
			; /* ok */
4196
		} else if (!patch->lines_added && !patch->lines_deleted) {
4197
			/* mode-only change: update the current */
4198
			if (get_current_oid(state, patch->old_name, &oid))
4199
				return error(_("mode change for %s, which is not "
4200
					       "in current HEAD"), name);
4201
		} else
4202
			return error(_("sha1 information is lacking or useless "
4203
				       "(%s)."), name);
4204

4205
		ce = make_cache_entry(&result, patch->old_mode, &oid, name, 0, 0);
4206
		if (!ce)
4207
			return error(_("make_cache_entry failed for path '%s'"),
4208
				     name);
4209
		if (add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD)) {
4210
			discard_cache_entry(ce);
4211
			return error(_("could not add %s to temporary index"),
4212
				     name);
4213
		}
4214
	}
4215

4216
	hold_lock_file_for_update(&lock, state->fake_ancestor, LOCK_DIE_ON_ERROR);
4217
	res = write_locked_index(&result, &lock, COMMIT_LOCK);
4218
	discard_index(&result);
4219

4220
	if (res)
4221
		return error(_("could not write temporary index to %s"),
4222
			     state->fake_ancestor);
4223

4224
	return 0;
4225
}
4226

4227
static void stat_patch_list(struct apply_state *state, struct patch *patch)
4228
{
4229
	int files, adds, dels;
4230

4231
	for (files = adds = dels = 0 ; patch ; patch = patch->next) {
4232
		files++;
4233
		adds += patch->lines_added;
4234
		dels += patch->lines_deleted;
4235
		show_stats(state, patch);
4236
	}
4237

4238
	print_stat_summary(stdout, files, adds, dels);
4239
}
4240

4241
static void numstat_patch_list(struct apply_state *state,
4242
			       struct patch *patch)
4243
{
4244
	for ( ; patch; patch = patch->next) {
4245
		const char *name;
4246
		name = patch->new_name ? patch->new_name : patch->old_name;
4247
		if (patch->is_binary)
4248
			printf("-\t-\t");
4249
		else
4250
			printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);
4251
		write_name_quoted(name, stdout, state->line_termination);
4252
	}
4253
}
4254

4255
static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)
4256
{
4257
	if (mode)
4258
		printf(" %s mode %06o %s\n", newdelete, mode, name);
4259
	else
4260
		printf(" %s %s\n", newdelete, name);
4261
}
4262

4263
static void show_mode_change(struct patch *p, int show_name)
4264
{
4265
	if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {
4266
		if (show_name)
4267
			printf(" mode change %06o => %06o %s\n",
4268
			       p->old_mode, p->new_mode, p->new_name);
4269
		else
4270
			printf(" mode change %06o => %06o\n",
4271
			       p->old_mode, p->new_mode);
4272
	}
4273
}
4274

4275
static void show_rename_copy(struct patch *p)
4276
{
4277
	const char *renamecopy = p->is_rename ? "rename" : "copy";
4278
	const char *old_name, *new_name;
4279

4280
	/* Find common prefix */
4281
	old_name = p->old_name;
4282
	new_name = p->new_name;
4283
	while (1) {
4284
		const char *slash_old, *slash_new;
4285
		slash_old = strchr(old_name, '/');
4286
		slash_new = strchr(new_name, '/');
4287
		if (!slash_old ||
4288
		    !slash_new ||
4289
		    slash_old - old_name != slash_new - new_name ||
4290
		    memcmp(old_name, new_name, slash_new - new_name))
4291
			break;
4292
		old_name = slash_old + 1;
4293
		new_name = slash_new + 1;
4294
	}
4295
	/* p->old_name through old_name is the common prefix, and old_name and
4296
	 * new_name through the end of names are renames
4297
	 */
4298
	if (old_name != p->old_name)
4299
		printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,
4300
		       (int)(old_name - p->old_name), p->old_name,
4301
		       old_name, new_name, p->score);
4302
	else
4303
		printf(" %s %s => %s (%d%%)\n", renamecopy,
4304
		       p->old_name, p->new_name, p->score);
4305
	show_mode_change(p, 0);
4306
}
4307

4308
static void summary_patch_list(struct patch *patch)
4309
{
4310
	struct patch *p;
4311

4312
	for (p = patch; p; p = p->next) {
4313
		if (p->is_new)
4314
			show_file_mode_name("create", p->new_mode, p->new_name);
4315
		else if (p->is_delete)
4316
			show_file_mode_name("delete", p->old_mode, p->old_name);
4317
		else {
4318
			if (p->is_rename || p->is_copy)
4319
				show_rename_copy(p);
4320
			else {
4321
				if (p->score) {
4322
					printf(" rewrite %s (%d%%)\n",
4323
					       p->new_name, p->score);
4324
					show_mode_change(p, 0);
4325
				}
4326
				else
4327
					show_mode_change(p, 1);
4328
			}
4329
		}
4330
	}
4331
}
4332

4333
static void patch_stats(struct apply_state *state, struct patch *patch)
4334
{
4335
	int lines = patch->lines_added + patch->lines_deleted;
4336

4337
	if (lines > state->max_change)
4338
		state->max_change = lines;
4339
	if (patch->old_name) {
4340
		int len = quote_c_style(patch->old_name, NULL, NULL, 0);
4341
		if (!len)
4342
			len = strlen(patch->old_name);
4343
		if (len > state->max_len)
4344
			state->max_len = len;
4345
	}
4346
	if (patch->new_name) {
4347
		int len = quote_c_style(patch->new_name, NULL, NULL, 0);
4348
		if (!len)
4349
			len = strlen(patch->new_name);
4350
		if (len > state->max_len)
4351
			state->max_len = len;
4352
	}
4353
}
4354

4355
static int remove_file(struct apply_state *state, struct patch *patch, int rmdir_empty)
4356
{
4357
	if (state->update_index && !state->ita_only) {
4358
		if (remove_file_from_index(state->repo->index, patch->old_name) < 0)
4359
			return error(_("unable to remove %s from index"), patch->old_name);
4360
	}
4361
	if (!state->cached) {
4362
		if (!remove_or_warn(patch->old_mode, patch->old_name) && rmdir_empty) {
4363
			remove_path(patch->old_name);
4364
		}
4365
	}
4366
	return 0;
4367
}
4368

4369
static int add_index_file(struct apply_state *state,
4370
			  const char *path,
4371
			  unsigned mode,
4372
			  void *buf,
4373
			  unsigned long size)
4374
{
4375
	struct stat st;
4376
	struct cache_entry *ce;
4377
	int namelen = strlen(path);
4378

4379
	ce = make_empty_cache_entry(state->repo->index, namelen);
4380
	memcpy(ce->name, path, namelen);
4381
	ce->ce_mode = create_ce_mode(mode);
4382
	ce->ce_flags = create_ce_flags(0);
4383
	ce->ce_namelen = namelen;
4384
	if (state->ita_only) {
4385
		ce->ce_flags |= CE_INTENT_TO_ADD;
4386
		set_object_name_for_intent_to_add_entry(ce);
4387
	} else if (S_ISGITLINK(mode)) {
4388
		const char *s;
4389

4390
		if (!skip_prefix(buf, "Subproject commit ", &s) ||
4391
		    get_oid_hex(s, &ce->oid)) {
4392
			discard_cache_entry(ce);
4393
			return error(_("corrupt patch for submodule %s"), path);
4394
		}
4395
	} else {
4396
		if (!state->cached) {
4397
			if (lstat(path, &st) < 0) {
4398
				discard_cache_entry(ce);
4399
				return error_errno(_("unable to stat newly "
4400
						     "created file '%s'"),
4401
						   path);
4402
			}
4403
			fill_stat_cache_info(state->repo->index, ce, &st);
4404
		}
4405
		if (write_object_file(buf, size, OBJ_BLOB, &ce->oid) < 0) {
4406
			discard_cache_entry(ce);
4407
			return error(_("unable to create backing store "
4408
				       "for newly created file %s"), path);
4409
		}
4410
	}
4411
	if (add_index_entry(state->repo->index, ce, ADD_CACHE_OK_TO_ADD) < 0) {
4412
		discard_cache_entry(ce);
4413
		return error(_("unable to add cache entry for %s"), path);
4414
	}
4415

4416
	return 0;
4417
}
4418

4419
/*
4420
 * Returns:
4421
 *  -1 if an unrecoverable error happened
4422
 *   0 if everything went well
4423
 *   1 if a recoverable error happened
4424
 */
4425
static int try_create_file(struct apply_state *state, const char *path,
4426
			   unsigned int mode, const char *buf,
4427
			   unsigned long size)
4428
{
4429
	int fd, res;
4430
	struct strbuf nbuf = STRBUF_INIT;
4431

4432
	if (S_ISGITLINK(mode)) {
4433
		struct stat st;
4434
		if (!lstat(path, &st) && S_ISDIR(st.st_mode))
4435
			return 0;
4436
		return !!mkdir(path, 0777);
4437
	}
4438

4439
	if (has_symlinks && S_ISLNK(mode))
4440
		/* Although buf:size is counted string, it also is NUL
4441
		 * terminated.
4442
		 */
4443
		return !!symlink(buf, path);
4444

4445
	fd = open(path, O_CREAT | O_EXCL | O_WRONLY, (mode & 0100) ? 0777 : 0666);
4446
	if (fd < 0)
4447
		return 1;
4448

4449
	if (convert_to_working_tree(state->repo->index, path, buf, size, &nbuf, NULL)) {
4450
		size = nbuf.len;
4451
		buf  = nbuf.buf;
4452
	}
4453

4454
	res = write_in_full(fd, buf, size) < 0;
4455
	if (res)
4456
		error_errno(_("failed to write to '%s'"), path);
4457
	strbuf_release(&nbuf);
4458

4459
	if (close(fd) < 0 && !res)
4460
		return error_errno(_("closing file '%s'"), path);
4461

4462
	return res ? -1 : 0;
4463
}
4464

4465
/*
4466
 * We optimistically assume that the directories exist,
4467
 * which is true 99% of the time anyway. If they don't,
4468
 * we create them and try again.
4469
 *
4470
 * Returns:
4471
 *   -1 on error
4472
 *   0 otherwise
4473
 */
4474
static int create_one_file(struct apply_state *state,
4475
			   char *path,
4476
			   unsigned mode,
4477
			   const char *buf,
4478
			   unsigned long size)
4479
{
4480
	char *newpath = NULL;
4481
	int res;
4482

4483
	if (state->cached)
4484
		return 0;
4485

4486
	/*
4487
	 * We already try to detect whether files are beyond a symlink in our
4488
	 * up-front checks. But in the case where symlinks are created by any
4489
	 * of the intermediate hunks it can happen that our up-front checks
4490
	 * didn't yet see the symlink, but at the point of arriving here there
4491
	 * in fact is one. We thus repeat the check for symlinks here.
4492
	 *
4493
	 * Note that this does not make the up-front check obsolete as the
4494
	 * failure mode is different:
4495
	 *
4496
	 * - The up-front checks cause us to abort before we have written
4497
	 *   anything into the working directory. So when we exit this way the
4498
	 *   working directory remains clean.
4499
	 *
4500
	 * - The checks here happen in the middle of the action where we have
4501
	 *   already started to apply the patch. The end result will be a dirty
4502
	 *   working directory.
4503
	 *
4504
	 * Ideally, we should update the up-front checks to catch what would
4505
	 * happen when we apply the patch before we damage the working tree.
4506
	 * We have all the information necessary to do so.  But for now, as a
4507
	 * part of embargoed security work, having this check would serve as a
4508
	 * reasonable first step.
4509
	 */
4510
	if (path_is_beyond_symlink(state, path))
4511
		return error(_("affected file '%s' is beyond a symbolic link"), path);
4512

4513
	res = try_create_file(state, path, mode, buf, size);
4514
	if (res < 0)
4515
		return -1;
4516
	if (!res)
4517
		return 0;
4518

4519
	if (errno == ENOENT) {
4520
		if (safe_create_leading_directories_no_share(path))
4521
			return 0;
4522
		res = try_create_file(state, path, mode, buf, size);
4523
		if (res < 0)
4524
			return -1;
4525
		if (!res)
4526
			return 0;
4527
	}
4528

4529
	if (errno == EEXIST || errno == EACCES) {
4530
		/* We may be trying to create a file where a directory
4531
		 * used to be.
4532
		 */
4533
		struct stat st;
4534
		if (!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))
4535
			errno = EEXIST;
4536
	}
4537

4538
	if (errno == EEXIST) {
4539
		unsigned int nr = getpid();
4540

4541
		for (;;) {
4542
			newpath = mkpathdup("%s~%u", path, nr);
4543
			res = try_create_file(state, newpath, mode, buf, size);
4544
			if (res < 0)
4545
				goto out;
4546
			if (!res) {
4547
				if (!rename(newpath, path))
4548
					goto out;
4549
				unlink_or_warn(newpath);
4550
				break;
4551
			}
4552
			if (errno != EEXIST)
4553
				break;
4554
			++nr;
4555
			FREE_AND_NULL(newpath);
4556
		}
4557
	}
4558
	res = error_errno(_("unable to write file '%s' mode %o"), path, mode);
4559
out:
4560
	free(newpath);
4561
	return res;
4562
}
4563

4564
static int add_conflicted_stages_file(struct apply_state *state,
4565
				       struct patch *patch)
4566
{
4567
	int stage, namelen;
4568
	unsigned mode;
4569
	struct cache_entry *ce;
4570

4571
	if (!state->update_index)
4572
		return 0;
4573
	namelen = strlen(patch->new_name);
4574
	mode = patch->new_mode ? patch->new_mode : (S_IFREG | 0644);
4575

4576
	remove_file_from_index(state->repo->index, patch->new_name);
4577
	for (stage = 1; stage < 4; stage++) {
4578
		if (is_null_oid(&patch->threeway_stage[stage - 1]))
4579
			continue;
4580
		ce = make_empty_cache_entry(state->repo->index, namelen);
4581
		memcpy(ce->name, patch->new_name, namelen);
4582
		ce->ce_mode = create_ce_mode(mode);
4583
		ce->ce_flags = create_ce_flags(stage);
4584
		ce->ce_namelen = namelen;
4585
		oidcpy(&ce->oid, &patch->threeway_stage[stage - 1]);
4586
		if (add_index_entry(state->repo->index, ce, ADD_CACHE_OK_TO_ADD) < 0) {
4587
			discard_cache_entry(ce);
4588
			return error(_("unable to add cache entry for %s"),
4589
				     patch->new_name);
4590
		}
4591
	}
4592

4593
	return 0;
4594
}
4595

4596
static int create_file(struct apply_state *state, struct patch *patch)
4597
{
4598
	char *path = patch->new_name;
4599
	unsigned mode = patch->new_mode;
4600
	unsigned long size = patch->resultsize;
4601
	char *buf = patch->result;
4602

4603
	if (!mode)
4604
		mode = S_IFREG | 0644;
4605
	if (create_one_file(state, path, mode, buf, size))
4606
		return -1;
4607

4608
	if (patch->conflicted_threeway)
4609
		return add_conflicted_stages_file(state, patch);
4610
	else if (state->update_index)
4611
		return add_index_file(state, path, mode, buf, size);
4612
	return 0;
4613
}
4614

4615
/* phase zero is to remove, phase one is to create */
4616
static int write_out_one_result(struct apply_state *state,
4617
				struct patch *patch,
4618
				int phase)
4619
{
4620
	if (patch->is_delete > 0) {
4621
		if (phase == 0)
4622
			return remove_file(state, patch, 1);
4623
		return 0;
4624
	}
4625
	if (patch->is_new > 0 || patch->is_copy) {
4626
		if (phase == 1)
4627
			return create_file(state, patch);
4628
		return 0;
4629
	}
4630
	/*
4631
	 * Rename or modification boils down to the same
4632
	 * thing: remove the old, write the new
4633
	 */
4634
	if (phase == 0)
4635
		return remove_file(state, patch, patch->is_rename);
4636
	if (phase == 1)
4637
		return create_file(state, patch);
4638
	return 0;
4639
}
4640

4641
static int write_out_one_reject(struct apply_state *state, struct patch *patch)
4642
{
4643
	FILE *rej;
4644
	char *namebuf;
4645
	struct fragment *frag;
4646
	int fd, cnt = 0;
4647
	struct strbuf sb = STRBUF_INIT;
4648

4649
	for (cnt = 0, frag = patch->fragments; frag; frag = frag->next) {
4650
		if (!frag->rejected)
4651
			continue;
4652
		cnt++;
4653
	}
4654

4655
	if (!cnt) {
4656
		if (state->apply_verbosity > verbosity_normal)
4657
			say_patch_name(stderr,
4658
				       _("Applied patch %s cleanly."), patch);
4659
		return 0;
4660
	}
4661

4662
	/* This should not happen, because a removal patch that leaves
4663
	 * contents are marked "rejected" at the patch level.
4664
	 */
4665
	if (!patch->new_name)
4666
		die(_("internal error"));
4667

4668
	/* Say this even without --verbose */
4669
	strbuf_addf(&sb, Q_("Applying patch %%s with %d reject...",
4670
			    "Applying patch %%s with %d rejects...",
4671
			    cnt),
4672
		    cnt);
4673
	if (state->apply_verbosity > verbosity_silent)
4674
		say_patch_name(stderr, sb.buf, patch);
4675
	strbuf_release(&sb);
4676

4677
	namebuf = xstrfmt("%s.rej", patch->new_name);
4678

4679
	fd = open(namebuf, O_CREAT | O_EXCL | O_WRONLY, 0666);
4680
	if (fd < 0) {
4681
		if (errno != EEXIST) {
4682
			error_errno(_("cannot open %s"), namebuf);
4683
			goto error;
4684
		}
4685
		if (unlink(namebuf)) {
4686
			error_errno(_("cannot unlink '%s'"), namebuf);
4687
			goto error;
4688
		}
4689
		fd = open(namebuf, O_CREAT | O_EXCL | O_WRONLY, 0666);
4690
		if (fd < 0) {
4691
			error_errno(_("cannot open %s"), namebuf);
4692
			goto error;
4693
		}
4694
	}
4695
	rej = fdopen(fd, "w");
4696
	if (!rej) {
4697
		error_errno(_("cannot open %s"), namebuf);
4698
		close(fd);
4699
		goto error;
4700
	}
4701

4702
	/* Normal git tools never deal with .rej, so do not pretend
4703
	 * this is a git patch by saying --git or giving extended
4704
	 * headers.  While at it, maybe please "kompare" that wants
4705
	 * the trailing TAB and some garbage at the end of line ;-).
4706
	 */
4707
	fprintf(rej, "diff a/%s b/%s\t(rejected hunks)\n",
4708
		patch->new_name, patch->new_name);
4709
	for (cnt = 1, frag = patch->fragments;
4710
	     frag;
4711
	     cnt++, frag = frag->next) {
4712
		if (!frag->rejected) {
4713
			if (state->apply_verbosity > verbosity_silent)
4714
				fprintf_ln(stderr, _("Hunk #%d applied cleanly."), cnt);
4715
			continue;
4716
		}
4717
		if (state->apply_verbosity > verbosity_silent)
4718
			fprintf_ln(stderr, _("Rejected hunk #%d."), cnt);
4719
		fprintf(rej, "%.*s", frag->size, frag->patch);
4720
		if (frag->patch[frag->size-1] != '\n')
4721
			fputc('\n', rej);
4722
	}
4723
	fclose(rej);
4724
error:
4725
	free(namebuf);
4726
	return -1;
4727
}
4728

4729
/*
4730
 * Returns:
4731
 *  -1 if an error happened
4732
 *   0 if the patch applied cleanly
4733
 *   1 if the patch did not apply cleanly
4734
 */
4735
static int write_out_results(struct apply_state *state, struct patch *list)
4736
{
4737
	int phase;
4738
	int errs = 0;
4739
	struct patch *l;
4740
	struct string_list cpath = STRING_LIST_INIT_DUP;
4741

4742
	for (phase = 0; phase < 2; phase++) {
4743
		l = list;
4744
		while (l) {
4745
			if (l->rejected)
4746
				errs = 1;
4747
			else {
4748
				if (write_out_one_result(state, l, phase)) {
4749
					string_list_clear(&cpath, 0);
4750
					return -1;
4751
				}
4752
				if (phase == 1) {
4753
					if (write_out_one_reject(state, l))
4754
						errs = 1;
4755
					if (l->conflicted_threeway) {
4756
						string_list_append(&cpath, l->new_name);
4757
						errs = 1;
4758
					}
4759
				}
4760
			}
4761
			l = l->next;
4762
		}
4763
	}
4764

4765
	if (cpath.nr) {
4766
		struct string_list_item *item;
4767

4768
		string_list_sort(&cpath);
4769
		if (state->apply_verbosity > verbosity_silent) {
4770
			for_each_string_list_item(item, &cpath)
4771
				fprintf(stderr, "U %s\n", item->string);
4772
		}
4773
		string_list_clear(&cpath, 0);
4774

4775
		/*
4776
		 * rerere relies on the partially merged result being in the working
4777
		 * tree with conflict markers, but that isn't written with --cached.
4778
		 */
4779
		if (!state->cached)
4780
			repo_rerere(state->repo, 0);
4781
	}
4782

4783
	return errs;
4784
}
4785

4786
/*
4787
 * Try to apply a patch.
4788
 *
4789
 * Returns:
4790
 *  -128 if a bad error happened (like patch unreadable)
4791
 *  -1 if patch did not apply and user cannot deal with it
4792
 *   0 if the patch applied
4793
 *   1 if the patch did not apply but user might fix it
4794
 */
4795
static int apply_patch(struct apply_state *state,
4796
		       int fd,
4797
		       const char *filename,
4798
		       int options)
4799
{
4800
	size_t offset;
4801
	struct strbuf buf = STRBUF_INIT; /* owns the patch text */
4802
	struct patch *list = NULL, **listp = &list;
4803
	int skipped_patch = 0;
4804
	int res = 0;
4805
	int flush_attributes = 0;
4806

4807
	state->patch_input_file = filename;
4808
	if (read_patch_file(&buf, fd) < 0)
4809
		return -128;
4810
	offset = 0;
4811
	while (offset < buf.len) {
4812
		struct patch *patch;
4813
		int nr;
4814

4815
		CALLOC_ARRAY(patch, 1);
4816
		patch->inaccurate_eof = !!(options & APPLY_OPT_INACCURATE_EOF);
4817
		patch->recount =  !!(options & APPLY_OPT_RECOUNT);
4818
		nr = parse_chunk(state, buf.buf + offset, buf.len - offset, patch);
4819
		if (nr < 0) {
4820
			free_patch(patch);
4821
			if (nr == -128) {
4822
				res = -128;
4823
				goto end;
4824
			}
4825
			break;
4826
		}
4827
		if (state->apply_in_reverse)
4828
			reverse_patches(patch);
4829
		if (use_patch(state, patch)) {
4830
			patch_stats(state, patch);
4831
			if (!list || !state->apply_in_reverse) {
4832
				*listp = patch;
4833
				listp = &patch->next;
4834
			} else {
4835
				patch->next = list;
4836
				list = patch;
4837
			}
4838

4839
			if ((patch->new_name &&
4840
			     ends_with_path_components(patch->new_name,
4841
						       GITATTRIBUTES_FILE)) ||
4842
			    (patch->old_name &&
4843
			     ends_with_path_components(patch->old_name,
4844
						       GITATTRIBUTES_FILE)))
4845
				flush_attributes = 1;
4846
		}
4847
		else {
4848
			if (state->apply_verbosity > verbosity_normal)
4849
				say_patch_name(stderr, _("Skipped patch '%s'."), patch);
4850
			free_patch(patch);
4851
			skipped_patch++;
4852
		}
4853
		offset += nr;
4854
	}
4855

4856
	if (!list && !skipped_patch) {
4857
		if (!state->allow_empty) {
4858
			error(_("No valid patches in input (allow with \"--allow-empty\")"));
4859
			res = -128;
4860
		}
4861
		goto end;
4862
	}
4863

4864
	if (state->whitespace_error && (state->ws_error_action == die_on_ws_error))
4865
		state->apply = 0;
4866

4867
	state->update_index = (state->check_index || state->ita_only) && state->apply;
4868
	if (state->update_index && !is_lock_file_locked(&state->lock_file)) {
4869
		if (state->index_file)
4870
			hold_lock_file_for_update(&state->lock_file,
4871
						  state->index_file,
4872
						  LOCK_DIE_ON_ERROR);
4873
		else
4874
			repo_hold_locked_index(state->repo, &state->lock_file,
4875
					       LOCK_DIE_ON_ERROR);
4876
	}
4877

4878
	if (state->check_index && read_apply_cache(state) < 0) {
4879
		error(_("unable to read index file"));
4880
		res = -128;
4881
		goto end;
4882
	}
4883

4884
	if (state->check || state->apply) {
4885
		int r = check_patch_list(state, list);
4886
		if (r == -128) {
4887
			res = -128;
4888
			goto end;
4889
		}
4890
		if (r < 0 && !state->apply_with_reject) {
4891
			res = -1;
4892
			goto end;
4893
		}
4894
	}
4895

4896
	if (state->apply) {
4897
		int write_res = write_out_results(state, list);
4898
		if (write_res < 0) {
4899
			res = -128;
4900
			goto end;
4901
		}
4902
		if (write_res > 0) {
4903
			/* with --3way, we still need to write the index out */
4904
			res = state->apply_with_reject ? -1 : 1;
4905
			goto end;
4906
		}
4907
	}
4908

4909
	if (state->fake_ancestor &&
4910
	    build_fake_ancestor(state, list)) {
4911
		res = -128;
4912
		goto end;
4913
	}
4914

4915
	if (state->diffstat && state->apply_verbosity > verbosity_silent)
4916
		stat_patch_list(state, list);
4917

4918
	if (state->numstat && state->apply_verbosity > verbosity_silent)
4919
		numstat_patch_list(state, list);
4920

4921
	if (state->summary && state->apply_verbosity > verbosity_silent)
4922
		summary_patch_list(list);
4923

4924
	if (flush_attributes)
4925
		reset_parsed_attributes();
4926
end:
4927
	free_patch_list(list);
4928
	strbuf_release(&buf);
4929
	string_list_clear(&state->fn_table, 0);
4930
	return res;
4931
}
4932

4933
static int apply_option_parse_exclude(const struct option *opt,
4934
				      const char *arg, int unset)
4935
{
4936
	struct apply_state *state = opt->value;
4937

4938
	BUG_ON_OPT_NEG(unset);
4939

4940
	add_name_limit(state, arg, 1);
4941
	return 0;
4942
}
4943

4944
static int apply_option_parse_include(const struct option *opt,
4945
				      const char *arg, int unset)
4946
{
4947
	struct apply_state *state = opt->value;
4948

4949
	BUG_ON_OPT_NEG(unset);
4950

4951
	add_name_limit(state, arg, 0);
4952
	state->has_include = 1;
4953
	return 0;
4954
}
4955

4956
static int apply_option_parse_p(const struct option *opt,
4957
				const char *arg,
4958
				int unset)
4959
{
4960
	struct apply_state *state = opt->value;
4961

4962
	BUG_ON_OPT_NEG(unset);
4963

4964
	state->p_value = atoi(arg);
4965
	state->p_value_known = 1;
4966
	return 0;
4967
}
4968

4969
static int apply_option_parse_space_change(const struct option *opt,
4970
					   const char *arg, int unset)
4971
{
4972
	struct apply_state *state = opt->value;
4973

4974
	BUG_ON_OPT_ARG(arg);
4975

4976
	if (unset)
4977
		state->ws_ignore_action = ignore_ws_none;
4978
	else
4979
		state->ws_ignore_action = ignore_ws_change;
4980
	return 0;
4981
}
4982

4983
static int apply_option_parse_whitespace(const struct option *opt,
4984
					 const char *arg, int unset)
4985
{
4986
	struct apply_state *state = opt->value;
4987

4988
	BUG_ON_OPT_NEG(unset);
4989

4990
	state->whitespace_option = arg;
4991
	if (parse_whitespace_option(state, arg))
4992
		return -1;
4993
	return 0;
4994
}
4995

4996
static int apply_option_parse_directory(const struct option *opt,
4997
					const char *arg, int unset)
4998
{
4999
	struct apply_state *state = opt->value;
5000

5001
	BUG_ON_OPT_NEG(unset);
5002

5003
	strbuf_reset(&state->root);
5004
	strbuf_addstr(&state->root, arg);
5005
	strbuf_complete(&state->root, '/');
5006
	return 0;
5007
}
5008

5009
int apply_all_patches(struct apply_state *state,
5010
		      int argc,
5011
		      const char **argv,
5012
		      int options)
5013
{
5014
	int i;
5015
	int res;
5016
	int errs = 0;
5017
	int read_stdin = 1;
5018

5019
	for (i = 0; i < argc; i++) {
5020
		const char *arg = argv[i];
5021
		char *to_free = NULL;
5022
		int fd;
5023

5024
		if (!strcmp(arg, "-")) {
5025
			res = apply_patch(state, 0, "<stdin>", options);
5026
			if (res < 0)
5027
				goto end;
5028
			errs |= res;
5029
			read_stdin = 0;
5030
			continue;
5031
		} else
5032
			arg = to_free = prefix_filename(state->prefix, arg);
5033

5034
		fd = open(arg, O_RDONLY);
5035
		if (fd < 0) {
5036
			error(_("can't open patch '%s': %s"), arg, strerror(errno));
5037
			res = -128;
5038
			free(to_free);
5039
			goto end;
5040
		}
5041
		read_stdin = 0;
5042
		set_default_whitespace_mode(state);
5043
		res = apply_patch(state, fd, arg, options);
5044
		close(fd);
5045
		free(to_free);
5046
		if (res < 0)
5047
			goto end;
5048
		errs |= res;
5049
	}
5050
	set_default_whitespace_mode(state);
5051
	if (read_stdin) {
5052
		res = apply_patch(state, 0, "<stdin>", options);
5053
		if (res < 0)
5054
			goto end;
5055
		errs |= res;
5056
	}
5057

5058
	if (state->whitespace_error) {
5059
		if (state->squelch_whitespace_errors &&
5060
		    state->squelch_whitespace_errors < state->whitespace_error) {
5061
			int squelched =
5062
				state->whitespace_error - state->squelch_whitespace_errors;
5063
			warning(Q_("squelched %d whitespace error",
5064
				   "squelched %d whitespace errors",
5065
				   squelched),
5066
				squelched);
5067
		}
5068
		if (state->ws_error_action == die_on_ws_error) {
5069
			error(Q_("%d line adds whitespace errors.",
5070
				 "%d lines add whitespace errors.",
5071
				 state->whitespace_error),
5072
			      state->whitespace_error);
5073
			res = -128;
5074
			goto end;
5075
		}
5076
		if (state->applied_after_fixing_ws && state->apply)
5077
			warning(Q_("%d line applied after"
5078
				   " fixing whitespace errors.",
5079
				   "%d lines applied after"
5080
				   " fixing whitespace errors.",
5081
				   state->applied_after_fixing_ws),
5082
				state->applied_after_fixing_ws);
5083
		else if (state->whitespace_error)
5084
			warning(Q_("%d line adds whitespace errors.",
5085
				   "%d lines add whitespace errors.",
5086
				   state->whitespace_error),
5087
				state->whitespace_error);
5088
	}
5089

5090
	if (state->update_index) {
5091
		res = write_locked_index(state->repo->index, &state->lock_file, COMMIT_LOCK);
5092
		if (res) {
5093
			error(_("Unable to write new index file"));
5094
			res = -128;
5095
			goto end;
5096
		}
5097
	}
5098

5099
	res = !!errs;
5100

5101
end:
5102
	rollback_lock_file(&state->lock_file);
5103

5104
	if (state->apply_verbosity <= verbosity_silent) {
5105
		set_error_routine(state->saved_error_routine);
5106
		set_warn_routine(state->saved_warn_routine);
5107
	}
5108

5109
	if (res > -1)
5110
		return res;
5111
	return (res == -1 ? 1 : 128);
5112
}
5113

5114
int apply_parse_options(int argc, const char **argv,
5115
			struct apply_state *state,
5116
			int *force_apply, int *options,
5117
			const char * const *apply_usage)
5118
{
5119
	struct option builtin_apply_options[] = {
5120
		OPT_CALLBACK_F(0, "exclude", state, N_("path"),
5121
			N_("don't apply changes matching the given path"),
5122
			PARSE_OPT_NONEG, apply_option_parse_exclude),
5123
		OPT_CALLBACK_F(0, "include", state, N_("path"),
5124
			N_("apply changes matching the given path"),
5125
			PARSE_OPT_NONEG, apply_option_parse_include),
5126
		OPT_CALLBACK('p', NULL, state, N_("num"),
5127
			N_("remove <num> leading slashes from traditional diff paths"),
5128
			apply_option_parse_p),
5129
		OPT_BOOL(0, "no-add", &state->no_add,
5130
			N_("ignore additions made by the patch")),
5131
		OPT_BOOL(0, "stat", &state->diffstat,
5132
			N_("instead of applying the patch, output diffstat for the input")),
5133
		OPT_NOOP_NOARG(0, "allow-binary-replacement"),
5134
		OPT_NOOP_NOARG(0, "binary"),
5135
		OPT_BOOL(0, "numstat", &state->numstat,
5136
			N_("show number of added and deleted lines in decimal notation")),
5137
		OPT_BOOL(0, "summary", &state->summary,
5138
			N_("instead of applying the patch, output a summary for the input")),
5139
		OPT_BOOL(0, "check", &state->check,
5140
			N_("instead of applying the patch, see if the patch is applicable")),
5141
		OPT_BOOL(0, "index", &state->check_index,
5142
			N_("make sure the patch is applicable to the current index")),
5143
		OPT_BOOL('N', "intent-to-add", &state->ita_only,
5144
			N_("mark new files with `git add --intent-to-add`")),
5145
		OPT_BOOL(0, "cached", &state->cached,
5146
			N_("apply a patch without touching the working tree")),
5147
		OPT_BOOL_F(0, "unsafe-paths", &state->unsafe_paths,
5148
			   N_("accept a patch that touches outside the working area"),
5149
			   PARSE_OPT_NOCOMPLETE),
5150
		OPT_BOOL(0, "apply", force_apply,
5151
			N_("also apply the patch (use with --stat/--summary/--check)")),
5152
		OPT_BOOL('3', "3way", &state->threeway,
5153
			 N_( "attempt three-way merge, fall back on normal patch if that fails")),
5154
		OPT_FILENAME(0, "build-fake-ancestor", &state->fake_ancestor,
5155
			N_("build a temporary index based on embedded index information")),
5156
		/* Think twice before adding "--nul" synonym to this */
5157
		OPT_SET_INT('z', NULL, &state->line_termination,
5158
			N_("paths are separated with NUL character"), '\0'),
5159
		OPT_INTEGER('C', NULL, &state->p_context,
5160
				N_("ensure at least <n> lines of context match")),
5161
		OPT_CALLBACK(0, "whitespace", state, N_("action"),
5162
			N_("detect new or modified lines that have whitespace errors"),
5163
			apply_option_parse_whitespace),
5164
		OPT_CALLBACK_F(0, "ignore-space-change", state, NULL,
5165
			N_("ignore changes in whitespace when finding context"),
5166
			PARSE_OPT_NOARG, apply_option_parse_space_change),
5167
		OPT_CALLBACK_F(0, "ignore-whitespace", state, NULL,
5168
			N_("ignore changes in whitespace when finding context"),
5169
			PARSE_OPT_NOARG, apply_option_parse_space_change),
5170
		OPT_BOOL('R', "reverse", &state->apply_in_reverse,
5171
			N_("apply the patch in reverse")),
5172
		OPT_BOOL(0, "unidiff-zero", &state->unidiff_zero,
5173
			N_("don't expect at least one line of context")),
5174
		OPT_BOOL(0, "reject", &state->apply_with_reject,
5175
			N_("leave the rejected hunks in corresponding *.rej files")),
5176
		OPT_BOOL(0, "allow-overlap", &state->allow_overlap,
5177
			N_("allow overlapping hunks")),
5178
		OPT__VERBOSITY(&state->apply_verbosity),
5179
		OPT_BIT(0, "inaccurate-eof", options,
5180
			N_("tolerate incorrectly detected missing new-line at the end of file"),
5181
			APPLY_OPT_INACCURATE_EOF),
5182
		OPT_BIT(0, "recount", options,
5183
			N_("do not trust the line counts in the hunk headers"),
5184
			APPLY_OPT_RECOUNT),
5185
		OPT_CALLBACK(0, "directory", state, N_("root"),
5186
			N_("prepend <root> to all filenames"),
5187
			apply_option_parse_directory),
5188
		OPT_BOOL(0, "allow-empty", &state->allow_empty,
5189
			N_("don't return error for empty patches")),
5190
		OPT_END()
5191
	};
5192

5193
	return parse_options(argc, argv, state->prefix, builtin_apply_options, apply_usage, 0);
5194
}
5195