Merge branch 'js/t9903-chaining' into maint
[git] / mailinfo.c
1 #include "cache.h"
2 #include "utf8.h"
3 #include "strbuf.h"
4 #include "mailinfo.h"
5
6 static void cleanup_space(struct strbuf *sb)
7 {
8         size_t pos, cnt;
9         for (pos = 0; pos < sb->len; pos++) {
10                 if (isspace(sb->buf[pos])) {
11                         sb->buf[pos] = ' ';
12                         for (cnt = 0; isspace(sb->buf[pos + cnt + 1]); cnt++);
13                         strbuf_remove(sb, pos + 1, cnt);
14                 }
15         }
16 }
17
18 static void get_sane_name(struct strbuf *out, struct strbuf *name, struct strbuf *email)
19 {
20         struct strbuf *src = name;
21         if (name->len < 3 || 60 < name->len || strchr(name->buf, '@') ||
22                 strchr(name->buf, '<') || strchr(name->buf, '>'))
23                 src = email;
24         else if (name == out)
25                 return;
26         strbuf_reset(out);
27         strbuf_addbuf(out, src);
28 }
29
30 static void parse_bogus_from(struct mailinfo *mi, const struct strbuf *line)
31 {
32         /* John Doe <johndoe> */
33
34         char *bra, *ket;
35         /* This is fallback, so do not bother if we already have an
36          * e-mail address.
37          */
38         if (mi->email.len)
39                 return;
40
41         bra = strchr(line->buf, '<');
42         if (!bra)
43                 return;
44         ket = strchr(bra, '>');
45         if (!ket)
46                 return;
47
48         strbuf_reset(&mi->email);
49         strbuf_add(&mi->email, bra + 1, ket - bra - 1);
50
51         strbuf_reset(&mi->name);
52         strbuf_add(&mi->name, line->buf, bra - line->buf);
53         strbuf_trim(&mi->name);
54         get_sane_name(&mi->name, &mi->name, &mi->email);
55 }
56
57 static void handle_from(struct mailinfo *mi, const struct strbuf *from)
58 {
59         char *at;
60         size_t el;
61         struct strbuf f;
62
63         strbuf_init(&f, from->len);
64         strbuf_addbuf(&f, from);
65
66         at = strchr(f.buf, '@');
67         if (!at) {
68                 parse_bogus_from(mi, from);
69                 return;
70         }
71
72         /*
73          * If we already have one email, don't take any confusing lines
74          */
75         if (mi->email.len && strchr(at + 1, '@')) {
76                 strbuf_release(&f);
77                 return;
78         }
79
80         /* Pick up the string around '@', possibly delimited with <>
81          * pair; that is the email part.
82          */
83         while (at > f.buf) {
84                 char c = at[-1];
85                 if (isspace(c))
86                         break;
87                 if (c == '<') {
88                         at[-1] = ' ';
89                         break;
90                 }
91                 at--;
92         }
93         el = strcspn(at, " \n\t\r\v\f>");
94         strbuf_reset(&mi->email);
95         strbuf_add(&mi->email, at, el);
96         strbuf_remove(&f, at - f.buf, el + (at[el] ? 1 : 0));
97
98         /* The remainder is name.  It could be
99          *
100          * - "John Doe <john.doe@xz>"                   (a), or
101          * - "john.doe@xz (John Doe)"                   (b), or
102          * - "John (zzz) Doe <john.doe@xz> (Comment)"   (c)
103          *
104          * but we have removed the email part, so
105          *
106          * - remove extra spaces which could stay after email (case 'c'), and
107          * - trim from both ends, possibly removing the () pair at the end
108          *   (cases 'a' and 'b').
109          */
110         cleanup_space(&f);
111         strbuf_trim(&f);
112         if (f.buf[0] == '(' && f.len && f.buf[f.len - 1] == ')') {
113                 strbuf_remove(&f, 0, 1);
114                 strbuf_setlen(&f, f.len - 1);
115         }
116
117         get_sane_name(&mi->name, &f, &mi->email);
118         strbuf_release(&f);
119 }
120
121 static void handle_header(struct strbuf **out, const struct strbuf *line)
122 {
123         if (!*out) {
124                 *out = xmalloc(sizeof(struct strbuf));
125                 strbuf_init(*out, line->len);
126         } else
127                 strbuf_reset(*out);
128
129         strbuf_addbuf(*out, line);
130 }
131
132 /* NOTE NOTE NOTE.  We do not claim we do full MIME.  We just attempt
133  * to have enough heuristics to grok MIME encoded patches often found
134  * on our mailing lists.  For example, we do not even treat header lines
135  * case insensitively.
136  */
137
138 static int slurp_attr(const char *line, const char *name, struct strbuf *attr)
139 {
140         const char *ends, *ap = strcasestr(line, name);
141         size_t sz;
142
143         strbuf_setlen(attr, 0);
144         if (!ap)
145                 return 0;
146         ap += strlen(name);
147         if (*ap == '"') {
148                 ap++;
149                 ends = "\"";
150         }
151         else
152                 ends = "; \t";
153         sz = strcspn(ap, ends);
154         strbuf_add(attr, ap, sz);
155         return 1;
156 }
157
158 static void handle_content_type(struct mailinfo *mi, struct strbuf *line)
159 {
160         struct strbuf *boundary = xmalloc(sizeof(struct strbuf));
161         strbuf_init(boundary, line->len);
162
163         if (slurp_attr(line->buf, "boundary=", boundary)) {
164                 strbuf_insert(boundary, 0, "--", 2);
165                 if (++mi->content_top >= &mi->content[MAX_BOUNDARIES]) {
166                         error("Too many boundaries to handle");
167                         mi->input_error = -1;
168                         mi->content_top = &mi->content[MAX_BOUNDARIES] - 1;
169                         return;
170                 }
171                 *(mi->content_top) = boundary;
172                 boundary = NULL;
173         }
174         slurp_attr(line->buf, "charset=", &mi->charset);
175
176         if (boundary) {
177                 strbuf_release(boundary);
178                 free(boundary);
179         }
180 }
181
182 static void handle_content_transfer_encoding(struct mailinfo *mi,
183                                              const struct strbuf *line)
184 {
185         if (strcasestr(line->buf, "base64"))
186                 mi->transfer_encoding = TE_BASE64;
187         else if (strcasestr(line->buf, "quoted-printable"))
188                 mi->transfer_encoding = TE_QP;
189         else
190                 mi->transfer_encoding = TE_DONTCARE;
191 }
192
193 static int is_multipart_boundary(struct mailinfo *mi, const struct strbuf *line)
194 {
195         struct strbuf *content_top = *(mi->content_top);
196
197         return ((content_top->len <= line->len) &&
198                 !memcmp(line->buf, content_top->buf, content_top->len));
199 }
200
201 static void cleanup_subject(struct mailinfo *mi, struct strbuf *subject)
202 {
203         size_t at = 0;
204
205         while (at < subject->len) {
206                 char *pos;
207                 size_t remove;
208
209                 switch (subject->buf[at]) {
210                 case 'r': case 'R':
211                         if (subject->len <= at + 3)
212                                 break;
213                         if ((subject->buf[at + 1] == 'e' ||
214                              subject->buf[at + 1] == 'E') &&
215                             subject->buf[at + 2] == ':') {
216                                 strbuf_remove(subject, at, 3);
217                                 continue;
218                         }
219                         at++;
220                         break;
221                 case ' ': case '\t': case ':':
222                         strbuf_remove(subject, at, 1);
223                         continue;
224                 case '[':
225                         pos = strchr(subject->buf + at, ']');
226                         if (!pos)
227                                 break;
228                         remove = pos - subject->buf + at + 1;
229                         if (!mi->keep_non_patch_brackets_in_subject ||
230                             (7 <= remove &&
231                              memmem(subject->buf + at, remove, "PATCH", 5)))
232                                 strbuf_remove(subject, at, remove);
233                         else {
234                                 at += remove;
235                                 /*
236                                  * If the input had a space after the ], keep
237                                  * it.  We don't bother with finding the end of
238                                  * the space, since we later normalize it
239                                  * anyway.
240                                  */
241                                 if (isspace(subject->buf[at]))
242                                         at += 1;
243                         }
244                         continue;
245                 }
246                 break;
247         }
248         strbuf_trim(subject);
249 }
250
251 #define MAX_HDR_PARSED 10
252 static const char *header[MAX_HDR_PARSED] = {
253         "From","Subject","Date",
254 };
255
256 static inline int cmp_header(const struct strbuf *line, const char *hdr)
257 {
258         int len = strlen(hdr);
259         return !strncasecmp(line->buf, hdr, len) && line->len > len &&
260                         line->buf[len] == ':' && isspace(line->buf[len + 1]);
261 }
262
263 static int is_format_patch_separator(const char *line, int len)
264 {
265         static const char SAMPLE[] =
266                 "From e6807f3efca28b30decfecb1732a56c7db1137ee Mon Sep 17 00:00:00 2001\n";
267         const char *cp;
268
269         if (len != strlen(SAMPLE))
270                 return 0;
271         if (!skip_prefix(line, "From ", &cp))
272                 return 0;
273         if (strspn(cp, "0123456789abcdef") != 40)
274                 return 0;
275         cp += 40;
276         return !memcmp(SAMPLE + (cp - line), cp, strlen(SAMPLE) - (cp - line));
277 }
278
279 static struct strbuf *decode_q_segment(const struct strbuf *q_seg, int rfc2047)
280 {
281         const char *in = q_seg->buf;
282         int c;
283         struct strbuf *out = xmalloc(sizeof(struct strbuf));
284         strbuf_init(out, q_seg->len);
285
286         while ((c = *in++) != 0) {
287                 if (c == '=') {
288                         int d = *in++;
289                         if (d == '\n' || !d)
290                                 break; /* drop trailing newline */
291                         strbuf_addch(out, (hexval(d) << 4) | hexval(*in++));
292                         continue;
293                 }
294                 if (rfc2047 && c == '_') /* rfc2047 4.2 (2) */
295                         c = 0x20;
296                 strbuf_addch(out, c);
297         }
298         return out;
299 }
300
301 static struct strbuf *decode_b_segment(const struct strbuf *b_seg)
302 {
303         /* Decode in..ep, possibly in-place to ot */
304         int c, pos = 0, acc = 0;
305         const char *in = b_seg->buf;
306         struct strbuf *out = xmalloc(sizeof(struct strbuf));
307         strbuf_init(out, b_seg->len);
308
309         while ((c = *in++) != 0) {
310                 if (c == '+')
311                         c = 62;
312                 else if (c == '/')
313                         c = 63;
314                 else if ('A' <= c && c <= 'Z')
315                         c -= 'A';
316                 else if ('a' <= c && c <= 'z')
317                         c -= 'a' - 26;
318                 else if ('0' <= c && c <= '9')
319                         c -= '0' - 52;
320                 else
321                         continue; /* garbage */
322                 switch (pos++) {
323                 case 0:
324                         acc = (c << 2);
325                         break;
326                 case 1:
327                         strbuf_addch(out, (acc | (c >> 4)));
328                         acc = (c & 15) << 4;
329                         break;
330                 case 2:
331                         strbuf_addch(out, (acc | (c >> 2)));
332                         acc = (c & 3) << 6;
333                         break;
334                 case 3:
335                         strbuf_addch(out, (acc | c));
336                         acc = pos = 0;
337                         break;
338                 }
339         }
340         return out;
341 }
342
343 static int convert_to_utf8(struct mailinfo *mi,
344                            struct strbuf *line, const char *charset)
345 {
346         char *out;
347
348         if (!mi->metainfo_charset || !charset || !*charset)
349                 return 0;
350
351         if (same_encoding(mi->metainfo_charset, charset))
352                 return 0;
353         out = reencode_string(line->buf, mi->metainfo_charset, charset);
354         if (!out) {
355                 mi->input_error = -1;
356                 return error("cannot convert from %s to %s",
357                              charset, mi->metainfo_charset);
358         }
359         strbuf_attach(line, out, strlen(out), strlen(out));
360         return 0;
361 }
362
363 static void decode_header(struct mailinfo *mi, struct strbuf *it)
364 {
365         char *in, *ep, *cp;
366         struct strbuf outbuf = STRBUF_INIT, *dec;
367         struct strbuf charset_q = STRBUF_INIT, piecebuf = STRBUF_INIT;
368         int found_error = 1; /* pessimism */
369
370         in = it->buf;
371         while (in - it->buf <= it->len && (ep = strstr(in, "=?")) != NULL) {
372                 int encoding;
373                 strbuf_reset(&charset_q);
374                 strbuf_reset(&piecebuf);
375
376                 if (in != ep) {
377                         /*
378                          * We are about to process an encoded-word
379                          * that begins at ep, but there is something
380                          * before the encoded word.
381                          */
382                         char *scan;
383                         for (scan = in; scan < ep; scan++)
384                                 if (!isspace(*scan))
385                                         break;
386
387                         if (scan != ep || in == it->buf) {
388                                 /*
389                                  * We should not lose that "something",
390                                  * unless we have just processed an
391                                  * encoded-word, and there is only LWS
392                                  * before the one we are about to process.
393                                  */
394                                 strbuf_add(&outbuf, in, ep - in);
395                         }
396                 }
397                 /* E.g.
398                  * ep : "=?iso-2022-jp?B?GyR...?= foo"
399                  * ep : "=?ISO-8859-1?Q?Foo=FCbar?= baz"
400                  */
401                 ep += 2;
402
403                 if (ep - it->buf >= it->len || !(cp = strchr(ep, '?')))
404                         goto release_return;
405
406                 if (cp + 3 - it->buf > it->len)
407                         goto release_return;
408                 strbuf_add(&charset_q, ep, cp - ep);
409
410                 encoding = cp[1];
411                 if (!encoding || cp[2] != '?')
412                         goto release_return;
413                 ep = strstr(cp + 3, "?=");
414                 if (!ep)
415                         goto release_return;
416                 strbuf_add(&piecebuf, cp + 3, ep - cp - 3);
417                 switch (tolower(encoding)) {
418                 default:
419                         goto release_return;
420                 case 'b':
421                         dec = decode_b_segment(&piecebuf);
422                         break;
423                 case 'q':
424                         dec = decode_q_segment(&piecebuf, 1);
425                         break;
426                 }
427                 if (convert_to_utf8(mi, dec, charset_q.buf))
428                         goto release_return;
429
430                 strbuf_addbuf(&outbuf, dec);
431                 strbuf_release(dec);
432                 free(dec);
433                 in = ep + 2;
434         }
435         strbuf_addstr(&outbuf, in);
436         strbuf_reset(it);
437         strbuf_addbuf(it, &outbuf);
438         found_error = 0;
439 release_return:
440         strbuf_release(&outbuf);
441         strbuf_release(&charset_q);
442         strbuf_release(&piecebuf);
443
444         if (found_error)
445                 mi->input_error = -1;
446 }
447
448 static int check_header(struct mailinfo *mi,
449                         const struct strbuf *line,
450                         struct strbuf *hdr_data[], int overwrite)
451 {
452         int i, ret = 0, len;
453         struct strbuf sb = STRBUF_INIT;
454
455         /* search for the interesting parts */
456         for (i = 0; header[i]; i++) {
457                 int len = strlen(header[i]);
458                 if ((!hdr_data[i] || overwrite) && cmp_header(line, header[i])) {
459                         /* Unwrap inline B and Q encoding, and optionally
460                          * normalize the meta information to utf8.
461                          */
462                         strbuf_add(&sb, line->buf + len + 2, line->len - len - 2);
463                         decode_header(mi, &sb);
464                         handle_header(&hdr_data[i], &sb);
465                         ret = 1;
466                         goto check_header_out;
467                 }
468         }
469
470         /* Content stuff */
471         if (cmp_header(line, "Content-Type")) {
472                 len = strlen("Content-Type: ");
473                 strbuf_add(&sb, line->buf + len, line->len - len);
474                 decode_header(mi, &sb);
475                 strbuf_insert(&sb, 0, "Content-Type: ", len);
476                 handle_content_type(mi, &sb);
477                 ret = 1;
478                 goto check_header_out;
479         }
480         if (cmp_header(line, "Content-Transfer-Encoding")) {
481                 len = strlen("Content-Transfer-Encoding: ");
482                 strbuf_add(&sb, line->buf + len, line->len - len);
483                 decode_header(mi, &sb);
484                 handle_content_transfer_encoding(mi, &sb);
485                 ret = 1;
486                 goto check_header_out;
487         }
488         if (cmp_header(line, "Message-Id")) {
489                 len = strlen("Message-Id: ");
490                 strbuf_add(&sb, line->buf + len, line->len - len);
491                 decode_header(mi, &sb);
492                 if (mi->add_message_id)
493                         mi->message_id = strbuf_detach(&sb, NULL);
494                 ret = 1;
495                 goto check_header_out;
496         }
497
498         /* for inbody stuff */
499         if (starts_with(line->buf, ">From") && isspace(line->buf[5])) {
500                 ret = is_format_patch_separator(line->buf + 1, line->len - 1);
501                 goto check_header_out;
502         }
503         if (starts_with(line->buf, "[PATCH]") && isspace(line->buf[7])) {
504                 for (i = 0; header[i]; i++) {
505                         if (!strcmp("Subject", header[i])) {
506                                 handle_header(&hdr_data[i], line);
507                                 ret = 1;
508                                 goto check_header_out;
509                         }
510                 }
511         }
512
513 check_header_out:
514         strbuf_release(&sb);
515         return ret;
516 }
517
518 static void decode_transfer_encoding(struct mailinfo *mi, struct strbuf *line)
519 {
520         struct strbuf *ret;
521
522         switch (mi->transfer_encoding) {
523         case TE_QP:
524                 ret = decode_q_segment(line, 0);
525                 break;
526         case TE_BASE64:
527                 ret = decode_b_segment(line);
528                 break;
529         case TE_DONTCARE:
530         default:
531                 return;
532         }
533         strbuf_reset(line);
534         strbuf_addbuf(line, ret);
535         strbuf_release(ret);
536         free(ret);
537 }
538
539 static inline int patchbreak(const struct strbuf *line)
540 {
541         size_t i;
542
543         /* Beginning of a "diff -" header? */
544         if (starts_with(line->buf, "diff -"))
545                 return 1;
546
547         /* CVS "Index: " line? */
548         if (starts_with(line->buf, "Index: "))
549                 return 1;
550
551         /*
552          * "--- <filename>" starts patches without headers
553          * "---<sp>*" is a manual separator
554          */
555         if (line->len < 4)
556                 return 0;
557
558         if (starts_with(line->buf, "---")) {
559                 /* space followed by a filename? */
560                 if (line->buf[3] == ' ' && !isspace(line->buf[4]))
561                         return 1;
562                 /* Just whitespace? */
563                 for (i = 3; i < line->len; i++) {
564                         unsigned char c = line->buf[i];
565                         if (c == '\n')
566                                 return 1;
567                         if (!isspace(c))
568                                 break;
569                 }
570                 return 0;
571         }
572         return 0;
573 }
574
575 static int is_scissors_line(const struct strbuf *line)
576 {
577         size_t i, len = line->len;
578         int scissors = 0, gap = 0;
579         int first_nonblank = -1;
580         int last_nonblank = 0, visible, perforation = 0, in_perforation = 0;
581         const char *buf = line->buf;
582
583         for (i = 0; i < len; i++) {
584                 if (isspace(buf[i])) {
585                         if (in_perforation) {
586                                 perforation++;
587                                 gap++;
588                         }
589                         continue;
590                 }
591                 last_nonblank = i;
592                 if (first_nonblank < 0)
593                         first_nonblank = i;
594                 if (buf[i] == '-') {
595                         in_perforation = 1;
596                         perforation++;
597                         continue;
598                 }
599                 if (i + 1 < len &&
600                     (!memcmp(buf + i, ">8", 2) || !memcmp(buf + i, "8<", 2) ||
601                      !memcmp(buf + i, ">%", 2) || !memcmp(buf + i, "%<", 2))) {
602                         in_perforation = 1;
603                         perforation += 2;
604                         scissors += 2;
605                         i++;
606                         continue;
607                 }
608                 in_perforation = 0;
609         }
610
611         /*
612          * The mark must be at least 8 bytes long (e.g. "-- >8 --").
613          * Even though there can be arbitrary cruft on the same line
614          * (e.g. "cut here"), in order to avoid misidentification, the
615          * perforation must occupy more than a third of the visible
616          * width of the line, and dashes and scissors must occupy more
617          * than half of the perforation.
618          */
619
620         visible = last_nonblank - first_nonblank + 1;
621         return (scissors && 8 <= visible &&
622                 visible < perforation * 3 &&
623                 gap * 2 < perforation);
624 }
625
626 static int handle_commit_msg(struct mailinfo *mi, struct strbuf *line)
627 {
628         assert(!mi->filter_stage);
629
630         if (mi->header_stage) {
631                 if (!line->len || (line->len == 1 && line->buf[0] == '\n'))
632                         return 0;
633         }
634
635         if (mi->use_inbody_headers && mi->header_stage) {
636                 mi->header_stage = check_header(mi, line, mi->s_hdr_data, 0);
637                 if (mi->header_stage)
638                         return 0;
639         } else
640                 /* Only trim the first (blank) line of the commit message
641                  * when ignoring in-body headers.
642                  */
643                 mi->header_stage = 0;
644
645         /* normalize the log message to UTF-8. */
646         if (convert_to_utf8(mi, line, mi->charset.buf))
647                 return 0; /* mi->input_error already set */
648
649         if (mi->use_scissors && is_scissors_line(line)) {
650                 int i;
651
652                 strbuf_setlen(&mi->log_message, 0);
653                 mi->header_stage = 1;
654
655                 /*
656                  * We may have already read "secondary headers"; purge
657                  * them to give ourselves a clean restart.
658                  */
659                 for (i = 0; header[i]; i++) {
660                         if (mi->s_hdr_data[i])
661                                 strbuf_release(mi->s_hdr_data[i]);
662                         mi->s_hdr_data[i] = NULL;
663                 }
664                 return 0;
665         }
666
667         if (patchbreak(line)) {
668                 if (mi->message_id)
669                         strbuf_addf(&mi->log_message,
670                                     "Message-Id: %s\n", mi->message_id);
671                 return 1;
672         }
673
674         strbuf_addbuf(&mi->log_message, line);
675         return 0;
676 }
677
678 static void handle_patch(struct mailinfo *mi, const struct strbuf *line)
679 {
680         fwrite(line->buf, 1, line->len, mi->patchfile);
681         mi->patch_lines++;
682 }
683
684 static void handle_filter(struct mailinfo *mi, struct strbuf *line)
685 {
686         switch (mi->filter_stage) {
687         case 0:
688                 if (!handle_commit_msg(mi, line))
689                         break;
690                 mi->filter_stage++;
691         case 1:
692                 handle_patch(mi, line);
693                 break;
694         }
695 }
696
697 static int is_rfc2822_header(const struct strbuf *line)
698 {
699         /*
700          * The section that defines the loosest possible
701          * field name is "3.6.8 Optional fields".
702          *
703          * optional-field = field-name ":" unstructured CRLF
704          * field-name = 1*ftext
705          * ftext = %d33-57 / %59-126
706          */
707         int ch;
708         char *cp = line->buf;
709
710         /* Count mbox From headers as headers */
711         if (starts_with(cp, "From ") || starts_with(cp, ">From "))
712                 return 1;
713
714         while ((ch = *cp++)) {
715                 if (ch == ':')
716                         return 1;
717                 if ((33 <= ch && ch <= 57) ||
718                     (59 <= ch && ch <= 126))
719                         continue;
720                 break;
721         }
722         return 0;
723 }
724
725 static int read_one_header_line(struct strbuf *line, FILE *in)
726 {
727         struct strbuf continuation = STRBUF_INIT;
728
729         /* Get the first part of the line. */
730         if (strbuf_getline_lf(line, in))
731                 return 0;
732
733         /*
734          * Is it an empty line or not a valid rfc2822 header?
735          * If so, stop here, and return false ("not a header")
736          */
737         strbuf_rtrim(line);
738         if (!line->len || !is_rfc2822_header(line)) {
739                 /* Re-add the newline */
740                 strbuf_addch(line, '\n');
741                 return 0;
742         }
743
744         /*
745          * Now we need to eat all the continuation lines..
746          * Yuck, 2822 header "folding"
747          */
748         for (;;) {
749                 int peek;
750
751                 peek = fgetc(in); ungetc(peek, in);
752                 if (peek != ' ' && peek != '\t')
753                         break;
754                 if (strbuf_getline_lf(&continuation, in))
755                         break;
756                 continuation.buf[0] = ' ';
757                 strbuf_rtrim(&continuation);
758                 strbuf_addbuf(line, &continuation);
759         }
760         strbuf_release(&continuation);
761
762         return 1;
763 }
764
765 static int find_boundary(struct mailinfo *mi, struct strbuf *line)
766 {
767         while (!strbuf_getline_lf(line, mi->input)) {
768                 if (*(mi->content_top) && is_multipart_boundary(mi, line))
769                         return 1;
770         }
771         return 0;
772 }
773
774 static int handle_boundary(struct mailinfo *mi, struct strbuf *line)
775 {
776         struct strbuf newline = STRBUF_INIT;
777
778         strbuf_addch(&newline, '\n');
779 again:
780         if (line->len >= (*(mi->content_top))->len + 2 &&
781             !memcmp(line->buf + (*(mi->content_top))->len, "--", 2)) {
782                 /* we hit an end boundary */
783                 /* pop the current boundary off the stack */
784                 strbuf_release(*(mi->content_top));
785                 free(*(mi->content_top));
786                 *(mi->content_top) = NULL;
787
788                 /* technically won't happen as is_multipart_boundary()
789                    will fail first.  But just in case..
790                  */
791                 if (--mi->content_top < mi->content) {
792                         error("Detected mismatched boundaries, can't recover");
793                         mi->input_error = -1;
794                         mi->content_top = mi->content;
795                         return 0;
796                 }
797                 handle_filter(mi, &newline);
798                 strbuf_release(&newline);
799                 if (mi->input_error)
800                         return 0;
801
802                 /* skip to the next boundary */
803                 if (!find_boundary(mi, line))
804                         return 0;
805                 goto again;
806         }
807
808         /* set some defaults */
809         mi->transfer_encoding = TE_DONTCARE;
810         strbuf_reset(&mi->charset);
811
812         /* slurp in this section's info */
813         while (read_one_header_line(line, mi->input))
814                 check_header(mi, line, mi->p_hdr_data, 0);
815
816         strbuf_release(&newline);
817         /* replenish line */
818         if (strbuf_getline_lf(line, mi->input))
819                 return 0;
820         strbuf_addch(line, '\n');
821         return 1;
822 }
823
824 static void handle_body(struct mailinfo *mi, struct strbuf *line)
825 {
826         struct strbuf prev = STRBUF_INIT;
827
828         /* Skip up to the first boundary */
829         if (*(mi->content_top)) {
830                 if (!find_boundary(mi, line))
831                         goto handle_body_out;
832         }
833
834         do {
835                 /* process any boundary lines */
836                 if (*(mi->content_top) && is_multipart_boundary(mi, line)) {
837                         /* flush any leftover */
838                         if (prev.len) {
839                                 handle_filter(mi, &prev);
840                                 strbuf_reset(&prev);
841                         }
842                         if (!handle_boundary(mi, line))
843                                 goto handle_body_out;
844                 }
845
846                 /* Unwrap transfer encoding */
847                 decode_transfer_encoding(mi, line);
848
849                 switch (mi->transfer_encoding) {
850                 case TE_BASE64:
851                 case TE_QP:
852                 {
853                         struct strbuf **lines, **it, *sb;
854
855                         /* Prepend any previous partial lines */
856                         strbuf_insert(line, 0, prev.buf, prev.len);
857                         strbuf_reset(&prev);
858
859                         /*
860                          * This is a decoded line that may contain
861                          * multiple new lines.  Pass only one chunk
862                          * at a time to handle_filter()
863                          */
864                         lines = strbuf_split(line, '\n');
865                         for (it = lines; (sb = *it); it++) {
866                                 if (*(it + 1) == NULL) /* The last line */
867                                         if (sb->buf[sb->len - 1] != '\n') {
868                                                 /* Partial line, save it for later. */
869                                                 strbuf_addbuf(&prev, sb);
870                                                 break;
871                                         }
872                                 handle_filter(mi, sb);
873                         }
874                         /*
875                          * The partial chunk is saved in "prev" and will be
876                          * appended by the next iteration of read_line_with_nul().
877                          */
878                         strbuf_list_free(lines);
879                         break;
880                 }
881                 default:
882                         handle_filter(mi, line);
883                 }
884
885                 if (mi->input_error)
886                         break;
887         } while (!strbuf_getwholeline(line, mi->input, '\n'));
888
889 handle_body_out:
890         strbuf_release(&prev);
891 }
892
893 static void output_header_lines(FILE *fout, const char *hdr, const struct strbuf *data)
894 {
895         const char *sp = data->buf;
896         while (1) {
897                 char *ep = strchr(sp, '\n');
898                 int len;
899                 if (!ep)
900                         len = strlen(sp);
901                 else
902                         len = ep - sp;
903                 fprintf(fout, "%s: %.*s\n", hdr, len, sp);
904                 if (!ep)
905                         break;
906                 sp = ep + 1;
907         }
908 }
909
910 static void handle_info(struct mailinfo *mi)
911 {
912         struct strbuf *hdr;
913         int i;
914
915         for (i = 0; header[i]; i++) {
916                 /* only print inbody headers if we output a patch file */
917                 if (mi->patch_lines && mi->s_hdr_data[i])
918                         hdr = mi->s_hdr_data[i];
919                 else if (mi->p_hdr_data[i])
920                         hdr = mi->p_hdr_data[i];
921                 else
922                         continue;
923
924                 if (!strcmp(header[i], "Subject")) {
925                         if (!mi->keep_subject) {
926                                 cleanup_subject(mi, hdr);
927                                 cleanup_space(hdr);
928                         }
929                         output_header_lines(mi->output, "Subject", hdr);
930                 } else if (!strcmp(header[i], "From")) {
931                         cleanup_space(hdr);
932                         handle_from(mi, hdr);
933                         fprintf(mi->output, "Author: %s\n", mi->name.buf);
934                         fprintf(mi->output, "Email: %s\n", mi->email.buf);
935                 } else {
936                         cleanup_space(hdr);
937                         fprintf(mi->output, "%s: %s\n", header[i], hdr->buf);
938                 }
939         }
940         fprintf(mi->output, "\n");
941 }
942
943 int mailinfo(struct mailinfo *mi, const char *msg, const char *patch)
944 {
945         FILE *cmitmsg;
946         int peek;
947         struct strbuf line = STRBUF_INIT;
948
949         cmitmsg = fopen(msg, "w");
950         if (!cmitmsg) {
951                 perror(msg);
952                 return -1;
953         }
954         mi->patchfile = fopen(patch, "w");
955         if (!mi->patchfile) {
956                 perror(patch);
957                 fclose(cmitmsg);
958                 return -1;
959         }
960
961         mi->p_hdr_data = xcalloc(MAX_HDR_PARSED, sizeof(*(mi->p_hdr_data)));
962         mi->s_hdr_data = xcalloc(MAX_HDR_PARSED, sizeof(*(mi->s_hdr_data)));
963
964         do {
965                 peek = fgetc(mi->input);
966         } while (isspace(peek));
967         ungetc(peek, mi->input);
968
969         /* process the email header */
970         while (read_one_header_line(&line, mi->input))
971                 check_header(mi, &line, mi->p_hdr_data, 1);
972
973         handle_body(mi, &line);
974         fwrite(mi->log_message.buf, 1, mi->log_message.len, cmitmsg);
975         fclose(cmitmsg);
976         fclose(mi->patchfile);
977
978         handle_info(mi);
979         strbuf_release(&line);
980         return mi->input_error;
981 }
982
983 static int git_mailinfo_config(const char *var, const char *value, void *mi_)
984 {
985         struct mailinfo *mi = mi_;
986
987         if (!starts_with(var, "mailinfo."))
988                 return git_default_config(var, value, NULL);
989         if (!strcmp(var, "mailinfo.scissors")) {
990                 mi->use_scissors = git_config_bool(var, value);
991                 return 0;
992         }
993         /* perhaps others here */
994         return 0;
995 }
996
997 void setup_mailinfo(struct mailinfo *mi)
998 {
999         memset(mi, 0, sizeof(*mi));
1000         strbuf_init(&mi->name, 0);
1001         strbuf_init(&mi->email, 0);
1002         strbuf_init(&mi->charset, 0);
1003         strbuf_init(&mi->log_message, 0);
1004         mi->header_stage = 1;
1005         mi->use_inbody_headers = 1;
1006         mi->content_top = mi->content;
1007         git_config(git_mailinfo_config, mi);
1008 }
1009
1010 void clear_mailinfo(struct mailinfo *mi)
1011 {
1012         int i;
1013
1014         strbuf_release(&mi->name);
1015         strbuf_release(&mi->email);
1016         strbuf_release(&mi->charset);
1017         free(mi->message_id);
1018
1019         for (i = 0; mi->p_hdr_data[i]; i++)
1020                 strbuf_release(mi->p_hdr_data[i]);
1021         free(mi->p_hdr_data);
1022         for (i = 0; mi->s_hdr_data[i]; i++)
1023                 strbuf_release(mi->s_hdr_data[i]);
1024         free(mi->s_hdr_data);
1025
1026         while (mi->content < mi->content_top) {
1027                 free(*(mi->content_top));
1028                 mi->content_top--;
1029         }
1030
1031         strbuf_release(&mi->log_message);
1032 }