Add 'filter' attribute and external filter driver definition.
[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) || (action == CRLF_GUESS && !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             (action == CRLF_GUESS && 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          * "$ident: 0000000000000000000000000000000000000000 $" <=> "$ident$"
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 < 6)
426                         break;
427                 if (memcmp("ident", cp, 5))
428                         continue;
429                 ch = cp[5];
430                 cp += 6;
431                 size -= 6;
432                 if (ch == '$')
433                         cnt++; /* $ident$ */
434                 if (ch != ':')
435                         continue;
436
437                 /*
438                  * "$ident: ... "; 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 == '$') && (6 <= size) &&
470                     !memcmp("ident:", src, 6)) {
471                         unsigned long rem = size - 6;
472                         const char *cp = src + 6;
473                         do {
474                                 ch = *cp++;
475                                 if (ch == '$')
476                                         break;
477                                 rem--;
478                         } while (rem);
479                         if (!rem)
480                                 continue;
481                         memcpy(dst, "ident$", 6);
482                         dst += 6;
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                 char ch = *src++;
513                 *dst++ = ch;
514                 if ((ch != '$') || (size < 6) || memcmp("ident", src, 5))
515                         continue;
516
517                 if (src[5] == ':') {
518                         /* discard up to but not including the closing $ */
519                         unsigned long rem = size - 6;
520                         cp = src + 6;
521                         do {
522                                 ch = *cp++;
523                                 if (ch == '$')
524                                         break;
525                                 rem--;
526                         } while (rem);
527                         if (!rem)
528                                 continue;
529                         size -= (cp - src);
530                 } else if (src[5] == '$')
531                         cp = src + 5;
532                 else
533                         continue;
534
535                 memcpy(dst, "ident: ", 7);
536                 dst += 7;
537                 memcpy(dst, sha1_to_hex(sha1), 40);
538                 dst += 40;
539                 *dst++ = ' ';
540                 size -= (cp - src);
541                 src = cp;
542                 *dst++ = *src++;
543                 size--;
544         }
545
546         *sizep = dst - buf;
547         return buf;
548 }
549
550 static int git_path_check_crlf(const char *path, struct git_attr_check *check)
551 {
552         const char *value = check->value;
553
554         if (ATTR_TRUE(value))
555                 return CRLF_TEXT;
556         else if (ATTR_FALSE(value))
557                 return CRLF_BINARY;
558         else if (ATTR_UNSET(value))
559                 ;
560         else if (!strcmp(value, "input"))
561                 return CRLF_INPUT;
562         return CRLF_GUESS;
563 }
564
565 static struct convert_driver *git_path_check_convert(const char *path,
566                                              struct git_attr_check *check)
567 {
568         const char *value = check->value;
569         struct convert_driver *drv;
570
571         if (ATTR_TRUE(value) || ATTR_FALSE(value) || ATTR_UNSET(value))
572                 return NULL;
573         for (drv = user_convert; drv; drv = drv->next)
574                 if (!strcmp(value, drv->name))
575                         return drv;
576         return NULL;
577 }
578
579 static int git_path_check_ident(const char *path, struct git_attr_check *check)
580 {
581         const char *value = check->value;
582
583         return !!ATTR_TRUE(value);
584 }
585
586 char *convert_to_git(const char *path, const char *src, unsigned long *sizep)
587 {
588         struct git_attr_check check[3];
589         int crlf = CRLF_GUESS;
590         int ident = 0;
591         char *filter = NULL;
592         char *buf, *buf2;
593
594         setup_convert_check(check);
595         if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
596                 struct convert_driver *drv;
597                 crlf = git_path_check_crlf(path, check + 0);
598                 ident = git_path_check_ident(path, check + 1);
599                 drv = git_path_check_convert(path, check + 2);
600                 if (drv && drv->clean)
601                         filter = drv->clean;
602         }
603
604         buf = apply_filter(path, src, sizep, filter);
605
606         buf2 = crlf_to_git(path, buf ? buf : src, sizep, crlf);
607         if (buf2) {
608                 free(buf);
609                 buf = buf2;
610         }
611
612         buf2 = ident_to_git(path, buf ? buf : src, sizep, ident);
613         if (buf2) {
614                 free(buf);
615                 buf = buf2;
616         }
617
618         return buf;
619 }
620
621 char *convert_to_working_tree(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->smudge)
636                         filter = drv->smudge;
637         }
638
639         buf = ident_to_worktree(path, src, sizep, ident);
640
641         buf2 = crlf_to_worktree(path, buf ? buf : src, sizep, crlf);
642         if (buf2) {
643                 free(buf);
644                 buf = buf2;
645         }
646
647         buf2 = apply_filter(path, buf ? buf : src, sizep, filter);
648         if (buf2) {
649                 free(buf);
650                 buf = buf2;
651         }
652
653         return buf;
654 }