rerere: drop want_sp parameter from is_cmarker()
[git/git.git] / rerere.c
CommitLineData
5b2fd956 1#include "cache.h"
697cc8ef 2#include "lockfile.h"
c455c87c 3#include "string-list.h"
5b2fd956 4#include "rerere.h"
5b2fd956 5#include "xdiff-interface.h"
dea4562b
JH
6#include "dir.h"
7#include "resolve-undo.h"
8#include "ll-merge.h"
8588567c 9#include "attr.h"
01a10b0a 10#include "pathspec.h"
5b2fd956 11
ac49f5ca
MZ
12#define RESOLVED 0
13#define PUNTED 1
14#define THREE_STAGED 2
15void *RERERE_RESOLVED = &RERERE_RESOLVED;
16
5b2fd956
SB
17/* if rerere_enabled == -1, fall back to detection of .git/rr-cache */
18static int rerere_enabled = -1;
19
20/* automatically update cleanly resolved paths to the index */
21static int rerere_autoupdate;
22
23static char *merge_rr_path;
24
90056966 25const char *rerere_path(const char *hex, const char *file)
5b2fd956 26{
90056966 27 return git_path("rr-cache/%s/%s", hex, file);
5b2fd956
SB
28}
29
7e0d4ab5 30static int has_rerere_resolution(const char *hex)
5b2fd956
SB
31{
32 struct stat st;
90056966 33 return !stat(rerere_path(hex, "postimage"), &st);
5b2fd956
SB
34}
35
c455c87c 36static void read_rr(struct string_list *rr)
5b2fd956 37{
f5800f6a 38 struct strbuf buf = STRBUF_INIT;
5b2fd956 39 FILE *in = fopen(merge_rr_path, "r");
f5800f6a 40
5b2fd956
SB
41 if (!in)
42 return;
f5800f6a
JH
43 while (!strbuf_getwholeline(&buf, in, '\0')) {
44 char *path;
45 unsigned char sha1[20];
46
47 /* There has to be the hash, tab, path and then NUL */
48 if (buf.len < 42 || get_sha1_hex(buf.buf, sha1))
5b2fd956 49 die("corrupt MERGE_RR");
f5800f6a
JH
50
51 if (buf.buf[40] != '\t')
5b2fd956 52 die("corrupt MERGE_RR");
f5800f6a
JH
53 buf.buf[40] = '\0';
54 path = buf.buf + 41;
55
56 string_list_insert(rr, path)->util = xstrdup(buf.buf);
5b2fd956 57 }
f5800f6a 58 strbuf_release(&buf);
5b2fd956
SB
59 fclose(in);
60}
61
62static struct lock_file write_lock;
63
c455c87c 64static int write_rr(struct string_list *rr, int out_fd)
5b2fd956
SB
65{
66 int i;
67 for (i = 0; i < rr->nr; i++) {
e2cb6a95
JH
68 struct strbuf buf = STRBUF_INIT;
69
70 assert(rr->items[i].util != RERERE_RESOLVED);
5b2fd956
SB
71 if (!rr->items[i].util)
72 continue;
e2cb6a95
JH
73 strbuf_addf(&buf, "%s\t%s%c",
74 (char *)rr->items[i].util,
75 rr->items[i].string, 0);
76 if (write_in_full(out_fd, buf.buf, buf.len) != buf.len)
5b2fd956 77 die("unable to write rerere record");
e2cb6a95
JH
78
79 strbuf_release(&buf);
5b2fd956
SB
80 }
81 if (commit_lock_file(&write_lock) != 0)
82 die("unable to write rerere record");
83 return 0;
84}
85
47d32af2
AR
86static void ferr_write(const void *p, size_t count, FILE *fp, int *err)
87{
88 if (!count || *err)
89 return;
90 if (fwrite(p, count, 1, fp) != 1)
91 *err = errno;
92}
93
94static inline void ferr_puts(const char *s, FILE *fp, int *err)
95{
96 ferr_write(s, strlen(s), fp, err);
97}
98
27d6b085
JH
99struct rerere_io {
100 int (*getline)(struct strbuf *, struct rerere_io *);
101 FILE *output;
102 int wrerror;
103 /* some more stuff */
104};
105
106static void rerere_io_putstr(const char *str, struct rerere_io *io)
107{
108 if (io->output)
109 ferr_puts(str, io->output, &io->wrerror);
110}
111
191f2417
JH
112static void rerere_io_putconflict(int ch, int size, struct rerere_io *io)
113{
114 char buf[64];
115
116 while (size) {
117 if (size < sizeof(buf) - 2) {
118 memset(buf, ch, size);
119 buf[size] = '\n';
120 buf[size + 1] = '\0';
121 size = 0;
122 } else {
123 int sz = sizeof(buf) - 1;
124 if (size <= sz)
125 sz -= (sz - size) + 1;
126 memset(buf, ch, sz);
127 buf[sz] = '\0';
128 size -= sz;
129 }
130 rerere_io_putstr(buf, io);
131 }
132}
133
27d6b085
JH
134static void rerere_io_putmem(const char *mem, size_t sz, struct rerere_io *io)
135{
136 if (io->output)
137 ferr_write(mem, sz, io->output, &io->wrerror);
138}
139
140struct rerere_io_file {
141 struct rerere_io io;
142 FILE *input;
143};
144
145static int rerere_file_getline(struct strbuf *sb, struct rerere_io *io_)
146{
147 struct rerere_io_file *io = (struct rerere_io_file *)io_;
148 return strbuf_getwholeline(sb, io->input, '\n');
149}
150
67711cdc
JH
151/*
152 * Require the exact number of conflict marker letters, no more, no
153 * less, followed by SP or any whitespace
154 * (including LF).
155 */
156static int is_cmarker(char *buf, int marker_char, int marker_size)
191f2417 157{
67711cdc
JH
158 int want_sp;
159
160 /*
161 * The beginning of our version and the end of their version
162 * always are labeled like "<<<<< ours" or ">>>>> theirs",
163 * hence we set want_sp for them. Note that the version from
164 * the common ancestor in diff3-style output is not always
165 * labelled (e.g. "||||| common" is often seen but "|||||"
166 * alone is also valid), so we do not set want_sp.
167 */
168 want_sp = (marker_char == '<') || (marker_char == '>');
169
191f2417
JH
170 while (marker_size--)
171 if (*buf++ != marker_char)
172 return 0;
173 if (want_sp && *buf != ' ')
174 return 0;
175 return isspace(*buf);
176}
177
178static int handle_path(unsigned char *sha1, struct rerere_io *io, int marker_size)
5b2fd956 179{
9126f009 180 git_SHA_CTX ctx;
cc58d7df
JH
181 int hunk_no = 0;
182 enum {
4b05548f 183 RR_CONTEXT = 0, RR_SIDE_1, RR_SIDE_2, RR_ORIGINAL
cc58d7df 184 } hunk = RR_CONTEXT;
f285a2d7 185 struct strbuf one = STRBUF_INIT, two = STRBUF_INIT;
d58ee6db 186 struct strbuf buf = STRBUF_INIT;
5b2fd956
SB
187
188 if (sha1)
9126f009 189 git_SHA1_Init(&ctx);
5b2fd956 190
27d6b085 191 while (!io->getline(&buf, io)) {
67711cdc 192 if (is_cmarker(buf.buf, '<', marker_size)) {
cc58d7df 193 if (hunk != RR_CONTEXT)
5b2fd956 194 goto bad;
cc58d7df 195 hunk = RR_SIDE_1;
67711cdc 196 } else if (is_cmarker(buf.buf, '|', marker_size)) {
cc58d7df 197 if (hunk != RR_SIDE_1)
5b2fd956 198 goto bad;
387c9d49 199 hunk = RR_ORIGINAL;
67711cdc 200 } else if (is_cmarker(buf.buf, '=', marker_size)) {
387c9d49 201 if (hunk != RR_SIDE_1 && hunk != RR_ORIGINAL)
5b2fd956 202 goto bad;
cc58d7df 203 hunk = RR_SIDE_2;
67711cdc 204 } else if (is_cmarker(buf.buf, '>', marker_size)) {
cc58d7df 205 if (hunk != RR_SIDE_2)
5b2fd956
SB
206 goto bad;
207 if (strbuf_cmp(&one, &two) > 0)
208 strbuf_swap(&one, &two);
209 hunk_no++;
cc58d7df 210 hunk = RR_CONTEXT;
191f2417 211 rerere_io_putconflict('<', marker_size, io);
27d6b085 212 rerere_io_putmem(one.buf, one.len, io);
191f2417 213 rerere_io_putconflict('=', marker_size, io);
27d6b085 214 rerere_io_putmem(two.buf, two.len, io);
191f2417 215 rerere_io_putconflict('>', marker_size, io);
5b2fd956 216 if (sha1) {
9126f009 217 git_SHA1_Update(&ctx, one.buf ? one.buf : "",
5b2fd956 218 one.len + 1);
9126f009 219 git_SHA1_Update(&ctx, two.buf ? two.buf : "",
5b2fd956
SB
220 two.len + 1);
221 }
222 strbuf_reset(&one);
223 strbuf_reset(&two);
cc58d7df 224 } else if (hunk == RR_SIDE_1)
e992d1eb 225 strbuf_addbuf(&one, &buf);
387c9d49
JH
226 else if (hunk == RR_ORIGINAL)
227 ; /* discard */
cc58d7df 228 else if (hunk == RR_SIDE_2)
e992d1eb 229 strbuf_addbuf(&two, &buf);
27d6b085
JH
230 else
231 rerere_io_putstr(buf.buf, io);
5b2fd956
SB
232 continue;
233 bad:
234 hunk = 99; /* force error exit */
235 break;
236 }
237 strbuf_release(&one);
238 strbuf_release(&two);
d58ee6db 239 strbuf_release(&buf);
5b2fd956 240
5b2fd956 241 if (sha1)
9126f009 242 git_SHA1_Final(sha1, &ctx);
27d6b085
JH
243 if (hunk != RR_CONTEXT)
244 return -1;
245 return hunk_no;
246}
247
248static int handle_file(const char *path, unsigned char *sha1, const char *output)
249{
250 int hunk_no = 0;
251 struct rerere_io_file io;
8588567c 252 int marker_size = ll_merge_marker_size(path);
27d6b085
JH
253
254 memset(&io, 0, sizeof(io));
255 io.io.getline = rerere_file_getline;
256 io.input = fopen(path, "r");
257 io.io.wrerror = 0;
258 if (!io.input)
259 return error("Could not open %s", path);
260
261 if (output) {
262 io.io.output = fopen(output, "w");
263 if (!io.io.output) {
264 fclose(io.input);
265 return error("Could not write %s", output);
266 }
267 }
268
191f2417 269 hunk_no = handle_path(sha1, (struct rerere_io *)&io, marker_size);
27d6b085
JH
270
271 fclose(io.input);
272 if (io.io.wrerror)
273 error("There were errors while writing %s (%s)",
274 path, strerror(io.io.wrerror));
275 if (io.io.output && fclose(io.io.output))
276 io.io.wrerror = error("Failed to flush %s: %s",
277 path, strerror(errno));
278
279 if (hunk_no < 0) {
5b2fd956 280 if (output)
691f1a28 281 unlink_or_warn(output);
5b2fd956
SB
282 return error("Could not parse conflict hunks in %s", path);
283 }
27d6b085 284 if (io.io.wrerror)
47d32af2 285 return -1;
5b2fd956
SB
286 return hunk_no;
287}
288
dea4562b
JH
289struct rerere_io_mem {
290 struct rerere_io io;
291 struct strbuf input;
292};
293
294static int rerere_mem_getline(struct strbuf *sb, struct rerere_io *io_)
295{
296 struct rerere_io_mem *io = (struct rerere_io_mem *)io_;
297 char *ep;
298 size_t len;
299
300 strbuf_release(sb);
301 if (!io->input.len)
302 return -1;
53d8afaf
JS
303 ep = memchr(io->input.buf, '\n', io->input.len);
304 if (!ep)
305 ep = io->input.buf + io->input.len;
306 else if (*ep == '\n')
dea4562b
JH
307 ep++;
308 len = ep - io->input.buf;
309 strbuf_add(sb, io->input.buf, len);
310 strbuf_remove(&io->input, 0, len);
311 return 0;
312}
313
314static int handle_cache(const char *path, unsigned char *sha1, const char *output)
315{
b9e31f59 316 mmfile_t mmfile[3] = {{NULL}};
dea4562b 317 mmbuffer_t result = {NULL, 0};
9c5e6c80 318 const struct cache_entry *ce;
dea4562b
JH
319 int pos, len, i, hunk_no;
320 struct rerere_io_mem io;
8588567c 321 int marker_size = ll_merge_marker_size(path);
dea4562b
JH
322
323 /*
324 * Reproduce the conflicted merge in-core
325 */
326 len = strlen(path);
327 pos = cache_name_pos(path, len);
328 if (0 <= pos)
47d32af2 329 return -1;
dea4562b
JH
330 pos = -pos - 1;
331
332 for (i = 0; i < 3; i++) {
333 enum object_type type;
334 unsigned long size;
b9e31f59 335 int j;
dea4562b 336
dea4562b
JH
337 if (active_nr <= pos)
338 break;
339 ce = active_cache[pos++];
b9e31f59
JS
340 if (ce_namelen(ce) != len || memcmp(ce->name, path, len))
341 continue;
342 j = ce_stage(ce) - 1;
343 mmfile[j].ptr = read_sha1_file(ce->sha1, &type, &size);
344 mmfile[j].size = size;
dea4562b
JH
345 }
346 for (i = 0; i < 3; i++) {
347 if (!mmfile[i].ptr && !mmfile[i].size)
348 mmfile[i].ptr = xstrdup("");
349 }
18b037a5
JN
350 /*
351 * NEEDSWORK: handle conflicts from merges with
352 * merge.renormalize set, too
353 */
f01de62e 354 ll_merge(&result, path, &mmfile[0], NULL,
dea4562b 355 &mmfile[1], "ours",
712516bc 356 &mmfile[2], "theirs", NULL);
dea4562b
JH
357 for (i = 0; i < 3; i++)
358 free(mmfile[i].ptr);
359
af86debc 360 memset(&io, 0, sizeof(io));
dea4562b
JH
361 io.io.getline = rerere_mem_getline;
362 if (output)
363 io.io.output = fopen(output, "w");
364 else
365 io.io.output = NULL;
366 strbuf_init(&io.input, 0);
367 strbuf_attach(&io.input, result.ptr, result.size, result.size);
368
191f2417 369 hunk_no = handle_path(sha1, (struct rerere_io *)&io, marker_size);
dea4562b
JH
370 strbuf_release(&io.input);
371 if (io.io.output)
372 fclose(io.io.output);
5b2fd956
SB
373 return hunk_no;
374}
375
ac49f5ca 376static int check_one_conflict(int i, int *type)
5b2fd956 377{
9c5e6c80 378 const struct cache_entry *e = active_cache[i];
ac49f5ca
MZ
379
380 if (!ce_stage(e)) {
381 *type = RESOLVED;
382 return i + 1;
383 }
384
385 *type = PUNTED;
5eda906b 386 while (ce_stage(active_cache[i]) == 1)
fb70a06d 387 i++;
ac49f5ca
MZ
388
389 /* Only handle regular files with both stages #2 and #3 */
390 if (i + 1 < active_nr) {
9c5e6c80
NTND
391 const struct cache_entry *e2 = active_cache[i];
392 const struct cache_entry *e3 = active_cache[i + 1];
5b2fd956
SB
393 if (ce_stage(e2) == 2 &&
394 ce_stage(e3) == 3 &&
ac49f5ca 395 ce_same_name(e, e3) &&
5b2fd956 396 S_ISREG(e2->ce_mode) &&
ac49f5ca
MZ
397 S_ISREG(e3->ce_mode))
398 *type = THREE_STAGED;
399 }
400
401 /* Skip the entries with the same name */
402 while (i < active_nr && ce_same_name(e, active_cache[i]))
403 i++;
404 return i;
405}
406
407static int find_conflict(struct string_list *conflict)
408{
409 int i;
410 if (read_cache() < 0)
411 return error("Could not read index");
412
413 for (i = 0; i < active_nr;) {
414 int conflict_type;
9c5e6c80 415 const struct cache_entry *e = active_cache[i];
ac49f5ca
MZ
416 i = check_one_conflict(i, &conflict_type);
417 if (conflict_type == THREE_STAGED)
418 string_list_insert(conflict, (const char *)e->name);
419 }
420 return 0;
421}
422
423int rerere_remaining(struct string_list *merge_rr)
424{
425 int i;
426 if (read_cache() < 0)
427 return error("Could not read index");
428
429 for (i = 0; i < active_nr;) {
430 int conflict_type;
9c5e6c80 431 const struct cache_entry *e = active_cache[i];
ac49f5ca
MZ
432 i = check_one_conflict(i, &conflict_type);
433 if (conflict_type == PUNTED)
434 string_list_insert(merge_rr, (const char *)e->name);
435 else if (conflict_type == RESOLVED) {
436 struct string_list_item *it;
437 it = string_list_lookup(merge_rr, (const char *)e->name);
438 if (it != NULL) {
439 free(it->util);
440 it->util = RERERE_RESOLVED;
441 }
5b2fd956
SB
442 }
443 }
444 return 0;
445}
446
447static int merge(const char *name, const char *path)
448{
449 int ret;
689b8c29 450 mmfile_t cur = {NULL, 0}, base = {NULL, 0}, other = {NULL, 0};
5b2fd956 451 mmbuffer_t result = {NULL, 0};
5b2fd956 452
90056966 453 if (handle_file(path, NULL, rerere_path(name, "thisimage")) < 0)
5b2fd956
SB
454 return 1;
455
90056966
SG
456 if (read_mmfile(&cur, rerere_path(name, "thisimage")) ||
457 read_mmfile(&base, rerere_path(name, "preimage")) ||
689b8c29
BW
458 read_mmfile(&other, rerere_path(name, "postimage"))) {
459 ret = 1;
460 goto out;
461 }
1e4cd68c 462 ret = ll_merge(&result, path, &base, NULL, &cur, "", &other, "", NULL);
5b2fd956 463 if (!ret) {
7d7ff15b
SG
464 FILE *f;
465
466 if (utime(rerere_path(name, "postimage"), NULL) < 0)
467 warning("failed utime() on %s: %s",
468 rerere_path(name, "postimage"),
469 strerror(errno));
470 f = fopen(path, "w");
5b2fd956 471 if (!f)
47d32af2
AR
472 return error("Could not open %s: %s", path,
473 strerror(errno));
474 if (fwrite(result.ptr, result.size, 1, f) != 1)
475 error("Could not write %s: %s", path, strerror(errno));
476 if (fclose(f))
477 return error("Writing %s failed: %s", path,
478 strerror(errno));
5b2fd956
SB
479 }
480
689b8c29 481out:
5b2fd956
SB
482 free(cur.ptr);
483 free(base.ptr);
484 free(other.ptr);
485 free(result.ptr);
486
487 return ret;
488}
489
490static struct lock_file index_lock;
491
89ea9035 492static void update_paths(struct string_list *update)
5b2fd956
SB
493{
494 int i;
5b2fd956 495
89ea9035 496 hold_locked_index(&index_lock, 1);
5b2fd956
SB
497
498 for (i = 0; i < update->nr; i++) {
c455c87c 499 struct string_list_item *item = &update->items[i];
89ea9035
JN
500 if (add_file_to_cache(item->string, 0))
501 exit(128);
a14c7ab8
JH
502 fprintf(stderr, "Staged '%s' using previous resolution.\n",
503 item->string);
5b2fd956
SB
504 }
505
89ea9035 506 if (active_cache_changed) {
03b86647 507 if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK))
5b2fd956 508 die("Unable to write new index file");
89ea9035 509 } else
5b2fd956 510 rollback_lock_file(&index_lock);
5b2fd956
SB
511}
512
c455c87c 513static int do_plain_rerere(struct string_list *rr, int fd)
5b2fd956 514{
183113a5
TF
515 struct string_list conflict = STRING_LIST_INIT_DUP;
516 struct string_list update = STRING_LIST_INIT_DUP;
5b2fd956
SB
517 int i;
518
519 find_conflict(&conflict);
520
521 /*
522 * MERGE_RR records paths with conflicts immediately after merge
523 * failed. Some of the conflicted paths might have been hand resolved
524 * in the working tree since then, but the initial run would catch all
525 * and register their preimages.
526 */
527
528 for (i = 0; i < conflict.nr; i++) {
c455c87c
JS
529 const char *path = conflict.items[i].string;
530 if (!string_list_has_string(rr, path)) {
5b2fd956
SB
531 unsigned char sha1[20];
532 char *hex;
533 int ret;
534 ret = handle_file(path, sha1, NULL);
535 if (ret < 1)
536 continue;
537 hex = xstrdup(sha1_to_hex(sha1));
78a395d3 538 string_list_insert(rr, path)->util = hex;
fd956338 539 if (mkdir_in_gitdir(git_path("rr-cache/%s", hex)))
ba19a808 540 continue;
90056966 541 handle_file(path, NULL, rerere_path(hex, "preimage"));
5b2fd956
SB
542 fprintf(stderr, "Recorded preimage for '%s'\n", path);
543 }
544 }
545
546 /*
547 * Now some of the paths that had conflicts earlier might have been
548 * hand resolved. Others may be similar to a conflict already that
549 * was resolved before.
550 */
551
552 for (i = 0; i < rr->nr; i++) {
553 int ret;
c455c87c 554 const char *path = rr->items[i].string;
5b2fd956
SB
555 const char *name = (const char *)rr->items[i].util;
556
90056966 557 if (has_rerere_resolution(name)) {
a14c7ab8
JH
558 if (merge(name, path))
559 continue;
560
561 if (rerere_autoupdate)
562 string_list_insert(&update, path);
563 else
564 fprintf(stderr,
565 "Resolved '%s' using previous resolution.\n",
566 path);
567 goto mark_resolved;
5b2fd956
SB
568 }
569
570 /* Let's see if we have resolved it. */
571 ret = handle_file(path, NULL, NULL);
572 if (ret)
573 continue;
574
575 fprintf(stderr, "Recorded resolution for '%s'.\n", path);
90056966 576 copy_file(rerere_path(name, "postimage"), path, 0666);
5b2fd956 577 mark_resolved:
8d9b5a4a 578 free(rr->items[i].util);
5b2fd956
SB
579 rr->items[i].util = NULL;
580 }
581
582 if (update.nr)
583 update_paths(&update);
584
585 return write_rr(rr, fd);
586}
587
633e5ad3 588static void git_rerere_config(void)
5b2fd956 589{
633e5ad3
TA
590 git_config_get_bool("rerere.enabled", &rerere_enabled);
591 git_config_get_bool("rerere.autoupdate", &rerere_autoupdate);
592 git_config(git_default_config, NULL);
5b2fd956
SB
593}
594
595static int is_rerere_enabled(void)
596{
5b2fd956
SB
597 const char *rr_cache;
598 int rr_cache_exists;
599
600 if (!rerere_enabled)
601 return 0;
602
603 rr_cache = git_path("rr-cache");
90b4a71c 604 rr_cache_exists = is_directory(rr_cache);
5b2fd956
SB
605 if (rerere_enabled < 0)
606 return rr_cache_exists;
607
90a6464b 608 if (!rr_cache_exists && mkdir_in_gitdir(rr_cache))
5b2fd956
SB
609 die("Could not create directory %s", rr_cache);
610 return 1;
611}
612
cb6020bb 613int setup_rerere(struct string_list *merge_rr, int flags)
5b2fd956
SB
614{
615 int fd;
616
633e5ad3 617 git_rerere_config();
5b2fd956
SB
618 if (!is_rerere_enabled())
619 return -1;
620
cb6020bb
JH
621 if (flags & (RERERE_AUTOUPDATE|RERERE_NOAUTOUPDATE))
622 rerere_autoupdate = !!(flags & RERERE_AUTOUPDATE);
a4f34cbb 623 merge_rr_path = git_pathdup("MERGE_RR");
acd3b9ec
JH
624 fd = hold_lock_file_for_update(&write_lock, merge_rr_path,
625 LOCK_DIE_ON_ERROR);
5b2fd956
SB
626 read_rr(merge_rr);
627 return fd;
628}
629
cb6020bb 630int rerere(int flags)
5b2fd956 631{
183113a5 632 struct string_list merge_rr = STRING_LIST_INIT_DUP;
5b2fd956
SB
633 int fd;
634
cb6020bb 635 fd = setup_rerere(&merge_rr, flags);
5b2fd956
SB
636 if (fd < 0)
637 return 0;
638 return do_plain_rerere(&merge_rr, fd);
639}
dea4562b
JH
640
641static int rerere_forget_one_path(const char *path, struct string_list *rr)
642{
643 const char *filename;
644 char *hex;
645 unsigned char sha1[20];
646 int ret;
8d9b5a4a 647 struct string_list_item *item;
dea4562b
JH
648
649 ret = handle_cache(path, sha1, NULL);
650 if (ret < 1)
651 return error("Could not parse conflict hunks in '%s'", path);
652 hex = xstrdup(sha1_to_hex(sha1));
653 filename = rerere_path(hex, "postimage");
654 if (unlink(filename))
655 return (errno == ENOENT
656 ? error("no remembered resolution for %s", path)
657 : error("cannot unlink %s: %s", filename, strerror(errno)));
658
659 handle_cache(path, sha1, rerere_path(hex, "preimage"));
660 fprintf(stderr, "Updated preimage for '%s'\n", path);
661
8d9b5a4a
JH
662 item = string_list_insert(rr, path);
663 free(item->util);
664 item->util = hex;
dea4562b
JH
665 fprintf(stderr, "Forgot resolution for %s\n", path);
666 return 0;
667}
668
01a10b0a 669int rerere_forget(struct pathspec *pathspec)
dea4562b
JH
670{
671 int i, fd;
183113a5
TF
672 struct string_list conflict = STRING_LIST_INIT_DUP;
673 struct string_list merge_rr = STRING_LIST_INIT_DUP;
dea4562b
JH
674
675 if (read_cache() < 0)
676 return error("Could not read index");
677
6751e047 678 fd = setup_rerere(&merge_rr, RERERE_NOAUTOUPDATE);
dea4562b
JH
679
680 unmerge_cache(pathspec);
681 find_conflict(&conflict);
682 for (i = 0; i < conflict.nr; i++) {
683 struct string_list_item *it = &conflict.items[i];
854b0959 684 if (!match_pathspec(pathspec, it->string,
ae8d0824 685 strlen(it->string), 0, NULL, 0))
dea4562b
JH
686 continue;
687 rerere_forget_one_path(it->string, &merge_rr);
688 }
689 return write_rr(&merge_rr, fd);
690}
0f891e7d
JH
691
692static time_t rerere_created_at(const char *name)
693{
694 struct stat st;
695 return stat(rerere_path(name, "preimage"), &st) ? (time_t) 0 : st.st_mtime;
696}
697
698static time_t rerere_last_used_at(const char *name)
699{
700 struct stat st;
701 return stat(rerere_path(name, "postimage"), &st) ? (time_t) 0 : st.st_mtime;
702}
703
704static void unlink_rr_item(const char *name)
705{
706 unlink(rerere_path(name, "thisimage"));
707 unlink(rerere_path(name, "preimage"));
708 unlink(rerere_path(name, "postimage"));
709 rmdir(git_path("rr-cache/%s", name));
710}
711
0f891e7d
JH
712void rerere_gc(struct string_list *rr)
713{
714 struct string_list to_remove = STRING_LIST_INIT_DUP;
715 DIR *dir;
716 struct dirent *e;
717 int i, cutoff;
718 time_t now = time(NULL), then;
633e5ad3
TA
719 int cutoff_noresolve = 15;
720 int cutoff_resolve = 60;
0f891e7d 721
633e5ad3
TA
722 git_config_get_int("gc.rerereresolved", &cutoff_resolve);
723 git_config_get_int("gc.rerereunresolved", &cutoff_noresolve);
724 git_config(git_default_config, NULL);
0f891e7d
JH
725 dir = opendir(git_path("rr-cache"));
726 if (!dir)
727 die_errno("unable to open rr-cache directory");
728 while ((e = readdir(dir))) {
729 if (is_dot_or_dotdot(e->d_name))
730 continue;
731
732 then = rerere_last_used_at(e->d_name);
733 if (then) {
633e5ad3 734 cutoff = cutoff_resolve;
0f891e7d
JH
735 } else {
736 then = rerere_created_at(e->d_name);
737 if (!then)
738 continue;
633e5ad3 739 cutoff = cutoff_noresolve;
0f891e7d
JH
740 }
741 if (then < now - cutoff * 86400)
742 string_list_append(&to_remove, e->d_name);
743 }
a9930e35 744 closedir(dir);
0f891e7d
JH
745 for (i = 0; i < to_remove.nr; i++)
746 unlink_rr_item(to_remove.items[i].string);
747 string_list_clear(&to_remove, 0);
748}
749
750void rerere_clear(struct string_list *merge_rr)
751{
752 int i;
753
754 for (i = 0; i < merge_rr->nr; i++) {
755 const char *name = (const char *)merge_rr->items[i].util;
756 if (!has_rerere_resolution(name))
757 unlink_rr_item(name);
758 }
759 unlink_or_warn(git_path("MERGE_RR"));
760}