Fix mishandling of $Id$ expanded in the repository copy in convert.c
[git/git.git] / convert.c
1 #include "cache.h"
2 #include "attr.h"
3 #include "run-command.h"
4
5 /*
6 * convert.c - convert a file when checking it out and checking it in.
7 *
8 * This should use the pathname to decide on whether it wants to do some
9 * more interesting conversions (automatic gzip/unzip, general format
10 * conversions etc etc), but by default it just does automatic CRLF<->LF
11 * translation when the "auto_crlf" option is set.
12 */
13
14 #define CRLF_GUESS (-1)
15 #define CRLF_BINARY 0
16 #define CRLF_TEXT 1
17 #define CRLF_INPUT 2
18
19 struct text_stat {
20 /* CR, LF and CRLF counts */
21 unsigned cr, lf, crlf;
22
23 /* These are just approximations! */
24 unsigned printable, nonprintable;
25 };
26
27 static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
28 {
29 unsigned long i;
30
31 memset(stats, 0, sizeof(*stats));
32
33 for (i = 0; i < size; i++) {
34 unsigned char c = buf[i];
35 if (c == '\r') {
36 stats->cr++;
37 if (i+1 < size && buf[i+1] == '\n')
38 stats->crlf++;
39 continue;
40 }
41 if (c == '\n') {
42 stats->lf++;
43 continue;
44 }
45 if (c == 127)
46 /* DEL */
47 stats->nonprintable++;
48 else if (c < 32) {
49 switch (c) {
50 /* BS, HT, ESC and FF */
51 case '\b': case '\t': case '\033': case '\014':
52 stats->printable++;
53 break;
54 default:
55 stats->nonprintable++;
56 }
57 }
58 else
59 stats->printable++;
60 }
61 }
62
63 /*
64 * The same heuristics as diff.c::mmfile_is_binary()
65 */
66 static int is_binary(unsigned long size, struct text_stat *stats)
67 {
68
69 if ((stats->printable >> 7) < stats->nonprintable)
70 return 1;
71 /*
72 * Other heuristics? Average line length might be relevant,
73 * as might LF vs CR vs CRLF counts..
74 *
75 * NOTE! It might be normal to have a low ratio of CRLF to LF
76 * (somebody starts with a LF-only file and edits it with an editor
77 * that adds CRLF only to lines that are added..). But do we
78 * want to support CR-only? Probably not.
79 */
80 return 0;
81 }
82
83 static char *crlf_to_git(const char *path, const char *src, unsigned long *sizep, int action)
84 {
85 char *buffer, *dst;
86 unsigned long size, nsize;
87 struct text_stat stats;
88
89 if ((action == CRLF_BINARY) || !auto_crlf)
90 return NULL;
91
92 size = *sizep;
93 if (!size)
94 return NULL;
95
96 gather_stats(src, size, &stats);
97
98 /* No CR? Nothing to convert, regardless. */
99 if (!stats.cr)
100 return NULL;
101
102 if (action == CRLF_GUESS) {
103 /*
104 * We're currently not going to even try to convert stuff
105 * that has bare CR characters. Does anybody do that crazy
106 * stuff?
107 */
108 if (stats.cr != stats.crlf)
109 return NULL;
110
111 /*
112 * And add some heuristics for binary vs text, of course...
113 */
114 if (is_binary(size, &stats))
115 return NULL;
116 }
117
118 /*
119 * Ok, allocate a new buffer, fill it in, and return it
120 * to let the caller know that we switched buffers.
121 */
122 nsize = size - stats.crlf;
123 buffer = xmalloc(nsize);
124 *sizep = nsize;
125
126 dst = buffer;
127 if (action == CRLF_GUESS) {
128 /*
129 * If we guessed, we already know we rejected a file with
130 * lone CR, and we can strip a CR without looking at what
131 * follow it.
132 */
133 do {
134 unsigned char c = *src++;
135 if (c != '\r')
136 *dst++ = c;
137 } while (--size);
138 } else {
139 do {
140 unsigned char c = *src++;
141 if (! (c == '\r' && (1 < size && *src == '\n')))
142 *dst++ = c;
143 } while (--size);
144 }
145
146 return buffer;
147 }
148
149 static char *crlf_to_worktree(const char *path, const char *src, unsigned long *sizep, int action)
150 {
151 char *buffer, *dst;
152 unsigned long size, nsize;
153 struct text_stat stats;
154 unsigned char last;
155
156 if ((action == CRLF_BINARY) || (action == CRLF_INPUT) ||
157 auto_crlf <= 0)
158 return NULL;
159
160 size = *sizep;
161 if (!size)
162 return NULL;
163
164 gather_stats(src, size, &stats);
165
166 /* No LF? Nothing to convert, regardless. */
167 if (!stats.lf)
168 return NULL;
169
170 /* Was it already in CRLF format? */
171 if (stats.lf == stats.crlf)
172 return NULL;
173
174 if (action == CRLF_GUESS) {
175 /* If we have any bare CR characters, we're not going to touch it */
176 if (stats.cr != stats.crlf)
177 return NULL;
178
179 if (is_binary(size, &stats))
180 return NULL;
181 }
182
183 /*
184 * Ok, allocate a new buffer, fill it in, and return it
185 * to let the caller know that we switched buffers.
186 */
187 nsize = size + stats.lf - stats.crlf;
188 buffer = xmalloc(nsize);
189 *sizep = nsize;
190 last = 0;
191
192 dst = buffer;
193 do {
194 unsigned char c = *src++;
195 if (c == '\n' && last != '\r')
196 *dst++ = '\r';
197 *dst++ = c;
198 last = c;
199 } while (--size);
200
201 return buffer;
202 }
203
204 static int filter_buffer(const char *path, const char *src,
205 unsigned long size, const char *cmd)
206 {
207 /*
208 * Spawn cmd and feed the buffer contents through its stdin.
209 */
210 struct child_process child_process;
211 int pipe_feed[2];
212 int write_err, status;
213
214 memset(&child_process, 0, sizeof(child_process));
215
216 if (pipe(pipe_feed) < 0) {
217 error("cannot create pipe to run external filter %s", cmd);
218 return 1;
219 }
220
221 child_process.pid = fork();
222 if (child_process.pid < 0) {
223 error("cannot fork to run external filter %s", cmd);
224 close(pipe_feed[0]);
225 close(pipe_feed[1]);
226 return 1;
227 }
228 if (!child_process.pid) {
229 dup2(pipe_feed[0], 0);
230 close(pipe_feed[0]);
231 close(pipe_feed[1]);
232 execlp("sh", "sh", "-c", cmd, NULL);
233 return 1;
234 }
235 close(pipe_feed[0]);
236
237 write_err = (write_in_full(pipe_feed[1], src, size) < 0);
238 if (close(pipe_feed[1]))
239 write_err = 1;
240 if (write_err)
241 error("cannot feed the input to external filter %s", cmd);
242
243 status = finish_command(&child_process);
244 if (status)
245 error("external filter %s failed %d", cmd, -status);
246 return (write_err || status);
247 }
248
249 static char *apply_filter(const char *path, const char *src,
250 unsigned long *sizep, const char *cmd)
251 {
252 /*
253 * Create a pipeline to have the command filter the buffer's
254 * contents.
255 *
256 * (child --> cmd) --> us
257 */
258 const int SLOP = 4096;
259 int pipe_feed[2];
260 int status;
261 char *dst;
262 unsigned long dstsize, dstalloc;
263 struct child_process child_process;
264
265 if (!cmd)
266 return NULL;
267
268 memset(&child_process, 0, sizeof(child_process));
269
270 if (pipe(pipe_feed) < 0) {
271 error("cannot create pipe to run external filter %s", cmd);
272 return NULL;
273 }
274
275 fflush(NULL);
276 child_process.pid = fork();
277 if (child_process.pid < 0) {
278 error("cannot fork to run external filter %s", cmd);
279 close(pipe_feed[0]);
280 close(pipe_feed[1]);
281 return NULL;
282 }
283 if (!child_process.pid) {
284 dup2(pipe_feed[1], 1);
285 close(pipe_feed[0]);
286 close(pipe_feed[1]);
287 exit(filter_buffer(path, src, *sizep, cmd));
288 }
289 close(pipe_feed[1]);
290
291 dstalloc = *sizep;
292 dst = xmalloc(dstalloc);
293 dstsize = 0;
294
295 while (1) {
296 ssize_t numread = xread(pipe_feed[0], dst + dstsize,
297 dstalloc - dstsize);
298
299 if (numread <= 0) {
300 if (!numread)
301 break;
302 error("read from external filter %s failed", cmd);
303 free(dst);
304 dst = NULL;
305 break;
306 }
307 dstsize += numread;
308 if (dstalloc <= dstsize + SLOP) {
309 dstalloc = dstsize + SLOP;
310 dst = xrealloc(dst, dstalloc);
311 }
312 }
313 if (close(pipe_feed[0])) {
314 error("read from external filter %s failed", cmd);
315 free(dst);
316 dst = NULL;
317 }
318
319 status = finish_command(&child_process);
320 if (status) {
321 error("external filter %s failed %d", cmd, -status);
322 free(dst);
323 dst = NULL;
324 }
325
326 if (dst)
327 *sizep = dstsize;
328 return dst;
329 }
330
331 static struct convert_driver {
332 const char *name;
333 struct convert_driver *next;
334 char *smudge;
335 char *clean;
336 } *user_convert, **user_convert_tail;
337
338 static int read_convert_config(const char *var, const char *value)
339 {
340 const char *ep, *name;
341 int namelen;
342 struct convert_driver *drv;
343
344 /*
345 * External conversion drivers are configured using
346 * "filter.<name>.variable".
347 */
348 if (prefixcmp(var, "filter.") || (ep = strrchr(var, '.')) == var + 6)
349 return 0;
350 name = var + 7;
351 namelen = ep - name;
352 for (drv = user_convert; drv; drv = drv->next)
353 if (!strncmp(drv->name, name, namelen) && !drv->name[namelen])
354 break;
355 if (!drv) {
356 char *namebuf;
357 drv = xcalloc(1, sizeof(struct convert_driver));
358 namebuf = xmalloc(namelen + 1);
359 memcpy(namebuf, name, namelen);
360 namebuf[namelen] = 0;
361 drv->name = namebuf;
362 drv->next = NULL;
363 *user_convert_tail = drv;
364 user_convert_tail = &(drv->next);
365 }
366
367 ep++;
368
369 /*
370 * filter.<name>.smudge and filter.<name>.clean specifies
371 * the command line:
372 *
373 * command-line
374 *
375 * The command-line will not be interpolated in any way.
376 */
377
378 if (!strcmp("smudge", ep)) {
379 if (!value)
380 return error("%s: lacks value", var);
381 drv->smudge = strdup(value);
382 return 0;
383 }
384
385 if (!strcmp("clean", ep)) {
386 if (!value)
387 return error("%s: lacks value", var);
388 drv->clean = strdup(value);
389 return 0;
390 }
391 return 0;
392 }
393
394 static void setup_convert_check(struct git_attr_check *check)
395 {
396 static struct git_attr *attr_crlf;
397 static struct git_attr *attr_ident;
398 static struct git_attr *attr_filter;
399
400 if (!attr_crlf) {
401 attr_crlf = git_attr("crlf", 4);
402 attr_ident = git_attr("ident", 5);
403 attr_filter = git_attr("filter", 6);
404 user_convert_tail = &user_convert;
405 git_config(read_convert_config);
406 }
407 check[0].attr = attr_crlf;
408 check[1].attr = attr_ident;
409 check[2].attr = attr_filter;
410 }
411
412 static int count_ident(const char *cp, unsigned long size)
413 {
414 /*
415 * "$Id: 0000000000000000000000000000000000000000 $" <=> "$Id$"
416 */
417 int cnt = 0;
418 char ch;
419
420 while (size) {
421 ch = *cp++;
422 size--;
423 if (ch != '$')
424 continue;
425 if (size < 3)
426 break;
427 if (memcmp("Id", cp, 2))
428 continue;
429 ch = cp[2];
430 cp += 3;
431 size -= 3;
432 if (ch == '$')
433 cnt++; /* $Id$ */
434 if (ch != ':')
435 continue;
436
437 /*
438 * "$Id: ... "; scan up to the closing dollar sign and discard.
439 */
440 while (size) {
441 ch = *cp++;
442 size--;
443 if (ch == '$') {
444 cnt++;
445 break;
446 }
447 }
448 }
449 return cnt;
450 }
451
452 static char *ident_to_git(const char *path, const char *src, unsigned long *sizep, int ident)
453 {
454 int cnt;
455 unsigned long size;
456 char *dst, *buf;
457
458 if (!ident)
459 return NULL;
460 size = *sizep;
461 cnt = count_ident(src, size);
462 if (!cnt)
463 return NULL;
464 buf = xmalloc(size);
465
466 for (dst = buf; size; size--) {
467 char ch = *src++;
468 *dst++ = ch;
469 if ((ch == '$') && (3 <= size) &&
470 !memcmp("Id:", src, 3)) {
471 unsigned long rem = size - 3;
472 const char *cp = src + 3;
473 do {
474 ch = *cp++;
475 if (ch == '$')
476 break;
477 rem--;
478 } while (rem);
479 if (!rem)
480 continue;
481 memcpy(dst, "Id$", 3);
482 dst += 3;
483 size -= (cp - src);
484 src = cp;
485 }
486 }
487
488 *sizep = dst - buf;
489 return buf;
490 }
491
492 static char *ident_to_worktree(const char *path, const char *src, unsigned long *sizep, int ident)
493 {
494 int cnt;
495 unsigned long size;
496 char *dst, *buf;
497 unsigned char sha1[20];
498
499 if (!ident)
500 return NULL;
501
502 size = *sizep;
503 cnt = count_ident(src, size);
504 if (!cnt)
505 return NULL;
506
507 hash_sha1_file(src, size, "blob", sha1);
508 buf = xmalloc(size + cnt * 43);
509
510 for (dst = buf; size; size--) {
511 const char *cp;
512 /* Fetch next source character, move the pointer on */
513 char ch = *src++;
514 /* Copy the current character to the destination */
515 *dst++ = ch;
516 /* If the current character is "$" or there are less than three
517 * remaining bytes or the two bytes following this one are not
518 * "Id", then simply read the next character */
519 if ((ch != '$') || (size < 3) || memcmp("Id", src, 2))
520 continue;
521 /*
522 * Here when
523 * - There are more than 2 bytes remaining
524 * - The current three bytes are "$Id"
525 * with
526 * - ch == "$"
527 * - src[0] == "I"
528 */
529
530 /*
531 * It's possible that an expanded Id has crept its way into the
532 * repository, we cope with that by stripping the expansion out
533 */
534 if (src[2] == ':') {
535 /* Expanded keywords have "$Id:" at the front */
536
537 /* discard up to but not including the closing $ */
538 unsigned long rem = size - 3;
539 /* Point at first byte after the ":" */
540 cp = src + 3;
541 /*
542 * Throw away characters until either
543 * - we reach a "$"
544 * - we run out of bytes (rem == 0)
545 */
546 do {
547 ch = *cp;
548 if (ch == '$')
549 break;
550 cp++;
551 rem--;
552 } while (rem);
553 /* If the above finished because it ran out of characters, then
554 * this is an incomplete keyword, so don't run the expansion */
555 if (!rem)
556 continue;
557 } else if (src[2] == '$')
558 cp = src + 2;
559 else
560 /* Anything other than "$Id:XXX$" or $Id$ and we skip the
561 * expansion */
562 continue;
563
564 /* cp is now pointing at the last $ of the keyword */
565
566 memcpy(dst, "Id: ", 4);
567 dst += 4;
568 memcpy(dst, sha1_to_hex(sha1), 40);
569 dst += 40;
570 *dst++ = ' ';
571
572 /* Adjust for the characters we've discarded */
573 size -= (cp - src);
574 src = cp;
575
576 /* Copy the final "$" */
577 *dst++ = *src++;
578 size--;
579 }
580
581 *sizep = dst - buf;
582 return buf;
583 }
584
585 static int git_path_check_crlf(const char *path, struct git_attr_check *check)
586 {
587 const char *value = check->value;
588
589 if (ATTR_TRUE(value))
590 return CRLF_TEXT;
591 else if (ATTR_FALSE(value))
592 return CRLF_BINARY;
593 else if (ATTR_UNSET(value))
594 ;
595 else if (!strcmp(value, "input"))
596 return CRLF_INPUT;
597 return CRLF_GUESS;
598 }
599
600 static struct convert_driver *git_path_check_convert(const char *path,
601 struct git_attr_check *check)
602 {
603 const char *value = check->value;
604 struct convert_driver *drv;
605
606 if (ATTR_TRUE(value) || ATTR_FALSE(value) || ATTR_UNSET(value))
607 return NULL;
608 for (drv = user_convert; drv; drv = drv->next)
609 if (!strcmp(value, drv->name))
610 return drv;
611 return NULL;
612 }
613
614 static int git_path_check_ident(const char *path, struct git_attr_check *check)
615 {
616 const char *value = check->value;
617
618 return !!ATTR_TRUE(value);
619 }
620
621 char *convert_to_git(const char *path, const char *src, unsigned long *sizep)
622 {
623 struct git_attr_check check[3];
624 int crlf = CRLF_GUESS;
625 int ident = 0;
626 char *filter = NULL;
627 char *buf, *buf2;
628
629 setup_convert_check(check);
630 if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
631 struct convert_driver *drv;
632 crlf = git_path_check_crlf(path, check + 0);
633 ident = git_path_check_ident(path, check + 1);
634 drv = git_path_check_convert(path, check + 2);
635 if (drv && drv->clean)
636 filter = drv->clean;
637 }
638
639 buf = apply_filter(path, src, sizep, filter);
640
641 buf2 = crlf_to_git(path, buf ? buf : src, sizep, crlf);
642 if (buf2) {
643 free(buf);
644 buf = buf2;
645 }
646
647 buf2 = ident_to_git(path, buf ? buf : src, sizep, ident);
648 if (buf2) {
649 free(buf);
650 buf = buf2;
651 }
652
653 return buf;
654 }
655
656 char *convert_to_working_tree(const char *path, const char *src, unsigned long *sizep)
657 {
658 struct git_attr_check check[3];
659 int crlf = CRLF_GUESS;
660 int ident = 0;
661 char *filter = NULL;
662 char *buf, *buf2;
663
664 setup_convert_check(check);
665 if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
666 struct convert_driver *drv;
667 crlf = git_path_check_crlf(path, check + 0);
668 ident = git_path_check_ident(path, check + 1);
669 drv = git_path_check_convert(path, check + 2);
670 if (drv && drv->smudge)
671 filter = drv->smudge;
672 }
673
674 buf = ident_to_worktree(path, src, sizep, ident);
675
676 buf2 = crlf_to_worktree(path, buf ? buf : src, sizep, crlf);
677 if (buf2) {
678 free(buf);
679 buf = buf2;
680 }
681
682 buf2 = apply_filter(path, buf ? buf : src, sizep, filter);
683 if (buf2) {
684 free(buf);
685 buf = buf2;
686 }
687
688 return buf;
689 }
690
691 void *convert_sha1_file(const char *path, const unsigned char *sha1,
692 unsigned int mode, enum object_type *type,
693 unsigned long *size)
694 {
695 void *buffer = read_sha1_file(sha1, type, size);
696 if (S_ISREG(mode) && buffer) {
697 void *converted = convert_to_working_tree(path, buffer, size);
698 if (converted) {
699 free(buffer);
700 buffer = converted;
701 }
702 }
703 return buffer;
704 }