1#include "cache.h"
2#include "config.h"
3#include "lockfile.h"
4#include "string-list.h"
5#include "rerere.h"
6#include "xdiff-interface.h"
7#include "dir.h"
8#include "resolve-undo.h"
9#include "ll-merge.h"
10#include "attr.h"
11#include "pathspec.h"
12#include "sha1-lookup.h"
13
14#define RESOLVED 0
15#define PUNTED 1
16#define THREE_STAGED 2
17void *RERERE_RESOLVED = &RERERE_RESOLVED;
18
19/* if rerere_enabled == -1, fall back to detection of .git/rr-cache */
20static int rerere_enabled = -1;
21
22/* automatically update cleanly resolved paths to the index */
23static int rerere_autoupdate;
24
25static int rerere_dir_nr;
26static int rerere_dir_alloc;
27
28#define RR_HAS_POSTIMAGE 1
29#define RR_HAS_PREIMAGE 2
30static struct rerere_dir {
31 unsigned char sha1[20];
32 int status_alloc, status_nr;
33 unsigned char *status;
34} **rerere_dir;
35
36static void free_rerere_dirs(void)
37{
38 int i;
39 for (i = 0; i < rerere_dir_nr; i++) {
40 free(rerere_dir[i]->status);
41 free(rerere_dir[i]);
42 }
43 FREE_AND_NULL(rerere_dir);
44 rerere_dir_nr = rerere_dir_alloc = 0;
45}
46
47static void free_rerere_id(struct string_list_item *item)
48{
49 free(item->util);
50}
51
52static const char *rerere_id_hex(const struct rerere_id *id)
53{
54 return sha1_to_hex(id->collection->sha1);
55}
56
57static void fit_variant(struct rerere_dir *rr_dir, int variant)
58{
59 variant++;
60 ALLOC_GROW(rr_dir->status, variant, rr_dir->status_alloc);
61 if (rr_dir->status_nr < variant) {
62 memset(rr_dir->status + rr_dir->status_nr,
63 '\0', variant - rr_dir->status_nr);
64 rr_dir->status_nr = variant;
65 }
66}
67
68static void assign_variant(struct rerere_id *id)
69{
70 int variant;
71 struct rerere_dir *rr_dir = id->collection;
72
73 variant = id->variant;
74 if (variant < 0) {
75 for (variant = 0; variant < rr_dir->status_nr; variant++)
76 if (!rr_dir->status[variant])
77 break;
78 }
79 fit_variant(rr_dir, variant);
80 id->variant = variant;
81}
82
83const char *rerere_path(const struct rerere_id *id, const char *file)
84{
85 if (!file)
86 return git_path("rr-cache/%s", rerere_id_hex(id));
87
88 if (id->variant <= 0)
89 return git_path("rr-cache/%s/%s", rerere_id_hex(id), file);
90
91 return git_path("rr-cache/%s/%s.%d",
92 rerere_id_hex(id), file, id->variant);
93}
94
95static int is_rr_file(const char *name, const char *filename, int *variant)
96{
97 const char *suffix;
98 char *ep;
99
100 if (!strcmp(name, filename)) {
101 *variant = 0;
102 return 1;
103 }
104 if (!skip_prefix(name, filename, &suffix) || *suffix != '.')
105 return 0;
106
107 errno = 0;
108 *variant = strtol(suffix + 1, &ep, 10);
109 if (errno || *ep)
110 return 0;
111 return 1;
112}
113
114static void scan_rerere_dir(struct rerere_dir *rr_dir)
115{
116 struct dirent *de;
117 DIR *dir = opendir(git_path("rr-cache/%s", sha1_to_hex(rr_dir->sha1)));
118
119 if (!dir)
120 return;
121 while ((de = readdir(dir)) != NULL) {
122 int variant;
123
124 if (is_rr_file(de->d_name, "postimage", &variant)) {
125 fit_variant(rr_dir, variant);
126 rr_dir->status[variant] |= RR_HAS_POSTIMAGE;
127 } else if (is_rr_file(de->d_name, "preimage", &variant)) {
128 fit_variant(rr_dir, variant);
129 rr_dir->status[variant] |= RR_HAS_PREIMAGE;
130 }
131 }
132 closedir(dir);
133}
134
135static const unsigned char *rerere_dir_sha1(size_t i, void *table)
136{
137 struct rerere_dir **rr_dir = table;
138 return rr_dir[i]->sha1;
139}
140
141static struct rerere_dir *find_rerere_dir(const char *hex)
142{
143 unsigned char sha1[20];
144 struct rerere_dir *rr_dir;
145 int pos;
146
147 if (get_sha1_hex(hex, sha1))
148 return NULL; /* BUG */
149 pos = sha1_pos(sha1, rerere_dir, rerere_dir_nr, rerere_dir_sha1);
150 if (pos < 0) {
151 rr_dir = xmalloc(sizeof(*rr_dir));
152 hashcpy(rr_dir->sha1, sha1);
153 rr_dir->status = NULL;
154 rr_dir->status_nr = 0;
155 rr_dir->status_alloc = 0;
156 pos = -1 - pos;
157
158 /* Make sure the array is big enough ... */
159 ALLOC_GROW(rerere_dir, rerere_dir_nr + 1, rerere_dir_alloc);
160 /* ... and add it in. */
161 rerere_dir_nr++;
162 MOVE_ARRAY(rerere_dir + pos + 1, rerere_dir + pos,
163 rerere_dir_nr - pos - 1);
164 rerere_dir[pos] = rr_dir;
165 scan_rerere_dir(rr_dir);
166 }
167 return rerere_dir[pos];
168}
169
170static int has_rerere_resolution(const struct rerere_id *id)
171{
172 const int both = RR_HAS_POSTIMAGE|RR_HAS_PREIMAGE;
173 int variant = id->variant;
174
175 if (variant < 0)
176 return 0;
177 return ((id->collection->status[variant] & both) == both);
178}
179
180static struct rerere_id *new_rerere_id_hex(char *hex)
181{
182 struct rerere_id *id = xmalloc(sizeof(*id));
183 id->collection = find_rerere_dir(hex);
184 id->variant = -1; /* not known yet */
185 return id;
186}
187
188static struct rerere_id *new_rerere_id(unsigned char *sha1)
189{
190 return new_rerere_id_hex(sha1_to_hex(sha1));
191}
192
193/*
194 * $GIT_DIR/MERGE_RR file is a collection of records, each of which is
195 * "conflict ID", a HT and pathname, terminated with a NUL, and is
196 * used to keep track of the set of paths that "rerere" may need to
197 * work on (i.e. what is left by the previous invocation of "git
198 * rerere" during the current conflict resolution session).
199 */
200static void read_rr(struct string_list *rr)
201{
202 struct strbuf buf = STRBUF_INIT;
203 FILE *in = fopen_or_warn(git_path_merge_rr(), "r");
204
205 if (!in)
206 return;
207 while (!strbuf_getwholeline(&buf, in, '\0')) {
208 char *path;
209 unsigned char sha1[20];
210 struct rerere_id *id;
211 int variant;
212
213 /* There has to be the hash, tab, path and then NUL */
214 if (buf.len < 42 || get_sha1_hex(buf.buf, sha1))
215 die(_("corrupt MERGE_RR"));
216
217 if (buf.buf[40] != '.') {
218 variant = 0;
219 path = buf.buf + 40;
220 } else {
221 errno = 0;
222 variant = strtol(buf.buf + 41, &path, 10);
223 if (errno)
224 die(_("corrupt MERGE_RR"));
225 }
226 if (*(path++) != '\t')
227 die(_("corrupt MERGE_RR"));
228 buf.buf[40] = '\0';
229 id = new_rerere_id_hex(buf.buf);
230 id->variant = variant;
231 string_list_insert(rr, path)->util = id;
232 }
233 strbuf_release(&buf);
234 fclose(in);
235}
236
237static struct lock_file write_lock;
238
239static int write_rr(struct string_list *rr, int out_fd)
240{
241 int i;
242 for (i = 0; i < rr->nr; i++) {
243 struct strbuf buf = STRBUF_INIT;
244 struct rerere_id *id;
245
246 assert(rr->items[i].util != RERERE_RESOLVED);
247
248 id = rr->items[i].util;
249 if (!id)
250 continue;
251 assert(id->variant >= 0);
252 if (0 < id->variant)
253 strbuf_addf(&buf, "%s.%d\t%s%c",
254 rerere_id_hex(id), id->variant,
255 rr->items[i].string, 0);
256 else
257 strbuf_addf(&buf, "%s\t%s%c",
258 rerere_id_hex(id),
259 rr->items[i].string, 0);
260
261 if (write_in_full(out_fd, buf.buf, buf.len) < 0)
262 die(_("unable to write rerere record"));
263
264 strbuf_release(&buf);
265 }
266 if (commit_lock_file(&write_lock) != 0)
267 die(_("unable to write rerere record"));
268 return 0;
269}
270
271/*
272 * "rerere" interacts with conflicted file contents using this I/O
273 * abstraction. It reads a conflicted contents from one place via
274 * "getline()" method, and optionally can write it out after
275 * normalizing the conflicted hunks to the "output". Subclasses of
276 * rerere_io embed this structure at the beginning of their own
277 * rerere_io object.
278 */
279struct rerere_io {
280 int (*getline)(struct strbuf *, struct rerere_io *);
281 FILE *output;
282 int wrerror;
283 /* some more stuff */
284};
285
286static void ferr_write(const void *p, size_t count, FILE *fp, int *err)
287{
288 if (!count || *err)
289 return;
290 if (fwrite(p, count, 1, fp) != 1)
291 *err = errno;
292}
293
294static inline void ferr_puts(const char *s, FILE *fp, int *err)
295{
296 ferr_write(s, strlen(s), fp, err);
297}
298
299static void rerere_io_putstr(const char *str, struct rerere_io *io)
300{
301 if (io->output)
302 ferr_puts(str, io->output, &io->wrerror);
303}
304
305static void rerere_io_putmem(const char *mem, size_t sz, struct rerere_io *io)
306{
307 if (io->output)
308 ferr_write(mem, sz, io->output, &io->wrerror);
309}
310
311/*
312 * Subclass of rerere_io that reads from an on-disk file
313 */
314struct rerere_io_file {
315 struct rerere_io io;
316 FILE *input;
317};
318
319/*
320 * ... and its getline() method implementation
321 */
322static int rerere_file_getline(struct strbuf *sb, struct rerere_io *io_)
323{
324 struct rerere_io_file *io = (struct rerere_io_file *)io_;
325 return strbuf_getwholeline(sb, io->input, '\n');
326}
327
328/*
329 * Require the exact number of conflict marker letters, no more, no
330 * less, followed by SP or any whitespace
331 * (including LF).
332 */
333static int is_cmarker(char *buf, int marker_char, int marker_size)
334{
335 int want_sp;
336
337 /*
338 * The beginning of our version and the end of their version
339 * always are labeled like "<<<<< ours" or ">>>>> theirs",
340 * hence we set want_sp for them. Note that the version from
341 * the common ancestor in diff3-style output is not always
342 * labelled (e.g. "||||| common" is often seen but "|||||"
343 * alone is also valid), so we do not set want_sp.
344 */
345 want_sp = (marker_char == '<') || (marker_char == '>');
346
347 while (marker_size--)
348 if (*buf++ != marker_char)
349 return 0;
350 if (want_sp && *buf != ' ')
351 return 0;
352 return isspace(*buf);
353}
354
355static void rerere_strbuf_putconflict(struct strbuf *buf, int ch, size_t size)
356{
357 strbuf_addchars(buf, ch, size);
358 strbuf_addch(buf, '\n');
359}
360
361static int handle_conflict(struct strbuf *out, struct rerere_io *io,
362 int marker_size, git_SHA_CTX *ctx)
363{
364 enum {
365 RR_SIDE_1 = 0, RR_SIDE_2, RR_ORIGINAL
366 } hunk = RR_SIDE_1;
367 struct strbuf one = STRBUF_INIT, two = STRBUF_INIT;
368 struct strbuf buf = STRBUF_INIT, conflict = STRBUF_INIT;
369 int has_conflicts = -1;
370
371 while (!io->getline(&buf, io)) {
372 if (is_cmarker(buf.buf, '<', marker_size)) {
373 if (handle_conflict(&conflict, io, marker_size, NULL) < 0)
374 break;
375 if (hunk == RR_SIDE_1)
376 strbuf_addbuf(&one, &conflict);
377 else
378 strbuf_addbuf(&two, &conflict);
379 strbuf_release(&conflict);
380 } else if (is_cmarker(buf.buf, '|', marker_size)) {
381 if (hunk != RR_SIDE_1)
382 break;
383 hunk = RR_ORIGINAL;
384 } else if (is_cmarker(buf.buf, '=', marker_size)) {
385 if (hunk != RR_SIDE_1 && hunk != RR_ORIGINAL)
386 break;
387 hunk = RR_SIDE_2;
388 } else if (is_cmarker(buf.buf, '>', marker_size)) {
389 if (hunk != RR_SIDE_2)
390 break;
391 if (strbuf_cmp(&one, &two) > 0)
392 strbuf_swap(&one, &two);
393 has_conflicts = 1;
394 rerere_strbuf_putconflict(out, '<', marker_size);
395 strbuf_addbuf(out, &one);
396 rerere_strbuf_putconflict(out, '=', marker_size);
397 strbuf_addbuf(out, &two);
398 rerere_strbuf_putconflict(out, '>', marker_size);
399 if (ctx) {
400 git_SHA1_Update(ctx, one.buf ? one.buf : "",
401 one.len + 1);
402 git_SHA1_Update(ctx, two.buf ? two.buf : "",
403 two.len + 1);
404 }
405 break;
406 } else if (hunk == RR_SIDE_1)
407 strbuf_addbuf(&one, &buf);
408 else if (hunk == RR_ORIGINAL)
409 ; /* discard */
410 else if (hunk == RR_SIDE_2)
411 strbuf_addbuf(&two, &buf);
412 }
413 strbuf_release(&one);
414 strbuf_release(&two);
415 strbuf_release(&buf);
416
417 return has_conflicts;
418}
419
420/*
421 * Read contents a file with conflicts, normalize the conflicts
422 * by (1) discarding the common ancestor version in diff3-style,
423 * (2) reordering our side and their side so that whichever sorts
424 * alphabetically earlier comes before the other one, while
425 * computing the "conflict ID", which is just an SHA-1 hash of
426 * one side of the conflict, NUL, the other side of the conflict,
427 * and NUL concatenated together.
428 *
429 * Return 1 if conflict hunks are found, 0 if there are no conflict
430 * hunks and -1 if an error occured.
431 */
432static int handle_path(unsigned char *sha1, struct rerere_io *io, int marker_size)
433{
434 git_SHA_CTX ctx;
435 struct strbuf buf = STRBUF_INIT, out = STRBUF_INIT;
436 int has_conflicts = 0;
437 if (sha1)
438 git_SHA1_Init(&ctx);
439
440 while (!io->getline(&buf, io)) {
441 if (is_cmarker(buf.buf, '<', marker_size)) {
442 has_conflicts = handle_conflict(&out, io, marker_size,
443 sha1 ? &ctx : NULL);
444 if (has_conflicts < 0)
445 break;
446 rerere_io_putmem(out.buf, out.len, io);
447 strbuf_reset(&out);
448 } else
449 rerere_io_putstr(buf.buf, io);
450 }
451 strbuf_release(&buf);
452 strbuf_release(&out);
453
454 if (sha1)
455 git_SHA1_Final(sha1, &ctx);
456
457 return has_conflicts;
458}
459
460/*
461 * Scan the path for conflicts, do the "handle_path()" thing above, and
462 * return the number of conflict hunks found.
463 */
464static int handle_file(const char *path, unsigned char *sha1, const char *output)
465{
466 int has_conflicts = 0;
467 struct rerere_io_file io;
468 int marker_size = ll_merge_marker_size(path);
469
470 memset(&io, 0, sizeof(io));
471 io.io.getline = rerere_file_getline;
472 io.input = fopen(path, "r");
473 io.io.wrerror = 0;
474 if (!io.input)
475 return error_errno(_("could not open '%s'"), path);
476
477 if (output) {
478 io.io.output = fopen(output, "w");
479 if (!io.io.output) {
480 error_errno(_("could not write '%s'"), output);
481 fclose(io.input);
482 return -1;
483 }
484 }
485
486 has_conflicts = handle_path(sha1, (struct rerere_io *)&io, marker_size);
487
488 fclose(io.input);
489 if (io.io.wrerror)
490 error(_("there were errors while writing '%s' (%s)"),
491 path, strerror(io.io.wrerror));
492 if (io.io.output && fclose(io.io.output))
493 io.io.wrerror = error_errno(_("failed to flush '%s'"), path);
494
495 if (has_conflicts < 0) {
496 if (output)
497 unlink_or_warn(output);
498 return error(_("could not parse conflict hunks in '%s'"), path);
499 }
500 if (io.io.wrerror)
501 return -1;
502 return has_conflicts;
503}
504
505/*
506 * Look at a cache entry at "i" and see if it is not conflicting,
507 * conflicting and we are willing to handle, or conflicting and
508 * we are unable to handle, and return the determination in *type.
509 * Return the cache index to be looked at next, by skipping the
510 * stages we have already looked at in this invocation of this
511 * function.
512 */
513static int check_one_conflict(int i, int *type)
514{
515 const struct cache_entry *e = active_cache[i];
516
517 if (!ce_stage(e)) {
518 *type = RESOLVED;
519 return i + 1;
520 }
521
522 *type = PUNTED;
523 while (ce_stage(active_cache[i]) == 1)
524 i++;
525
526 /* Only handle regular files with both stages #2 and #3 */
527 if (i + 1 < active_nr) {
528 const struct cache_entry *e2 = active_cache[i];
529 const struct cache_entry *e3 = active_cache[i + 1];
530 if (ce_stage(e2) == 2 &&
531 ce_stage(e3) == 3 &&
532 ce_same_name(e, e3) &&
533 S_ISREG(e2->ce_mode) &&
534 S_ISREG(e3->ce_mode))
535 *type = THREE_STAGED;
536 }
537
538 /* Skip the entries with the same name */
539 while (i < active_nr && ce_same_name(e, active_cache[i]))
540 i++;
541 return i;
542}
543
544/*
545 * Scan the index and find paths that have conflicts that rerere can
546 * handle, i.e. the ones that has both stages #2 and #3.
547 *
548 * NEEDSWORK: we do not record or replay a previous "resolve by
549 * deletion" for a delete-modify conflict, as that is inherently risky
550 * without knowing what modification is being discarded. The only
551 * safe case, i.e. both side doing the deletion and modification that
552 * are identical to the previous round, might want to be handled,
553 * though.
554 */
555static int find_conflict(struct string_list *conflict)
556{
557 int i;
558 if (read_cache() < 0)
559 return error(_("index file corrupt"));
560
561 for (i = 0; i < active_nr;) {
562 int conflict_type;
563 const struct cache_entry *e = active_cache[i];
564 i = check_one_conflict(i, &conflict_type);
565 if (conflict_type == THREE_STAGED)
566 string_list_insert(conflict, (const char *)e->name);
567 }
568 return 0;
569}
570
571/*
572 * The merge_rr list is meant to hold outstanding conflicted paths
573 * that rerere could handle. Abuse the list by adding other types of
574 * entries to allow the caller to show "rerere remaining".
575 *
576 * - Conflicted paths that rerere does not handle are added
577 * - Conflicted paths that have been resolved are marked as such
578 * by storing RERERE_RESOLVED to .util field (where conflict ID
579 * is expected to be stored).
580 *
581 * Do *not* write MERGE_RR file out after calling this function.
582 *
583 * NEEDSWORK: we may want to fix the caller that implements "rerere
584 * remaining" to do this without abusing merge_rr.
585 */
586int rerere_remaining(struct string_list *merge_rr)
587{
588 int i;
589 if (setup_rerere(merge_rr, RERERE_READONLY))
590 return 0;
591 if (read_cache() < 0)
592 return error(_("index file corrupt"));
593
594 for (i = 0; i < active_nr;) {
595 int conflict_type;
596 const struct cache_entry *e = active_cache[i];
597 i = check_one_conflict(i, &conflict_type);
598 if (conflict_type == PUNTED)
599 string_list_insert(merge_rr, (const char *)e->name);
600 else if (conflict_type == RESOLVED) {
601 struct string_list_item *it;
602 it = string_list_lookup(merge_rr, (const char *)e->name);
603 if (it != NULL) {
604 free_rerere_id(it);
605 it->util = RERERE_RESOLVED;
606 }
607 }
608 }
609 return 0;
610}
611
612/*
613 * Try using the given conflict resolution "ID" to see
614 * if that recorded conflict resolves cleanly what we
615 * got in the "cur".
616 */
617static int try_merge(const struct rerere_id *id, const char *path,
618 mmfile_t *cur, mmbuffer_t *result)
619{
620 int ret;
621 mmfile_t base = {NULL, 0}, other = {NULL, 0};
622
623 if (read_mmfile(&base, rerere_path(id, "preimage")) ||
624 read_mmfile(&other, rerere_path(id, "postimage")))
625 ret = 1;
626 else
627 /*
628 * A three-way merge. Note that this honors user-customizable
629 * low-level merge driver settings.
630 */
631 ret = ll_merge(result, path, &base, NULL, cur, "", &other, "", NULL);
632
633 free(base.ptr);
634 free(other.ptr);
635
636 return ret;
637}
638
639/*
640 * Find the conflict identified by "id"; the change between its
641 * "preimage" (i.e. a previous contents with conflict markers) and its
642 * "postimage" (i.e. the corresponding contents with conflicts
643 * resolved) may apply cleanly to the contents stored in "path", i.e.
644 * the conflict this time around.
645 *
646 * Returns 0 for successful replay of recorded resolution, or non-zero
647 * for failure.
648 */
649static int merge(const struct rerere_id *id, const char *path)
650{
651 FILE *f;
652 int ret;
653 mmfile_t cur = {NULL, 0};
654 mmbuffer_t result = {NULL, 0};
655
656 /*
657 * Normalize the conflicts in path and write it out to
658 * "thisimage" temporary file.
659 */
660 if ((handle_file(path, NULL, rerere_path(id, "thisimage")) < 0) ||
661 read_mmfile(&cur, rerere_path(id, "thisimage"))) {
662 ret = 1;
663 goto out;
664 }
665
666 ret = try_merge(id, path, &cur, &result);
667 if (ret)
668 goto out;
669
670 /*
671 * A successful replay of recorded resolution.
672 * Mark that "postimage" was used to help gc.
673 */
674 if (utime(rerere_path(id, "postimage"), NULL) < 0)
675 warning_errno(_("failed utime() on '%s'"),
676 rerere_path(id, "postimage"));
677
678 /* Update "path" with the resolution */
679 f = fopen(path, "w");
680 if (!f)
681 return error_errno(_("could not open '%s'"), path);
682 if (fwrite(result.ptr, result.size, 1, f) != 1)
683 error_errno(_("could not write '%s'"), path);
684 if (fclose(f))
685 return error_errno(_("writing '%s' failed"), path);
686
687out:
688 free(cur.ptr);
689 free(result.ptr);
690
691 return ret;
692}
693
694static void update_paths(struct string_list *update)
695{
696 struct lock_file index_lock = LOCK_INIT;
697 int i;
698
699 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
700
701 for (i = 0; i < update->nr; i++) {
702 struct string_list_item *item = &update->items[i];
703 if (add_file_to_cache(item->string, 0))
704 exit(128);
705 fprintf_ln(stderr, _("Staged '%s' using previous resolution."),
706 item->string);
707 }
708
709 if (write_locked_index(&the_index, &index_lock,
710 COMMIT_LOCK | SKIP_IF_UNCHANGED))
711 die(_("unable to write new index file"));
712}
713
714static void remove_variant(struct rerere_id *id)
715{
716 unlink_or_warn(rerere_path(id, "postimage"));
717 unlink_or_warn(rerere_path(id, "preimage"));
718 id->collection->status[id->variant] = 0;
719}
720
721/*
722 * The path indicated by rr_item may still have conflict for which we
723 * have a recorded resolution, in which case replay it and optionally
724 * update it. Or it may have been resolved by the user and we may
725 * only have the preimage for that conflict, in which case the result
726 * needs to be recorded as a resolution in a postimage file.
727 */
728static void do_rerere_one_path(struct string_list_item *rr_item,
729 struct string_list *update)
730{
731 const char *path = rr_item->string;
732 struct rerere_id *id = rr_item->util;
733 struct rerere_dir *rr_dir = id->collection;
734 int variant;
735
736 variant = id->variant;
737
738 /* Has the user resolved it already? */
739 if (variant >= 0) {
740 if (!handle_file(path, NULL, NULL)) {
741 copy_file(rerere_path(id, "postimage"), path, 0666);
742 id->collection->status[variant] |= RR_HAS_POSTIMAGE;
743 fprintf_ln(stderr, _("Recorded resolution for '%s'."), path);
744 free_rerere_id(rr_item);
745 rr_item->util = NULL;
746 return;
747 }
748 /*
749 * There may be other variants that can cleanly
750 * replay. Try them and update the variant number for
751 * this one.
752 */
753 }
754
755 /* Does any existing resolution apply cleanly? */
756 for (variant = 0; variant < rr_dir->status_nr; variant++) {
757 const int both = RR_HAS_PREIMAGE | RR_HAS_POSTIMAGE;
758 struct rerere_id vid = *id;
759
760 if ((rr_dir->status[variant] & both) != both)
761 continue;
762
763 vid.variant = variant;
764 if (merge(&vid, path))
765 continue; /* failed to replay */
766
767 /*
768 * If there already is a different variant that applies
769 * cleanly, there is no point maintaining our own variant.
770 */
771 if (0 <= id->variant && id->variant != variant)
772 remove_variant(id);
773
774 if (rerere_autoupdate)
775 string_list_insert(update, path);
776 else
777 fprintf_ln(stderr,
778 _("Resolved '%s' using previous resolution."),
779 path);
780 free_rerere_id(rr_item);
781 rr_item->util = NULL;
782 return;
783 }
784
785 /* None of the existing one applies; we need a new variant */
786 assign_variant(id);
787
788 variant = id->variant;
789 handle_file(path, NULL, rerere_path(id, "preimage"));
790 if (id->collection->status[variant] & RR_HAS_POSTIMAGE) {
791 const char *path = rerere_path(id, "postimage");
792 if (unlink(path))
793 die_errno(_("cannot unlink stray '%s'"), path);
794 id->collection->status[variant] &= ~RR_HAS_POSTIMAGE;
795 }
796 id->collection->status[variant] |= RR_HAS_PREIMAGE;
797 fprintf_ln(stderr, _("Recorded preimage for '%s'"), path);
798}
799
800static int do_plain_rerere(struct string_list *rr, int fd)
801{
802 struct string_list conflict = STRING_LIST_INIT_DUP;
803 struct string_list update = STRING_LIST_INIT_DUP;
804 int i;
805
806 find_conflict(&conflict);
807
808 /*
809 * MERGE_RR records paths with conflicts immediately after
810 * merge failed. Some of the conflicted paths might have been
811 * hand resolved in the working tree since then, but the
812 * initial run would catch all and register their preimages.
813 */
814 for (i = 0; i < conflict.nr; i++) {
815 struct rerere_id *id;
816 unsigned char sha1[20];
817 const char *path = conflict.items[i].string;
818 int ret;
819
820 /*
821 * Ask handle_file() to scan and assign a
822 * conflict ID. No need to write anything out
823 * yet.
824 */
825 ret = handle_file(path, sha1, NULL);
826 if (ret != 0 && string_list_has_string(rr, path)) {
827 remove_variant(string_list_lookup(rr, path)->util);
828 string_list_remove(rr, path, 1);
829 }
830 if (ret < 1)
831 continue;
832
833 id = new_rerere_id(sha1);
834 string_list_insert(rr, path)->util = id;
835
836 /* Ensure that the directory exists. */
837 mkdir_in_gitdir(rerere_path(id, NULL));
838 }
839
840 for (i = 0; i < rr->nr; i++)
841 do_rerere_one_path(&rr->items[i], &update);
842
843 if (update.nr)
844 update_paths(&update);
845
846 return write_rr(rr, fd);
847}
848
849static void git_rerere_config(void)
850{
851 git_config_get_bool("rerere.enabled", &rerere_enabled);
852 git_config_get_bool("rerere.autoupdate", &rerere_autoupdate);
853 git_config(git_default_config, NULL);
854}
855
856static GIT_PATH_FUNC(git_path_rr_cache, "rr-cache")
857
858static int is_rerere_enabled(void)
859{
860 int rr_cache_exists;
861
862 if (!rerere_enabled)
863 return 0;
864
865 rr_cache_exists = is_directory(git_path_rr_cache());
866 if (rerere_enabled < 0)
867 return rr_cache_exists;
868
869 if (!rr_cache_exists && mkdir_in_gitdir(git_path_rr_cache()))
870 die(_("could not create directory '%s'"), git_path_rr_cache());
871 return 1;
872}
873
874int setup_rerere(struct string_list *merge_rr, int flags)
875{
876 int fd;
877
878 git_rerere_config();
879 if (!is_rerere_enabled())
880 return -1;
881
882 if (flags & (RERERE_AUTOUPDATE|RERERE_NOAUTOUPDATE))
883 rerere_autoupdate = !!(flags & RERERE_AUTOUPDATE);
884 if (flags & RERERE_READONLY)
885 fd = 0;
886 else
887 fd = hold_lock_file_for_update(&write_lock, git_path_merge_rr(),
888 LOCK_DIE_ON_ERROR);
889 read_rr(merge_rr);
890 return fd;
891}
892
893/*
894 * The main entry point that is called internally from codepaths that
895 * perform mergy operations, possibly leaving conflicted index entries
896 * and working tree files.
897 */
898int rerere(int flags)
899{
900 struct string_list merge_rr = STRING_LIST_INIT_DUP;
901 int fd, status;
902
903 fd = setup_rerere(&merge_rr, flags);
904 if (fd < 0)
905 return 0;
906 status = do_plain_rerere(&merge_rr, fd);
907 free_rerere_dirs();
908 return status;
909}
910
911/*
912 * Subclass of rerere_io that reads from an in-core buffer that is a
913 * strbuf
914 */
915struct rerere_io_mem {
916 struct rerere_io io;
917 struct strbuf input;
918};
919
920/*
921 * ... and its getline() method implementation
922 */
923static int rerere_mem_getline(struct strbuf *sb, struct rerere_io *io_)
924{
925 struct rerere_io_mem *io = (struct rerere_io_mem *)io_;
926 char *ep;
927 size_t len;
928
929 strbuf_release(sb);
930 if (!io->input.len)
931 return -1;
932 ep = memchr(io->input.buf, '\n', io->input.len);
933 if (!ep)
934 ep = io->input.buf + io->input.len;
935 else if (*ep == '\n')
936 ep++;
937 len = ep - io->input.buf;
938 strbuf_add(sb, io->input.buf, len);
939 strbuf_remove(&io->input, 0, len);
940 return 0;
941}
942
943static int handle_cache(const char *path, unsigned char *sha1, const char *output)
944{
945 mmfile_t mmfile[3] = {{NULL}};
946 mmbuffer_t result = {NULL, 0};
947 const struct cache_entry *ce;
948 int pos, len, i, has_conflicts;
949 struct rerere_io_mem io;
950 int marker_size = ll_merge_marker_size(path);
951
952 /*
953 * Reproduce the conflicted merge in-core
954 */
955 len = strlen(path);
956 pos = cache_name_pos(path, len);
957 if (0 <= pos)
958 return -1;
959 pos = -pos - 1;
960
961 while (pos < active_nr) {
962 enum object_type type;
963 unsigned long size;
964
965 ce = active_cache[pos++];
966 if (ce_namelen(ce) != len || memcmp(ce->name, path, len))
967 break;
968 i = ce_stage(ce) - 1;
969 if (!mmfile[i].ptr) {
970 mmfile[i].ptr = read_object_file(&ce->oid, &type,
971 &size);
972 mmfile[i].size = size;
973 }
974 }
975 for (i = 0; i < 3; i++)
976 if (!mmfile[i].ptr && !mmfile[i].size)
977 mmfile[i].ptr = xstrdup("");
978
979 /*
980 * NEEDSWORK: handle conflicts from merges with
981 * merge.renormalize set, too?
982 */
983 ll_merge(&result, path, &mmfile[0], NULL,
984 &mmfile[1], "ours",
985 &mmfile[2], "theirs", NULL);
986 for (i = 0; i < 3; i++)
987 free(mmfile[i].ptr);
988
989 memset(&io, 0, sizeof(io));
990 io.io.getline = rerere_mem_getline;
991 if (output)
992 io.io.output = fopen(output, "w");
993 else
994 io.io.output = NULL;
995 strbuf_init(&io.input, 0);
996 strbuf_attach(&io.input, result.ptr, result.size, result.size);
997
998 /*
999 * Grab the conflict ID and optionally write the original
1000 * contents with conflict markers out.
1001 */
1002 has_conflicts = handle_path(sha1, (struct rerere_io *)&io, marker_size);
1003 strbuf_release(&io.input);
1004 if (io.io.output)
1005 fclose(io.io.output);
1006 return has_conflicts;
1007}
1008
1009static int rerere_forget_one_path(const char *path, struct string_list *rr)
1010{
1011 const char *filename;
1012 struct rerere_id *id;
1013 unsigned char sha1[20];
1014 int ret;
1015 struct string_list_item *item;
1016
1017 /*
1018 * Recreate the original conflict from the stages in the
1019 * index and compute the conflict ID
1020 */
1021 ret = handle_cache(path, sha1, NULL);
1022 if (ret < 1)
1023 return error(_("could not parse conflict hunks in '%s'"), path);
1024
1025 /* Nuke the recorded resolution for the conflict */
1026 id = new_rerere_id(sha1);
1027
1028 for (id->variant = 0;
1029 id->variant < id->collection->status_nr;
1030 id->variant++) {
1031 mmfile_t cur = { NULL, 0 };
1032 mmbuffer_t result = {NULL, 0};
1033 int cleanly_resolved;
1034
1035 if (!has_rerere_resolution(id))
1036 continue;
1037
1038 handle_cache(path, sha1, rerere_path(id, "thisimage"));
1039 if (read_mmfile(&cur, rerere_path(id, "thisimage"))) {
1040 free(cur.ptr);
1041 error(_("failed to update conflicted state in '%s'"), path);
1042 goto fail_exit;
1043 }
1044 cleanly_resolved = !try_merge(id, path, &cur, &result);
1045 free(result.ptr);
1046 free(cur.ptr);
1047 if (cleanly_resolved)
1048 break;
1049 }
1050
1051 if (id->collection->status_nr <= id->variant) {
1052 error(_("no remembered resolution for '%s'"), path);
1053 goto fail_exit;
1054 }
1055
1056 filename = rerere_path(id, "postimage");
1057 if (unlink(filename)) {
1058 if (errno == ENOENT)
1059 error(_("no remembered resolution for '%s'"), path);
1060 else
1061 error_errno(_("cannot unlink '%s'"), filename);
1062 goto fail_exit;
1063 }
1064
1065 /*
1066 * Update the preimage so that the user can resolve the
1067 * conflict in the working tree, run us again to record
1068 * the postimage.
1069 */
1070 handle_cache(path, sha1, rerere_path(id, "preimage"));
1071 fprintf_ln(stderr, _("Updated preimage for '%s'"), path);
1072
1073 /*
1074 * And remember that we can record resolution for this
1075 * conflict when the user is done.
1076 */
1077 item = string_list_insert(rr, path);
1078 free_rerere_id(item);
1079 item->util = id;
1080 fprintf(stderr, _("Forgot resolution for '%s'\n"), path);
1081 return 0;
1082
1083fail_exit:
1084 free(id);
1085 return -1;
1086}
1087
1088int rerere_forget(struct pathspec *pathspec)
1089{
1090 int i, fd;
1091 struct string_list conflict = STRING_LIST_INIT_DUP;
1092 struct string_list merge_rr = STRING_LIST_INIT_DUP;
1093
1094 if (read_cache() < 0)
1095 return error(_("index file corrupt"));
1096
1097 fd = setup_rerere(&merge_rr, RERERE_NOAUTOUPDATE);
1098 if (fd < 0)
1099 return 0;
1100
1101 /*
1102 * The paths may have been resolved (incorrectly);
1103 * recover the original conflicted state and then
1104 * find the conflicted paths.
1105 */
1106 unmerge_cache(pathspec);
1107 find_conflict(&conflict);
1108 for (i = 0; i < conflict.nr; i++) {
1109 struct string_list_item *it = &conflict.items[i];
1110 if (!match_pathspec(pathspec, it->string,
1111 strlen(it->string), 0, NULL, 0))
1112 continue;
1113 rerere_forget_one_path(it->string, &merge_rr);
1114 }
1115 return write_rr(&merge_rr, fd);
1116}
1117
1118/*
1119 * Garbage collection support
1120 */
1121
1122static timestamp_t rerere_created_at(struct rerere_id *id)
1123{
1124 struct stat st;
1125
1126 return stat(rerere_path(id, "preimage"), &st) ? (time_t) 0 : st.st_mtime;
1127}
1128
1129static timestamp_t rerere_last_used_at(struct rerere_id *id)
1130{
1131 struct stat st;
1132
1133 return stat(rerere_path(id, "postimage"), &st) ? (time_t) 0 : st.st_mtime;
1134}
1135
1136/*
1137 * Remove the recorded resolution for a given conflict ID
1138 */
1139static void unlink_rr_item(struct rerere_id *id)
1140{
1141 unlink_or_warn(rerere_path(id, "thisimage"));
1142 remove_variant(id);
1143 id->collection->status[id->variant] = 0;
1144}
1145
1146static void prune_one(struct rerere_id *id,
1147 timestamp_t cutoff_resolve, timestamp_t cutoff_noresolve)
1148{
1149 timestamp_t then;
1150 timestamp_t cutoff;
1151
1152 then = rerere_last_used_at(id);
1153 if (then)
1154 cutoff = cutoff_resolve;
1155 else {
1156 then = rerere_created_at(id);
1157 if (!then)
1158 return;
1159 cutoff = cutoff_noresolve;
1160 }
1161 if (then < cutoff)
1162 unlink_rr_item(id);
1163}
1164
1165void rerere_gc(struct string_list *rr)
1166{
1167 struct string_list to_remove = STRING_LIST_INIT_DUP;
1168 DIR *dir;
1169 struct dirent *e;
1170 int i;
1171 timestamp_t now = time(NULL);
1172 timestamp_t cutoff_noresolve = now - 15 * 86400;
1173 timestamp_t cutoff_resolve = now - 60 * 86400;
1174
1175 if (setup_rerere(rr, 0) < 0)
1176 return;
1177
1178 git_config_get_expiry_in_days("gc.rerereresolved", &cutoff_resolve, now);
1179 git_config_get_expiry_in_days("gc.rerereunresolved", &cutoff_noresolve, now);
1180 git_config(git_default_config, NULL);
1181 dir = opendir(git_path("rr-cache"));
1182 if (!dir)
1183 die_errno(_("unable to open rr-cache directory"));
1184 /* Collect stale conflict IDs ... */
1185 while ((e = readdir(dir))) {
1186 struct rerere_dir *rr_dir;
1187 struct rerere_id id;
1188 int now_empty;
1189
1190 if (is_dot_or_dotdot(e->d_name))
1191 continue;
1192 rr_dir = find_rerere_dir(e->d_name);
1193 if (!rr_dir)
1194 continue; /* or should we remove e->d_name? */
1195
1196 now_empty = 1;
1197 for (id.variant = 0, id.collection = rr_dir;
1198 id.variant < id.collection->status_nr;
1199 id.variant++) {
1200 prune_one(&id, cutoff_resolve, cutoff_noresolve);
1201 if (id.collection->status[id.variant])
1202 now_empty = 0;
1203 }
1204 if (now_empty)
1205 string_list_append(&to_remove, e->d_name);
1206 }
1207 closedir(dir);
1208
1209 /* ... and then remove the empty directories */
1210 for (i = 0; i < to_remove.nr; i++)
1211 rmdir(git_path("rr-cache/%s", to_remove.items[i].string));
1212 string_list_clear(&to_remove, 0);
1213 rollback_lock_file(&write_lock);
1214}
1215
1216/*
1217 * During a conflict resolution, after "rerere" recorded the
1218 * preimages, abandon them if the user did not resolve them or
1219 * record their resolutions. And drop $GIT_DIR/MERGE_RR.
1220 *
1221 * NEEDSWORK: shouldn't we be calling this from "reset --hard"?
1222 */
1223void rerere_clear(struct string_list *merge_rr)
1224{
1225 int i;
1226
1227 if (setup_rerere(merge_rr, 0) < 0)
1228 return;
1229
1230 for (i = 0; i < merge_rr->nr; i++) {
1231 struct rerere_id *id = merge_rr->items[i].util;
1232 if (!has_rerere_resolution(id)) {
1233 unlink_rr_item(id);
1234 rmdir(rerere_path(id, NULL));
1235 }
1236 }
1237 unlink_or_warn(git_path_merge_rr());
1238 rollback_lock_file(&write_lock);
1239}