git-apply: first cut at actually checking fragment data
[git] / apply.c
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  * NOTE! It does all its work in the index file, and only cares about
9  * the files in the working directory if you tell it to "merge" the
10  * patch apply.
11  *
12  * Even when merging it always takes the source from the index, and
13  * uses the working tree as a "branch" for a 3-way merge.
14  */
15 #include <ctype.h>
16
17 #include "cache.h"
18
19 // We default to the merge behaviour, since that's what most people would
20 // expect.
21 //
22 //  --check turns on checking that the working tree matches the
23 //    files that are being modified, but doesn't apply the patch
24 //  --stat does just a diffstat, and doesn't actually apply
25 //  --show-files shows the directory changes
26 //
27 static int merge_patch = 1;
28 static int check_index = 0;
29 static int diffstat = 0;
30 static int check = 0;
31 static int apply = 1;
32 static int show_files = 0;
33 static const char apply_usage[] = "git-apply [--stat] [--check] [--show-files] <patch>";
34
35 /*
36  * For "diff-stat" like behaviour, we keep track of the biggest change
37  * we've seen, and the longest filename. That allows us to do simple
38  * scaling.
39  */
40 static int max_change, max_len;
41
42 /*
43  * Various "current state", notably line numbers and what
44  * file (and how) we're patching right now.. The "is_xxxx"
45  * things are flags, where -1 means "don't know yet".
46  */
47 static int linenr = 1;
48
49 struct fragment {
50         unsigned long oldpos, oldlines;
51         unsigned long newpos, newlines;
52         const char *patch;
53         int size;
54         struct fragment *next;
55 };
56
57 struct patch {
58         char *new_name, *old_name, *def_name;
59         unsigned int old_mode, new_mode;
60         int is_rename, is_copy, is_new, is_delete;
61         int lines_added, lines_deleted;
62         struct fragment *fragments;
63         const char *result;
64         unsigned long resultsize;
65         struct patch *next;
66 };
67
68 #define CHUNKSIZE (8192)
69 #define SLOP (16)
70
71 static void *read_patch_file(int fd, unsigned long *sizep)
72 {
73         unsigned long size = 0, alloc = CHUNKSIZE;
74         void *buffer = xmalloc(alloc);
75
76         for (;;) {
77                 int nr = alloc - size;
78                 if (nr < 1024) {
79                         alloc += CHUNKSIZE;
80                         buffer = xrealloc(buffer, alloc);
81                         nr = alloc - size;
82                 }
83                 nr = read(fd, buffer + size, nr);
84                 if (!nr)
85                         break;
86                 if (nr < 0) {
87                         if (errno == EAGAIN)
88                                 continue;
89                         die("git-apply: read returned %s", strerror(errno));
90                 }
91                 size += nr;
92         }
93         *sizep = size;
94
95         /*
96          * Make sure that we have some slop in the buffer
97          * so that we can do speculative "memcmp" etc, and
98          * see to it that it is NUL-filled.
99          */
100         if (alloc < size + SLOP)
101                 buffer = xrealloc(buffer, size + SLOP);
102         memset(buffer + size, 0, SLOP);
103         return buffer;
104 }
105
106 static unsigned long linelen(const char *buffer, unsigned long size)
107 {
108         unsigned long len = 0;
109         while (size--) {
110                 len++;
111                 if (*buffer++ == '\n')
112                         break;
113         }
114         return len;
115 }
116
117 static int is_dev_null(const char *str)
118 {
119         return !memcmp("/dev/null", str, 9) && isspace(str[9]);
120 }
121
122 #define TERM_SPACE      1
123 #define TERM_TAB        2
124
125 static int name_terminate(const char *name, int namelen, int c, int terminate)
126 {
127         if (c == ' ' && !(terminate & TERM_SPACE))
128                 return 0;
129         if (c == '\t' && !(terminate & TERM_TAB))
130                 return 0;
131
132         return 1;
133 }
134
135 static char * find_name(const char *line, char *def, int p_value, int terminate)
136 {
137         int len;
138         const char *start = line;
139         char *name;
140
141         for (;;) {
142                 char c = *line;
143
144                 if (isspace(c)) {
145                         if (c == '\n')
146                                 break;
147                         if (name_terminate(start, line-start, c, terminate))
148                                 break;
149                 }
150                 line++;
151                 if (c == '/' && !--p_value)
152                         start = line;
153         }
154         if (!start)
155                 return def;
156         len = line - start;
157         if (!len)
158                 return def;
159
160         /*
161          * Generally we prefer the shorter name, especially
162          * if the other one is just a variation of that with
163          * something else tacked on to the end (ie "file.orig"
164          * or "file~").
165          */
166         if (def) {
167                 int deflen = strlen(def);
168                 if (deflen < len && !strncmp(start, def, deflen))
169                         return def;
170         }
171
172         name = xmalloc(len + 1);
173         memcpy(name, start, len);
174         name[len] = 0;
175         free(def);
176         return name;
177 }
178
179 /*
180  * Get the name etc info from the --/+++ lines of a traditional patch header
181  *
182  * NOTE! This hardcodes "-p1" behaviour in filename detection.
183  *
184  * FIXME! The end-of-filename heuristics are kind of screwy. For existing
185  * files, we can happily check the index for a match, but for creating a
186  * new file we should try to match whatever "patch" does. I have no idea.
187  */
188 static void parse_traditional_patch(const char *first, const char *second, struct patch *patch)
189 {
190         int p_value = 1;
191         char *name;
192
193         first += 4;     // skip "--- "
194         second += 4;    // skip "+++ "
195         if (is_dev_null(first)) {
196                 patch->is_new = 1;
197                 patch->is_delete = 0;
198                 name = find_name(second, NULL, p_value, TERM_SPACE | TERM_TAB);
199                 patch->new_name = name;
200         } else if (is_dev_null(second)) {
201                 patch->is_new = 0;
202                 patch->is_delete = 1;
203                 name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
204                 patch->old_name = name;
205         } else {
206                 name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
207                 name = find_name(second, name, p_value, TERM_SPACE | TERM_TAB);
208                 patch->old_name = patch->new_name = name;
209         }
210         if (!name)
211                 die("unable to find filename in patch at line %d", linenr);
212 }
213
214 static int gitdiff_hdrend(const char *line, struct patch *patch)
215 {
216         return -1;
217 }
218
219 /*
220  * We're anal about diff header consistency, to make
221  * sure that we don't end up having strange ambiguous
222  * patches floating around.
223  *
224  * As a result, gitdiff_{old|new}name() will check
225  * their names against any previous information, just
226  * to make sure..
227  */
228 static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, const char *oldnew)
229 {
230         int len;
231         const char *name;
232
233         if (!orig_name && !isnull)
234                 return find_name(line, NULL, 1, 0);
235
236         name = "/dev/null";
237         len = 9;
238         if (orig_name) {
239                 name = orig_name;
240                 len = strlen(name);
241                 if (isnull)
242                         die("git-apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr);
243         }
244
245         if (*name == '/')
246                 goto absolute_path;
247
248         for (;;) {
249                 char c = *line++;
250                 if (c == '\n')
251                         break;
252                 if (c != '/')
253                         continue;
254 absolute_path:
255                 if (memcmp(line, name, len) || line[len] != '\n')
256                         break;
257                 return orig_name;
258         }
259         die("git-apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr);
260         return NULL;
261 }
262
263 static int gitdiff_oldname(const char *line, struct patch *patch)
264 {
265         patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name, "old");
266         return 0;
267 }
268
269 static int gitdiff_newname(const char *line, struct patch *patch)
270 {
271         patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name, "new");
272         return 0;
273 }
274
275 static int gitdiff_oldmode(const char *line, struct patch *patch)
276 {
277         patch->old_mode = strtoul(line, NULL, 8);
278         return 0;
279 }
280
281 static int gitdiff_newmode(const char *line, struct patch *patch)
282 {
283         patch->new_mode = strtoul(line, NULL, 8);
284         return 0;
285 }
286
287 static int gitdiff_delete(const char *line, struct patch *patch)
288 {
289         patch->is_delete = 1;
290         patch->old_name = patch->def_name;
291         return gitdiff_oldmode(line, patch);
292 }
293
294 static int gitdiff_newfile(const char *line, struct patch *patch)
295 {
296         patch->is_new = 1;
297         patch->new_name = patch->def_name;
298         return gitdiff_newmode(line, patch);
299 }
300
301 static int gitdiff_copysrc(const char *line, struct patch *patch)
302 {
303         patch->is_copy = 1;
304         patch->old_name = find_name(line, NULL, 0, 0);
305         return 0;
306 }
307
308 static int gitdiff_copydst(const char *line, struct patch *patch)
309 {
310         patch->is_copy = 1;
311         patch->new_name = find_name(line, NULL, 0, 0);
312         return 0;
313 }
314
315 static int gitdiff_renamesrc(const char *line, struct patch *patch)
316 {
317         patch->is_rename = 1;
318         patch->old_name = find_name(line, NULL, 0, 0);
319         return 0;
320 }
321
322 static int gitdiff_renamedst(const char *line, struct patch *patch)
323 {
324         patch->is_rename = 1;
325         patch->new_name = find_name(line, NULL, 0, 0);
326         return 0;
327 }
328
329 static int gitdiff_similarity(const char *line, struct patch *patch)
330 {
331         return 0;
332 }
333
334 static int gitdiff_dissimilarity(const char *line, struct patch *patch)
335 {
336         return 0;
337 }
338
339 /*
340  * This is normal for a diff that doesn't change anything: we'll fall through
341  * into the next diff. Tell the parser to break out.
342  */
343 static int gitdiff_unrecognized(const char *line, struct patch *patch)
344 {
345         return -1;
346 }
347
348 static char *git_header_name(char *line)
349 {
350         int len;
351         char *name, *second;
352
353         /*
354          * Find the first '/'
355          */
356         name = line;
357         for (;;) {
358                 char c = *name++;
359                 if (c == '\n')
360                         return NULL;
361                 if (c == '/')
362                         break;
363         }
364
365         /*
366          * We don't accept absolute paths (/dev/null) as possibly valid
367          */
368         if (name == line+1)
369                 return NULL;
370
371         /*
372          * Accept a name only if it shows up twice, exactly the same
373          * form.
374          */
375         for (len = 0 ; ; len++) {
376                 char c = name[len];
377
378                 switch (c) {
379                 default:
380                         continue;
381                 case '\n':
382                         break;
383                 case '\t': case ' ':
384                         second = name+len;
385                         for (;;) {
386                                 char c = *second++;
387                                 if (c == '\n')
388                                         return NULL;
389                                 if (c == '/')
390                                         break;
391                         }
392                         if (second[len] == '\n' && !memcmp(name, second, len)) {
393                                 char *ret = xmalloc(len + 1);
394                                 memcpy(ret, name, len);
395                                 ret[len] = 0;
396                                 return ret;
397                         }
398                 }
399         }
400         return NULL;
401 }
402
403 /* Verify that we recognize the lines following a git header */
404 static int parse_git_header(char *line, int len, unsigned int size, struct patch *patch)
405 {
406         unsigned long offset;
407
408         /* A git diff has explicit new/delete information, so we don't guess */
409         patch->is_new = 0;
410         patch->is_delete = 0;
411
412         /*
413          * Some things may not have the old name in the
414          * rest of the headers anywhere (pure mode changes,
415          * or removing or adding empty files), so we get
416          * the default name from the header.
417          */
418         patch->def_name = git_header_name(line + strlen("diff --git "));
419
420         line += len;
421         size -= len;
422         linenr++;
423         for (offset = len ; size > 0 ; offset += len, size -= len, line += len, linenr++) {
424                 static const struct opentry {
425                         const char *str;
426                         int (*fn)(const char *, struct patch *);
427                 } optable[] = {
428                         { "@@ -", gitdiff_hdrend },
429                         { "--- ", gitdiff_oldname },
430                         { "+++ ", gitdiff_newname },
431                         { "old mode ", gitdiff_oldmode },
432                         { "new mode ", gitdiff_newmode },
433                         { "deleted file mode ", gitdiff_delete },
434                         { "new file mode ", gitdiff_newfile },
435                         { "copy from ", gitdiff_copysrc },
436                         { "copy to ", gitdiff_copydst },
437                         { "rename from ", gitdiff_renamesrc },
438                         { "rename to ", gitdiff_renamedst },
439                         { "similarity index ", gitdiff_similarity },
440                         { "dissimilarity index ", gitdiff_dissimilarity },
441                         { "", gitdiff_unrecognized },
442                 };
443                 int i;
444
445                 len = linelen(line, size);
446                 if (!len || line[len-1] != '\n')
447                         break;
448                 for (i = 0; i < sizeof(optable) / sizeof(optable[0]); i++) {
449                         const struct opentry *p = optable + i;
450                         int oplen = strlen(p->str);
451                         if (len < oplen || memcmp(p->str, line, oplen))
452                                 continue;
453                         if (p->fn(line + oplen, patch) < 0)
454                                 return offset;
455                         break;
456                 }
457         }
458
459         return offset;
460 }
461
462 static int parse_num(const char *line, unsigned long *p)
463 {
464         char *ptr;
465
466         if (!isdigit(*line))
467                 return 0;
468         *p = strtoul(line, &ptr, 10);
469         return ptr - line;
470 }
471
472 static int parse_range(const char *line, int len, int offset, const char *expect,
473                         unsigned long *p1, unsigned long *p2)
474 {
475         int digits, ex;
476
477         if (offset < 0 || offset >= len)
478                 return -1;
479         line += offset;
480         len -= offset;
481
482         digits = parse_num(line, p1);
483         if (!digits)
484                 return -1;
485
486         offset += digits;
487         line += digits;
488         len -= digits;
489
490         *p2 = *p1;
491         if (*line == ',') {
492                 digits = parse_num(line+1, p2);
493                 if (!digits)
494                         return -1;
495
496                 offset += digits+1;
497                 line += digits+1;
498                 len -= digits+1;
499         }
500
501         ex = strlen(expect);
502         if (ex > len)
503                 return -1;
504         if (memcmp(line, expect, ex))
505                 return -1;
506
507         return offset + ex;
508 }
509
510 /*
511  * Parse a unified diff fragment header of the
512  * form "@@ -a,b +c,d @@"
513  */
514 static int parse_fragment_header(char *line, int len, struct fragment *fragment)
515 {
516         int offset;
517
518         if (!len || line[len-1] != '\n')
519                 return -1;
520
521         /* Figure out the number of lines in a fragment */
522         offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);
523         offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);
524
525         return offset;
526 }
527
528 static int find_header(char *line, unsigned long size, int *hdrsize, struct patch *patch)
529 {
530         unsigned long offset, len;
531
532         patch->is_rename = patch->is_copy = 0;
533         patch->is_new = patch->is_delete = -1;
534         patch->old_mode = patch->new_mode = 0;
535         patch->old_name = patch->new_name = NULL;
536         for (offset = 0; size > 0; offset += len, size -= len, line += len, linenr++) {
537                 unsigned long nextlen;
538
539                 len = linelen(line, size);
540                 if (!len)
541                         break;
542
543                 /* Testing this early allows us to take a few shortcuts.. */
544                 if (len < 6)
545                         continue;
546
547                 /*
548                  * Make sure we don't find any unconnected patch fragmants.
549                  * That's a sign that we didn't find a header, and that a
550                  * patch has become corrupted/broken up.
551                  */
552                 if (!memcmp("@@ -", line, 4)) {
553                         struct fragment dummy;
554                         if (parse_fragment_header(line, len, &dummy) < 0)
555                                 continue;
556                         error("patch fragment without header at line %d: %.*s", linenr, len-1, line);
557                 }
558
559                 if (size < len + 6)
560                         break;
561
562                 /*
563                  * Git patch? It might not have a real patch, just a rename
564                  * or mode change, so we handle that specially
565                  */
566                 if (!memcmp("diff --git ", line, 11)) {
567                         int git_hdr_len = parse_git_header(line, len, size, patch);
568                         if (git_hdr_len < 0)
569                                 continue;
570                         if (!patch->old_name && !patch->new_name)
571                                 die("git diff header lacks filename information");
572                         *hdrsize = git_hdr_len;
573                         return offset;
574                 }
575
576                 /** --- followed by +++ ? */
577                 if (memcmp("--- ", line,  4) || memcmp("+++ ", line + len, 4))
578                         continue;
579
580                 /*
581                  * We only accept unified patches, so we want it to
582                  * at least have "@@ -a,b +c,d @@\n", which is 14 chars
583                  * minimum
584                  */
585                 nextlen = linelen(line + len, size - len);
586                 if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))
587                         continue;
588
589                 /* Ok, we'll consider it a patch */
590                 parse_traditional_patch(line, line+len, patch);
591                 *hdrsize = len + nextlen;
592                 linenr += 2;
593                 return offset;
594         }
595         return -1;
596 }
597
598 /*
599  * Parse a unified diff. Note that this really needs
600  * to parse each fragment separately, since the only
601  * way to know the difference between a "---" that is
602  * part of a patch, and a "---" that starts the next
603  * patch is to look at the line counts..
604  */
605 static int parse_fragment(char *line, unsigned long size, struct patch *patch, struct fragment *fragment)
606 {
607         int added, deleted;
608         int len = linelen(line, size), offset;
609         unsigned long pos[4], oldlines, newlines;
610
611         offset = parse_fragment_header(line, len, fragment);
612         if (offset < 0)
613                 return -1;
614         oldlines = fragment->oldlines;
615         newlines = fragment->newlines;
616
617         if (patch->is_new < 0 && (pos[0] || oldlines))
618                 patch->is_new = 0;
619         if (patch->is_delete < 0 && (pos[1] || newlines))
620                 patch->is_delete = 0;
621
622         /* Parse the thing.. */
623         line += len;
624         size -= len;
625         linenr++;
626         added = deleted = 0;
627         for (offset = len; size > 0; offset += len, size -= len, line += len, linenr++) {
628                 if (!oldlines && !newlines)
629                         break;
630                 len = linelen(line, size);
631                 if (!len || line[len-1] != '\n')
632                         return -1;
633                 switch (*line) {
634                 default:
635                         return -1;
636                 case ' ':
637                         oldlines--;
638                         newlines--;
639                         break;
640                 case '-':
641                         deleted++;
642                         oldlines--;
643                         break;
644                 case '+':
645                         added++;
646                         newlines--;
647                         break;
648                 /* We allow "\ No newline at end of file" */
649                 case '\\':
650                         if (len < 12 || memcmp(line, "\\ No newline", 12))
651                                 return -1;
652                         break;
653                 }
654         }
655         patch->lines_added += added;
656         patch->lines_deleted += deleted;
657         return offset;
658 }
659
660 static int parse_single_patch(char *line, unsigned long size, struct patch *patch)
661 {
662         unsigned long offset = 0;
663         struct fragment **fragp = &patch->fragments;
664
665         while (size > 4 && !memcmp(line, "@@ -", 4)) {
666                 struct fragment *fragment;
667                 int len;
668
669                 fragment = xmalloc(sizeof(*fragment));
670                 memset(fragment, 0, sizeof(*fragment));
671                 len = parse_fragment(line, size, patch, fragment);
672                 if (len <= 0)
673                         die("corrupt patch at line %d", linenr);
674
675                 fragment->patch = line;
676                 fragment->size = len;
677
678                 *fragp = fragment;
679                 fragp = &fragment->next;
680
681                 offset += len;
682                 line += len;
683                 size -= len;
684         }
685         return offset;
686 }
687
688 static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
689 {
690         int hdrsize, patchsize;
691         int offset = find_header(buffer, size, &hdrsize, patch);
692
693         if (offset < 0)
694                 return offset;
695
696         patchsize = parse_single_patch(buffer + offset + hdrsize, size - offset - hdrsize, patch);
697
698         return offset + hdrsize + patchsize;
699 }
700
701 const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
702 const char minuses[]= "----------------------------------------------------------------------";
703
704 static void show_stats(struct patch *patch)
705 {
706         char *name = patch->old_name;
707         int len, max, add, del, total;
708
709         if (!name)
710                 name = patch->new_name;
711
712         /*
713          * "scale" the filename
714          */
715         len = strlen(name);
716         max = max_len;
717         if (max > 50)
718                 max = 50;
719         if (len > max)
720                 name += len - max;
721         len = max;
722
723         /*
724          * scale the add/delete
725          */
726         max = max_change;
727         if (max + len > 70)
728                 max = 70 - len;
729
730         add = patch->lines_added;
731         del = patch->lines_deleted;
732         total = add + del;
733
734         total = (total * max + max_change / 2) / max_change;
735         add = (add * max + max_change / 2) / max_change;
736         del = total - add;
737         printf(" %-*s |%5d %.*s%.*s\n",
738                 len, name, patch->lines_added + patch->lines_deleted,
739                 add, pluses, del, minuses);
740 }
741
742 static int read_old_data(struct stat *st, const char *path, void *buf, unsigned long size)
743 {
744         int fd;
745         unsigned long got;
746
747         switch (st->st_mode & S_IFMT) {
748         case S_IFLNK:
749                 return readlink(path, buf, size);
750         case S_IFREG:
751                 fd = open(path, O_RDONLY);
752                 if (fd < 0)
753                         return error("unable to open %s", path);
754                 got = 0;
755                 for (;;) {
756                         int ret = read(fd, buf + got, size - got);
757                         if (ret < 0) {
758                                 if (errno == EAGAIN)
759                                         continue;
760                                 break;
761                         }
762                         if (!ret)
763                                 break;
764                         got += ret;
765                 }
766                 close(fd);
767                 return got;
768
769         default:
770                 return -1;
771         }
772 }
773
774 static int find_offset(const char *buf, unsigned long size, const char *fragment, unsigned long fragsize, int line)
775 {
776         unsigned long start;
777
778         if (fragsize > size)
779                 return -1;
780
781         start = 0;
782         if (line > 1) {
783                 line--;
784                 unsigned long offset = 0;
785                 while (start + offset <= size) {
786                         if (buf[offset++] == '\n') {
787                                 start = offset;
788                                 if (!--line)
789                                         break;
790                         }
791                 }
792         }
793
794         /* Exact line number? */
795         if (!memcmp(buf + start, fragment, fragsize))
796                 return start;
797
798         /*
799          * We should start searching forward and backward.
800          */
801         return -1;
802 }
803
804 static int apply_one_fragment(char *buf, unsigned long *sizep, unsigned long *bufsizep, struct fragment *frag)
805 {
806         const char *patch = frag->patch;
807         int offset, size = frag->size;
808         char *old = xmalloc(size);
809         char *new = xmalloc(size);
810         int oldsize = 0, newsize = 0;
811
812         while (size > 0) {
813                 int len = linelen(patch, size);
814                 int plen;
815
816                 if (!len)
817                         break;
818
819                 /*
820                  * "plen" is how much of the line we should use for
821                  * the actual patch data. Normally we just remove the
822                  * first character on the line, but if the line is
823                  * followed by "\ No newline", then we also remove the
824                  * last one (which is the newline, of course).
825                  */
826                 plen = len-1;
827                 if (len > size && patch[len] == '\\')
828                         plen--;
829                 switch (*patch) {
830                 case ' ':
831                 case '-':
832                         memcpy(old + oldsize, patch + 1, plen);
833                         oldsize += plen;
834                         if (*patch == '-')
835                                 break;
836                 /* Fall-through for ' ' */
837                 case '+':
838                         memcpy(new + newsize, patch + 1, plen);
839                         newsize += plen;
840                         break;
841                 case '@': case '\\':
842                         /* Ignore it, we already handled it */
843                         break;
844                 default:
845                         return -1;
846                 }
847                 patch += len;
848                 size -= len;
849         }
850
851         offset = find_offset(buf, *sizep, old, oldsize, frag->newpos);
852         if (offset >= 0) {
853                 printf("found at offset %d\n", offset);
854                 offset = 0;
855         }
856
857         free(old);
858         free(new);
859         return offset;
860 }
861
862 static int apply_fragments(char *buf, unsigned long *sizep, unsigned long *bufsizep, struct patch *patch)
863 {
864         struct fragment *frag = patch->fragments;
865
866         while (frag) {
867                 if (apply_one_fragment(buf, sizep, bufsizep, frag) < 0)
868                         return error("patch failed: %s:%d", patch->old_name, frag->oldpos);
869                 frag = frag->next;
870         }
871 }
872
873 static int apply_data(struct patch *patch, struct stat *st)
874 {
875         unsigned long size, bufsize;
876         void *buf;
877
878         if (!patch->old_name || !patch->fragments)
879                 return 0;
880         size = st->st_size;
881         bufsize = size + 16;
882         buf = xmalloc(bufsize);
883         if (read_old_data(st, patch->old_name, buf, bufsize) != size)
884                 return error("read of %s failed", patch->old_name);
885         if (apply_fragments(buf, &size, &bufsize, patch) < 0)
886                 return -1;
887         return 0;
888 }
889
890 static int check_patch(struct patch *patch)
891 {
892         struct stat st;
893         const char *old_name = patch->old_name;
894         const char *new_name = patch->new_name;
895
896         if (old_name) {
897                 int changed;
898
899                 if (lstat(old_name, &st) < 0)
900                         return error("%s: %s\n", strerror(errno));
901                 if (check_index) {
902                         int pos = cache_name_pos(old_name, strlen(old_name));
903                         if (pos < 0)
904                                 return error("%s: does not exist in index", old_name);
905                         changed = ce_match_stat(active_cache[pos], &st);
906                         if (changed)
907                                 return error("%s: does not match index", old_name);
908                 }
909                 if (patch->is_new < 0)
910                         patch->is_new = 0;
911                 if (!patch->old_mode)
912                         patch->old_mode = st.st_mode;
913                 if ((st.st_mode ^ patch->old_mode) & S_IFMT)
914                         return error("%s: wrong type", old_name);
915                 if (st.st_mode != patch->old_mode)
916                         fprintf(stderr, "warning: %s has type %o, expected %o\n",
917                                 old_name, st.st_mode, patch->old_mode);
918         }
919
920         if (new_name && (patch->is_new | patch->is_rename | patch->is_copy)) {
921                 if (check_index && cache_name_pos(new_name, strlen(new_name)) >= 0)
922                         return error("%s: already exists in index", new_name);
923                 if (!lstat(new_name, &st))
924                         return error("%s: already exists in working directory", new_name);
925                 if (errno != ENOENT)
926                         return error("%s: %s", new_name, strerror(errno));
927         }
928
929         if (new_name && old_name) {
930                 int same = !strcmp(old_name, new_name);
931                 if (!patch->new_mode)
932                         patch->new_mode = patch->old_mode;
933                 if ((patch->old_mode ^ patch->new_mode) & S_IFMT)
934                         return error("new mode (%o) of %s does not match old mode (%o)%s%s",
935                                 patch->new_mode, new_name, patch->old_mode,
936                                 same ? "" : " of ", same ? "" : old_name);
937         }       
938
939         if (apply_data(patch, &st) < 0)
940                 return error("%s: patch does not apply", old_name);
941         return 0;
942 }
943
944 static int check_patch_list(struct patch *patch)
945 {
946         int error = 0;
947
948         for (;patch ; patch = patch->next)
949                 error |= check_patch(patch);
950         return error;
951 }
952
953 static void show_file(int c, unsigned int mode, const char *name)
954 {
955         printf("%c %o %s\n", c, mode, name);
956 }
957
958 static void show_file_list(struct patch *patch)
959 {
960         for (;patch ; patch = patch->next) {
961                 if (patch->is_rename) {
962                         show_file('-', patch->old_mode, patch->old_name);
963                         show_file('+', patch->new_mode, patch->new_name);
964                         continue;
965                 }
966                 if (patch->is_copy || patch->is_new) {
967                         show_file('+', patch->new_mode, patch->new_name);
968                         continue;
969                 }
970                 if (patch->is_delete) {
971                         show_file('-', patch->old_mode, patch->old_name);
972                         continue;
973                 }
974                 if (patch->old_mode && patch->new_mode && patch->old_mode != patch->new_mode) {
975                         printf("M %o:%o %s\n", patch->old_mode, patch->new_mode, patch->old_name);
976                         continue;
977                 }
978                 printf("M %o %s\n", patch->old_mode, patch->old_name);
979         }
980 }
981
982 static void stat_patch_list(struct patch *patch)
983 {
984         int files, adds, dels;
985
986         for (files = adds = dels = 0 ; patch ; patch = patch->next) {
987                 files++;
988                 adds += patch->lines_added;
989                 dels += patch->lines_deleted;
990                 show_stats(patch);
991         }
992
993         printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);
994 }
995
996 static void patch_stats(struct patch *patch)
997 {
998         int lines = patch->lines_added + patch->lines_deleted;
999
1000         if (lines > max_change)
1001                 max_change = lines;
1002         if (patch->old_name) {
1003                 int len = strlen(patch->old_name);
1004                 if (len > max_len)
1005                         max_len = len;
1006         }
1007         if (patch->new_name) {
1008                 int len = strlen(patch->new_name);
1009                 if (len > max_len)
1010                         max_len = len;
1011         }
1012 }
1013
1014 static int apply_patch(int fd)
1015 {
1016         unsigned long offset, size;
1017         char *buffer = read_patch_file(fd, &size);
1018         struct patch *list = NULL, **listp = &list;
1019
1020         if (!buffer)
1021                 return -1;
1022         offset = 0;
1023         while (size > 0) {
1024                 struct patch *patch;
1025                 int nr;
1026
1027                 patch = xmalloc(sizeof(*patch));
1028                 memset(patch, 0, sizeof(*patch));
1029                 nr = parse_chunk(buffer + offset, size, patch);
1030                 if (nr < 0)
1031                         break;
1032                 patch_stats(patch);
1033                 *listp = patch;
1034                 listp = &patch->next;
1035                 offset += nr;
1036                 size -= nr;
1037         }
1038
1039         if ((check || apply) && check_patch_list(list) < 0)
1040                 exit(1);
1041
1042         if (show_files)
1043                 show_file_list(list);
1044
1045         if (diffstat)
1046                 stat_patch_list(list);
1047
1048         free(buffer);
1049         return 0;
1050 }
1051
1052 int main(int argc, char **argv)
1053 {
1054         int i;
1055         int read_stdin = 1;
1056
1057         if (read_cache() < 0)
1058                 die("unable to read index file");
1059
1060         for (i = 1; i < argc; i++) {
1061                 const char *arg = argv[i];
1062                 int fd;
1063
1064                 if (!strcmp(arg, "-")) {
1065                         apply_patch(0);
1066                         read_stdin = 0;
1067                         continue;
1068                 }
1069                 if (!strcmp(arg, "--no-merge")) {
1070                         merge_patch = 0;
1071                         continue;
1072                 }
1073                 if (!strcmp(arg, "--stat")) {
1074                         apply = 0;
1075                         diffstat = 1;
1076                         continue;
1077                 }
1078                 if (!strcmp(arg, "--check")) {
1079                         apply = 0;
1080                         check = 1;
1081                         continue;
1082                 }
1083                 if (!strcmp(arg, "--index")) {
1084                         check_index = 1;
1085                         continue;
1086                 }
1087                 if (!strcmp(arg, "--show-files")) {
1088                         show_files = 1;
1089                         continue;
1090                 }
1091                 fd = open(arg, O_RDONLY);
1092                 if (fd < 0)
1093                         usage(apply_usage);
1094                 read_stdin = 0;
1095                 apply_patch(fd);
1096                 close(fd);
1097         }
1098         if (read_stdin)
1099                 apply_patch(0);
1100         return 0;
1101 }