1#include "cache.h"
2#include "path-list.h"
3#include "xdiff/xdiff.h"
4#include "xdiff-interface.h"
5#include <time.h>
7static const char git_rerere_usage[] =
9"git-rerere [clear | status | diff | gc]";
10/* these values are days */
12static int cutoff_noresolve = 15;
13static int cutoff_resolve = 60;
14/* if rerere_enabled == -1, fall back to detection of .git/rr-cache */
16static int rerere_enabled = -1;
17static char *merge_rr_path;
19static const char *rr_path(const char *name, const char *file)
21{
22 return git_path("rr-cache/%s/%s", name, file);
23}
24static void read_rr(struct path_list *rr)
26{
27 unsigned char sha1[20];
28 char buf[PATH_MAX];
29 FILE *in = fopen(merge_rr_path, "r");
30 if (!in)
31 return;
32 while (fread(buf, 40, 1, in) == 1) {
33 int i;
34 char *name;
35 if (get_sha1_hex(buf, sha1))
36 die("corrupt MERGE_RR");
37 buf[40] = '\0';
38 name = xstrdup(buf);
39 if (fgetc(in) != '\t')
40 die("corrupt MERGE_RR");
41 for (i = 0; i < sizeof(buf) && (buf[i] = fgetc(in)); i++)
42 ; /* do nothing */
43 if (i == sizeof(buf))
44 die("filename too long");
45 path_list_insert(buf, rr)->util = xstrdup(name);
46 }
47 fclose(in);
48}
49static struct lock_file write_lock;
51static int write_rr(struct path_list *rr, int out_fd)
53{
54 int i;
55 for (i = 0; i < rr->nr; i++) {
56 const char *path = rr->items[i].path;
57 int length = strlen(path) + 1;
58 if (write_in_full(out_fd, rr->items[i].util, 40) != 40 ||
59 write_in_full(out_fd, "\t", 1) != 1 ||
60 write_in_full(out_fd, path, length) != length)
61 die("unable to write rerere record");
62 }
63 if (close(out_fd) != 0)
64 die("unable to write rerere record");
65 return commit_lock_file(&write_lock);
66}
67struct buffer {
69 char *ptr;
70 int nr, alloc;
71};
72static void append_line(struct buffer *buffer, const char *line)
74{
75 int len = strlen(line);
76 if (buffer->nr + len > buffer->alloc) {
78 buffer->alloc = alloc_nr(buffer->nr + len);
79 buffer->ptr = xrealloc(buffer->ptr, buffer->alloc);
80 }
81 memcpy(buffer->ptr + buffer->nr, line, len);
82 buffer->nr += len;
83}
84static void clear_buffer(struct buffer *buffer)
86{
87 free(buffer->ptr);
88 buffer->ptr = NULL;
89 buffer->nr = buffer->alloc = 0;
90}
91static int handle_file(const char *path,
93 unsigned char *sha1, const char *output)
94{
95 SHA_CTX ctx;
96 char buf[1024];
97 int hunk = 0, hunk_no = 0;
98 struct buffer minus = { NULL, 0, 0 }, plus = { NULL, 0, 0 };
99 struct buffer *one = &minus, *two = +
100 FILE *f = fopen(path, "r");
101 FILE *out;
102 if (!f)
104 return error("Could not open %s", path);
105 if (output) {
107 out = fopen(output, "w");
108 if (!out) {
109 fclose(f);
110 return error("Could not write %s", output);
111 }
112 } else
113 out = NULL;
114 if (sha1)
116 SHA1_Init(&ctx);
117 while (fgets(buf, sizeof(buf), f)) {
119 if (!prefixcmp(buf, "<<<<<<< "))
120 hunk = 1;
121 else if (!prefixcmp(buf, "======="))
122 hunk = 2;
123 else if (!prefixcmp(buf, ">>>>>>> ")) {
124 int one_is_longer = (one->nr > two->nr);
125 int common_len = one_is_longer ? two->nr : one->nr;
126 int cmp = memcmp(one->ptr, two->ptr, common_len);
127 hunk_no++;
129 hunk = 0;
130 if ((cmp > 0) || ((cmp == 0) && one_is_longer)) {
131 struct buffer *swap = one;
132 one = two;
133 two = swap;
134 }
135 if (out) {
136 fputs("<<<<<<<\n", out);
137 fwrite(one->ptr, one->nr, 1, out);
138 fputs("=======\n", out);
139 fwrite(two->ptr, two->nr, 1, out);
140 fputs(">>>>>>>\n", out);
141 }
142 if (sha1) {
143 SHA1_Update(&ctx, one->ptr, one->nr);
144 SHA1_Update(&ctx, "\0", 1);
145 SHA1_Update(&ctx, two->ptr, two->nr);
146 SHA1_Update(&ctx, "\0", 1);
147 }
148 clear_buffer(one);
149 clear_buffer(two);
150 } else if (hunk == 1)
151 append_line(one, buf);
152 else if (hunk == 2)
153 append_line(two, buf);
154 else if (out)
155 fputs(buf, out);
156 }
157 fclose(f);
159 if (out)
160 fclose(out);
161 if (sha1)
162 SHA1_Final(sha1, &ctx);
163 return hunk_no;
164}
165static int find_conflict(struct path_list *conflict)
167{
168 int i;
169 if (read_cache() < 0)
170 return error("Could not read index");
171 for (i = 0; i+1 < active_nr; i++) {
172 struct cache_entry *e2 = active_cache[i];
173 struct cache_entry *e3 = active_cache[i+1];
174 if (ce_stage(e2) == 2 &&
175 ce_stage(e3) == 3 &&
176 ce_same_name(e2, e3) &&
177 S_ISREG(ntohl(e2->ce_mode)) &&
178 S_ISREG(ntohl(e3->ce_mode))) {
179 path_list_insert((const char *)e2->name, conflict);
180 i++; /* skip over both #2 and #3 */
181 }
182 }
183 return 0;
184}
185static int merge(const char *name, const char *path)
187{
188 int ret;
189 mmfile_t cur, base, other;
190 mmbuffer_t result = {NULL, 0};
191 xpparam_t xpp = {XDF_NEED_MINIMAL};
192 if (handle_file(path, NULL, rr_path(name, "thisimage")) < 0)
194 return 1;
195 if (read_mmfile(&cur, rr_path(name, "thisimage")) ||
197 read_mmfile(&base, rr_path(name, "preimage")) ||
198 read_mmfile(&other, rr_path(name, "postimage")))
199 return 1;
200 ret = xdl_merge(&base, &cur, "", &other, "",
201 &xpp, XDL_MERGE_ZEALOUS, &result);
202 if (!ret) {
203 FILE *f = fopen(path, "w");
204 if (!f)
205 return error("Could not write to %s", path);
206 fwrite(result.ptr, result.size, 1, f);
207 fclose(f);
208 }
209 free(cur.ptr);
211 free(base.ptr);
212 free(other.ptr);
213 free(result.ptr);
214 return ret;
216}
217static void unlink_rr_item(const char *name)
219{
220 unlink(rr_path(name, "thisimage"));
221 unlink(rr_path(name, "preimage"));
222 unlink(rr_path(name, "postimage"));
223 rmdir(git_path("rr-cache/%s", name));
224}
225static void garbage_collect(struct path_list *rr)
227{
228 struct path_list to_remove = { NULL, 0, 0, 1 };
229 char buf[1024];
230 DIR *dir;
231 struct dirent *e;
232 int len, i, cutoff;
233 time_t now = time(NULL), then;
234 strlcpy(buf, git_path("rr-cache"), sizeof(buf));
236 len = strlen(buf);
237 dir = opendir(buf);
238 strcpy(buf + len++, "/");
239 while ((e = readdir(dir))) {
240 const char *name = e->d_name;
241 struct stat st;
242 if (name[0] == '.' && (name[1] == '\0' ||
243 (name[1] == '.' && name[2] == '\0')))
244 continue;
245 i = snprintf(buf + len, sizeof(buf) - len, "%s", name);
246 strlcpy(buf + len + i, "/preimage", sizeof(buf) - len - i);
247 if (stat(buf, &st))
248 continue;
249 then = st.st_mtime;
250 strlcpy(buf + len + i, "/postimage", sizeof(buf) - len - i);
251 cutoff = stat(buf, &st) ? cutoff_noresolve : cutoff_resolve;
252 if (then < now - cutoff * 86400) {
253 buf[len + i] = '\0';
254 path_list_insert(xstrdup(name), &to_remove);
255 }
256 }
257 for (i = 0; i < to_remove.nr; i++)
258 unlink_rr_item(to_remove.items[i].path);
259 path_list_clear(&to_remove, 0);
260}
261static int outf(void *dummy, mmbuffer_t *ptr, int nbuf)
263{
264 int i;
265 for (i = 0; i < nbuf; i++)
266 if (write_in_full(1, ptr[i].ptr, ptr[i].size) != ptr[i].size)
267 return -1;
268 return 0;
269}
270static int diff_two(const char *file1, const char *label1,
272 const char *file2, const char *label2)
273{
274 xpparam_t xpp;
275 xdemitconf_t xecfg;
276 xdemitcb_t ecb;
277 mmfile_t minus, plus;
278 if (read_mmfile(&minus, file1) || read_mmfile(&plus, file2))
280 return 1;
281 printf("--- a/%s\n+++ b/%s\n", label1, label2);
283 fflush(stdout);
284 xpp.flags = XDF_NEED_MINIMAL;
285 memset(&xecfg, 0, sizeof(xecfg));
286 xecfg.ctxlen = 3;
287 ecb.outf = outf;
288 xdl_diff(&minus, &plus, &xpp, &xecfg, &ecb);
289 free(minus.ptr);
291 free(plus.ptr);
292 return 0;
293}
294static int copy_file(const char *src, const char *dest)
296{
297 FILE *in, *out;
298 char buffer[32768];
299 int count;
300 if (!(in = fopen(src, "r")))
302 return error("Could not open %s", src);
303 if (!(out = fopen(dest, "w")))
304 return error("Could not open %s", dest);
305 while ((count = fread(buffer, 1, sizeof(buffer), in)))
306 fwrite(buffer, 1, count, out);
307 fclose(in);
308 fclose(out);
309 return 0;
310}
311static int do_plain_rerere(struct path_list *rr, int fd)
313{
314 struct path_list conflict = { NULL, 0, 0, 1 };
315 int i;
316 find_conflict(&conflict);
318 /*
320 * MERGE_RR records paths with conflicts immediately after merge
321 * failed. Some of the conflicted paths might have been hand resolved
322 * in the working tree since then, but the initial run would catch all
323 * and register their preimages.
324 */
325 for (i = 0; i < conflict.nr; i++) {
327 const char *path = conflict.items[i].path;
328 if (!path_list_has_path(rr, path)) {
329 unsigned char sha1[20];
330 char *hex;
331 int ret;
332 ret = handle_file(path, sha1, NULL);
333 if (ret < 1)
334 continue;
335 hex = xstrdup(sha1_to_hex(sha1));
336 path_list_insert(path, rr)->util = hex;
337 if (mkdir(git_path("rr-cache/%s", hex), 0755))
338 continue;;
339 handle_file(path, NULL, rr_path(hex, "preimage"));
340 fprintf(stderr, "Recorded preimage for '%s'\n", path);
341 }
342 }
343 /*
345 * Now some of the paths that had conflicts earlier might have been
346 * hand resolved. Others may be similar to a conflict already that
347 * was resolved before.
348 */
349 for (i = 0; i < rr->nr; i++) {
351 struct stat st;
352 int ret;
353 const char *path = rr->items[i].path;
354 const char *name = (const char *)rr->items[i].util;
355 if (!stat(rr_path(name, "preimage"), &st) &&
357 !stat(rr_path(name, "postimage"), &st)) {
358 if (!merge(name, path)) {
359 fprintf(stderr, "Resolved '%s' using "
360 "previous resolution.\n", path);
361 goto tail_optimization;
362 }
363 }
364 /* Let's see if we have resolved it. */
366 ret = handle_file(path, NULL, NULL);
367 if (ret)
368 continue;
369 fprintf(stderr, "Recorded resolution for '%s'.\n", path);
371 copy_file(path, rr_path(name, "postimage"));
372tail_optimization:
373 if (i < rr->nr - 1)
374 memmove(rr->items + i,
375 rr->items + i + 1,
376 sizeof(rr->items[0]) * (rr->nr - i - 1));
377 rr->nr--;
378 i--;
379 }
380 return write_rr(rr, fd);
382}
383static int git_rerere_config(const char *var, const char *value)
385{
386 if (!strcmp(var, "gc.rerereresolved"))
387 cutoff_resolve = git_config_int(var, value);
388 else if (!strcmp(var, "gc.rerereunresolved"))
389 cutoff_noresolve = git_config_int(var, value);
390 else if (!strcmp(var, "rerere.enabled"))
391 rerere_enabled = git_config_bool(var, value);
392 else
393 return git_default_config(var, value);
394 return 0;
395}
396static int is_rerere_enabled(void)
398{
399 struct stat st;
400 const char *rr_cache;
401 int rr_cache_exists;
402 if (!rerere_enabled)
404 return 0;
405 rr_cache = git_path("rr-cache");
407 rr_cache_exists = !stat(rr_cache, &st) && S_ISDIR(st.st_mode);
408 if (rerere_enabled < 0)
409 return rr_cache_exists;
410 if (!rr_cache_exists &&
412 (mkdir(rr_cache, 0777) || adjust_shared_perm(rr_cache)))
413 die("Could not create directory %s", rr_cache);
414 return 1;
415}
416int cmd_rerere(int argc, const char **argv, const char *prefix)
418{
419 struct path_list merge_rr = { NULL, 0, 0, 1 };
420 int i, fd = -1;
421 git_config(git_rerere_config);
423 if (!is_rerere_enabled())
424 return 0;
425 merge_rr_path = xstrdup(git_path("rr-cache/MERGE_RR"));
427 fd = hold_lock_file_for_update(&write_lock, merge_rr_path, 1);
428 read_rr(&merge_rr);
429 if (argc < 2)
431 return do_plain_rerere(&merge_rr, fd);
432 else if (!strcmp(argv[1], "clear")) {
433 for (i = 0; i < merge_rr.nr; i++) {
434 struct stat st;
435 const char *name = (const char *)merge_rr.items[i].util;
436 if (!stat(git_path("rr-cache/%s", name), &st) &&
437 S_ISDIR(st.st_mode) &&
438 stat(rr_path(name, "postimage"), &st))
439 unlink_rr_item(name);
440 }
441 unlink(merge_rr_path);
442 } else if (!strcmp(argv[1], "gc"))
443 garbage_collect(&merge_rr);
444 else if (!strcmp(argv[1], "status"))
445 for (i = 0; i < merge_rr.nr; i++)
446 printf("%s\n", merge_rr.items[i].path);
447 else if (!strcmp(argv[1], "diff"))
448 for (i = 0; i < merge_rr.nr; i++) {
449 const char *path = merge_rr.items[i].path;
450 const char *name = (const char *)merge_rr.items[i].util;
451 diff_two(rr_path(name, "preimage"), path, path, path);
452 }
453 else
454 usage(git_rerere_usage);
455 path_list_clear(&merge_rr, 1);
457 return 0;
458}