revision: --topo-order and --unpacked
[git.git] / mailinfo.c
1 /*
2  * Another stupid program, this one parsing the headers of an
3  * email to figure out authorship and subject
4  */
5 #define _GNU_SOURCE
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <ctype.h>
10 #ifndef NO_ICONV
11 #include <iconv.h>
12 #endif
13 #include "git-compat-util.h"
14 #include "cache.h"
15
16 static FILE *cmitmsg, *patchfile;
17
18 static int keep_subject = 0;
19 static char *metainfo_charset = NULL;
20 static char line[1000];
21 static char date[1000];
22 static char name[1000];
23 static char email[1000];
24 static char subject[1000];
25
26 static enum  {
27         TE_DONTCARE, TE_QP, TE_BASE64,
28 } transfer_encoding;
29 static char charset[256];
30
31 static char multipart_boundary[1000];
32 static int multipart_boundary_len;
33 static int patch_lines = 0;
34
35 static char *sanity_check(char *name, char *email)
36 {
37         int len = strlen(name);
38         if (len < 3 || len > 60)
39                 return email;
40         if (strchr(name, '@') || strchr(name, '<') || strchr(name, '>'))
41                 return email;
42         return name;
43 }
44
45 static int bogus_from(char *line)
46 {
47         /* John Doe <johndoe> */
48         char *bra, *ket, *dst, *cp;
49
50         /* This is fallback, so do not bother if we already have an
51          * e-mail address.
52          */ 
53         if (*email)
54                 return 0;
55
56         bra = strchr(line, '<');
57         if (!bra)
58                 return 0;
59         ket = strchr(bra, '>');
60         if (!ket)
61                 return 0;
62
63         for (dst = email, cp = bra+1; cp < ket; )
64                 *dst++ = *cp++;
65         *dst = 0;
66         for (cp = line; isspace(*cp); cp++)
67                 ;
68         for (bra--; isspace(*bra); bra--)
69                 *bra = 0;
70         cp = sanity_check(cp, email);
71         strcpy(name, cp);
72         return 1;
73 }
74
75 static int handle_from(char *line)
76 {
77         char *at = strchr(line, '@');
78         char *dst;
79
80         if (!at)
81                 return bogus_from(line);
82
83         /*
84          * If we already have one email, don't take any confusing lines
85          */
86         if (*email && strchr(at+1, '@'))
87                 return 0;
88
89         /* Pick up the string around '@', possibly delimited with <>
90          * pair; that is the email part.  White them out while copying.
91          */
92         while (at > line) {
93                 char c = at[-1];
94                 if (isspace(c))
95                         break;
96                 if (c == '<') {
97                         at[-1] = ' ';
98                         break;
99                 }
100                 at--;
101         }
102         dst = email;
103         for (;;) {
104                 unsigned char c = *at;
105                 if (!c || c == '>' || isspace(c)) {
106                         if (c == '>')
107                                 *at = ' ';
108                         break;
109                 }
110                 *at++ = ' ';
111                 *dst++ = c;
112         }
113         *dst++ = 0;
114
115         /* The remainder is name.  It could be "John Doe <john.doe@xz>"
116          * or "john.doe@xz (John Doe)", but we have whited out the
117          * email part, so trim from both ends, possibly removing
118          * the () pair at the end.
119          */
120         at = line + strlen(line);
121         while (at > line) {
122                 unsigned char c = *--at;
123                 if (!isspace(c)) {
124                         at[(c == ')') ? 0 : 1] = 0;
125                         break;
126                 }
127         }
128
129         at = line;
130         for (;;) {
131                 unsigned char c = *at;
132                 if (!c || !isspace(c)) {
133                         if (c == '(')
134                                 at++;
135                         break;
136                 }
137                 at++;
138         }
139         at = sanity_check(at, email);
140         strcpy(name, at);
141         return 1;
142 }
143
144 static int handle_date(char *line)
145 {
146         strcpy(date, line);
147         return 0;
148 }
149
150 static int handle_subject(char *line)
151 {
152         strcpy(subject, line);
153         return 0;
154 }
155
156 /* NOTE NOTE NOTE.  We do not claim we do full MIME.  We just attempt
157  * to have enough heuristics to grok MIME encoded patches often found
158  * on our mailing lists.  For example, we do not even treat header lines
159  * case insensitively.
160  */
161
162 static int slurp_attr(const char *line, const char *name, char *attr)
163 {
164         char *ends, *ap = strcasestr(line, name);
165         size_t sz;
166
167         if (!ap) {
168                 *attr = 0;
169                 return 0;
170         }
171         ap += strlen(name);
172         if (*ap == '"') {
173                 ap++;
174                 ends = "\"";
175         }
176         else
177                 ends = "; \t";
178         sz = strcspn(ap, ends);
179         memcpy(attr, ap, sz);
180         attr[sz] = 0;
181         return 1;
182 }
183
184 static int handle_subcontent_type(char *line)
185 {
186         /* We do not want to mess with boundary.  Note that we do not
187          * handle nested multipart.
188          */
189         if (strcasestr(line, "boundary=")) {
190                 fprintf(stderr, "Not handling nested multipart message.\n");
191                 exit(1);
192         }
193         slurp_attr(line, "charset=", charset);
194         if (*charset) {
195                 int i, c;
196                 for (i = 0; (c = charset[i]) != 0; i++)
197                         charset[i] = tolower(c);
198         }
199         return 0;
200 }
201
202 static int handle_content_type(char *line)
203 {
204         *multipart_boundary = 0;
205         if (slurp_attr(line, "boundary=", multipart_boundary + 2)) {
206                 memcpy(multipart_boundary, "--", 2);
207                 multipart_boundary_len = strlen(multipart_boundary);
208         }
209         slurp_attr(line, "charset=", charset);
210         return 0;
211 }
212
213 static int handle_content_transfer_encoding(char *line)
214 {
215         if (strcasestr(line, "base64"))
216                 transfer_encoding = TE_BASE64;
217         else if (strcasestr(line, "quoted-printable"))
218                 transfer_encoding = TE_QP;
219         else
220                 transfer_encoding = TE_DONTCARE;
221         return 0;
222 }
223
224 static int is_multipart_boundary(const char *line)
225 {
226         return (!memcmp(line, multipart_boundary, multipart_boundary_len));
227 }
228
229 static int eatspace(char *line)
230 {
231         int len = strlen(line);
232         while (len > 0 && isspace(line[len-1]))
233                 line[--len] = 0;
234         return len;
235 }
236
237 #define SEEN_FROM 01
238 #define SEEN_DATE 02
239 #define SEEN_SUBJECT 04
240
241 /* First lines of body can have From:, Date:, and Subject: */
242 static int handle_inbody_header(int *seen, char *line)
243 {
244         if (!memcmp("From:", line, 5) && isspace(line[5])) {
245                 if (!(*seen & SEEN_FROM) && handle_from(line+6)) {
246                         *seen |= SEEN_FROM;
247                         return 1;
248                 }
249         }
250         if (!memcmp("Date:", line, 5) && isspace(line[5])) {
251                 if (!(*seen & SEEN_DATE)) {
252                         handle_date(line+6);
253                         *seen |= SEEN_DATE;
254                         return 1;
255                 }
256         }
257         if (!memcmp("Subject:", line, 8) && isspace(line[8])) {
258                 if (!(*seen & SEEN_SUBJECT)) {
259                         handle_subject(line+9);
260                         *seen |= SEEN_SUBJECT;
261                         return 1;
262                 }
263         }
264         if (!memcmp("[PATCH]", line, 7) && isspace(line[7])) {
265                 if (!(*seen & SEEN_SUBJECT)) {
266                         handle_subject(line);
267                         *seen |= SEEN_SUBJECT;
268                         return 1;
269                 }
270         }
271         return 0;
272 }
273
274 static char *cleanup_subject(char *subject)
275 {
276         if (keep_subject)
277                 return subject;
278         for (;;) {
279                 char *p;
280                 int len, remove;
281                 switch (*subject) {
282                 case 'r': case 'R':
283                         if (!memcmp("e:", subject+1, 2)) {
284                                 subject +=3;
285                                 continue;
286                         }
287                         break;
288                 case ' ': case '\t': case ':':
289                         subject++;
290                         continue;
291
292                 case '[':
293                         p = strchr(subject, ']');
294                         if (!p) {
295                                 subject++;
296                                 continue;
297                         }
298                         len = strlen(p);
299                         remove = p - subject;
300                         if (remove <= len *2) {
301                                 subject = p+1;
302                                 continue;
303                         }       
304                         break;
305                 }
306                 return subject;
307         }
308 }                       
309
310 static void cleanup_space(char *buf)
311 {
312         unsigned char c;
313         while ((c = *buf) != 0) {
314                 buf++;
315                 if (isspace(c)) {
316                         buf[-1] = ' ';
317                         c = *buf;
318                         while (isspace(c)) {
319                                 int len = strlen(buf);
320                                 memmove(buf, buf+1, len);
321                                 c = *buf;
322                         }
323                 }
324         }
325 }
326
327 typedef int (*header_fn_t)(char *);
328 struct header_def {
329         const char *name;
330         header_fn_t func;
331         int namelen;
332 };
333
334 static void check_header(char *line, int len, struct header_def *header)
335 {
336         int i;
337
338         if (header[0].namelen <= 0) {
339                 for (i = 0; header[i].name; i++)
340                         header[i].namelen = strlen(header[i].name);
341         }
342         for (i = 0; header[i].name; i++) {
343                 int len = header[i].namelen;
344                 if (!strncasecmp(line, header[i].name, len) &&
345                     line[len] == ':' && isspace(line[len + 1])) {
346                         header[i].func(line + len + 2);
347                         break;
348                 }
349         }
350 }
351
352 static void check_subheader_line(char *line, int len)
353 {
354         static struct header_def header[] = {
355                 { "Content-Type", handle_subcontent_type },
356                 { "Content-Transfer-Encoding",
357                   handle_content_transfer_encoding },
358                 { NULL },
359         };
360         check_header(line, len, header);
361 }
362 static void check_header_line(char *line, int len)
363 {
364         static struct header_def header[] = {
365                 { "From", handle_from },
366                 { "Date", handle_date },
367                 { "Subject", handle_subject },
368                 { "Content-Type", handle_content_type },
369                 { "Content-Transfer-Encoding",
370                   handle_content_transfer_encoding },
371                 { NULL },
372         };
373         check_header(line, len, header);
374 }
375
376 static int read_one_header_line(char *line, int sz, FILE *in)
377 {
378         int ofs = 0;
379         while (ofs < sz) {
380                 int peek, len;
381                 if (fgets(line + ofs, sz - ofs, in) == NULL)
382                         return ofs;
383                 len = eatspace(line + ofs);
384                 if (len == 0)
385                         return ofs;
386                 peek = fgetc(in); ungetc(peek, in);
387                 if (peek == ' ' || peek == '\t') {
388                         /* Yuck, 2822 header "folding" */
389                         ofs += len;
390                         continue;
391                 }
392                 return ofs + len;
393         }
394         return ofs;
395 }
396
397 static unsigned hexval(int c)
398 {
399         if (c >= '0' && c <= '9')
400                 return c - '0';
401         if (c >= 'a' && c <= 'f')
402                 return c - 'a' + 10;
403         if (c >= 'A' && c <= 'F')
404                 return c - 'A' + 10;
405         return ~0;
406 }
407
408 static int decode_q_segment(char *in, char *ot, char *ep)
409 {
410         int c;
411         while ((c = *in++) != 0 && (in <= ep)) {
412                 if (c == '=') {
413                         int d = *in++;
414                         if (d == '\n' || !d)
415                                 break; /* drop trailing newline */
416                         *ot++ = ((hexval(d) << 4) | hexval(*in++));
417                 }
418                 else
419                         *ot++ = c;
420         }
421         *ot = 0;
422         return 0;
423 }
424
425 static int decode_b_segment(char *in, char *ot, char *ep)
426 {
427         /* Decode in..ep, possibly in-place to ot */
428         int c, pos = 0, acc = 0;
429
430         while ((c = *in++) != 0 && (in <= ep)) {
431                 if (c == '+')
432                         c = 62;
433                 else if (c == '/')
434                         c = 63;
435                 else if ('A' <= c && c <= 'Z')
436                         c -= 'A';
437                 else if ('a' <= c && c <= 'z')
438                         c -= 'a' - 26;
439                 else if ('0' <= c && c <= '9')
440                         c -= '0' - 52;
441                 else if (c == '=') {
442                         /* padding is almost like (c == 0), except we do
443                          * not output NUL resulting only from it;
444                          * for now we just trust the data.
445                          */
446                         c = 0;
447                 }
448                 else
449                         continue; /* garbage */
450                 switch (pos++) {
451                 case 0:
452                         acc = (c << 2);
453                         break;
454                 case 1:
455                         *ot++ = (acc | (c >> 4));
456                         acc = (c & 15) << 4;
457                         break;
458                 case 2:
459                         *ot++ = (acc | (c >> 2));
460                         acc = (c & 3) << 6;
461                         break;
462                 case 3:
463                         *ot++ = (acc | c);
464                         acc = pos = 0;
465                         break;
466                 }
467         }
468         *ot = 0;
469         return 0;
470 }
471
472 static void convert_to_utf8(char *line, char *charset)
473 {
474 #ifndef NO_ICONV
475         char *in, *out;
476         size_t insize, outsize, nrc;
477         char outbuf[4096]; /* cheat */
478         static char latin_one[] = "latin1";
479         char *input_charset = *charset ? charset : latin_one;
480         iconv_t conv = iconv_open(metainfo_charset, input_charset);
481
482         if (conv == (iconv_t) -1) {
483                 static int warned_latin1_once = 0;
484                 if (input_charset != latin_one) {
485                         fprintf(stderr, "cannot convert from %s to %s\n",
486                                 input_charset, metainfo_charset);
487                         *charset = 0;
488                 }
489                 else if (!warned_latin1_once) {
490                         warned_latin1_once = 1;
491                         fprintf(stderr, "tried to convert from %s to %s, "
492                                 "but your iconv does not work with it.\n",
493                                 input_charset, metainfo_charset);
494                 }
495                 return;
496         }
497         in = line;
498         insize = strlen(in);
499         out = outbuf;
500         outsize = sizeof(outbuf);
501         nrc = iconv(conv, &in, &insize, &out, &outsize);
502         iconv_close(conv);
503         if (nrc == (size_t) -1)
504                 return;
505         *out = 0;
506         strcpy(line, outbuf);
507 #endif
508 }
509
510 static void decode_header_bq(char *it)
511 {
512         char *in, *out, *ep, *cp, *sp;
513         char outbuf[1000];
514
515         in = it;
516         out = outbuf;
517         while ((ep = strstr(in, "=?")) != NULL) {
518                 int sz, encoding;
519                 char charset_q[256], piecebuf[256];
520                 if (in != ep) {
521                         sz = ep - in;
522                         memcpy(out, in, sz);
523                         out += sz;
524                         in += sz;
525                 }
526                 /* E.g.
527                  * ep : "=?iso-2022-jp?B?GyR...?= foo"
528                  * ep : "=?ISO-8859-1?Q?Foo=FCbar?= baz"
529                  */
530                 ep += 2;
531                 cp = strchr(ep, '?');
532                 if (!cp)
533                         return; /* no munging */
534                 for (sp = ep; sp < cp; sp++)
535                         charset_q[sp - ep] = tolower(*sp);
536                 charset_q[cp - ep] = 0;
537                 encoding = cp[1];
538                 if (!encoding || cp[2] != '?')
539                         return; /* no munging */
540                 ep = strstr(cp + 3, "?=");
541                 if (!ep)
542                         return; /* no munging */
543                 switch (tolower(encoding)) {
544                 default:
545                         return; /* no munging */
546                 case 'b':
547                         sz = decode_b_segment(cp + 3, piecebuf, ep);
548                         break;
549                 case 'q':
550                         sz = decode_q_segment(cp + 3, piecebuf, ep);
551                         break;
552                 }
553                 if (sz < 0)
554                         return;
555                 if (metainfo_charset)
556                         convert_to_utf8(piecebuf, charset_q);
557                 strcpy(out, piecebuf);
558                 out += strlen(out);
559                 in = ep + 2;
560         }
561         strcpy(out, in);
562         strcpy(it, outbuf);
563 }
564
565 static void decode_transfer_encoding(char *line)
566 {
567         char *ep;
568
569         switch (transfer_encoding) {
570         case TE_QP:
571                 ep = line + strlen(line);
572                 decode_q_segment(line, line, ep);
573                 break;
574         case TE_BASE64:
575                 ep = line + strlen(line);
576                 decode_b_segment(line, line, ep);
577                 break;
578         case TE_DONTCARE:
579                 break;
580         }
581 }
582
583 static void handle_info(void)
584 {
585         char *sub;
586         static int done_info = 0;
587
588         if (done_info)
589                 return;
590
591         done_info = 1;
592         sub = cleanup_subject(subject);
593         cleanup_space(name);
594         cleanup_space(date);
595         cleanup_space(email);
596         cleanup_space(sub);
597
598         /* Unwrap inline B and Q encoding, and optionally
599          * normalize the meta information to utf8.
600          */
601         decode_header_bq(name);
602         decode_header_bq(date);
603         decode_header_bq(email);
604         decode_header_bq(sub);
605         printf("Author: %s\nEmail: %s\nSubject: %s\nDate: %s\n\n",
606                name, email, sub, date);
607 }
608
609 /* We are inside message body and have read line[] already.
610  * Spit out the commit log.
611  */
612 static int handle_commit_msg(void)
613 {
614         if (!cmitmsg)
615                 return 0;
616         do {
617                 if (!memcmp("diff -", line, 6) ||
618                     !memcmp("---", line, 3) ||
619                     !memcmp("Index: ", line, 7))
620                         break;
621                 if ((multipart_boundary[0] && is_multipart_boundary(line))) {
622                         /* We come here when the first part had only
623                          * the commit message without any patch.  We
624                          * pretend we have not seen this line yet, and
625                          * go back to the loop.
626                          */
627                         return 1;
628                 }
629
630                 /* Unwrap transfer encoding and optionally
631                  * normalize the log message to UTF-8.
632                  */
633                 decode_transfer_encoding(line);
634                 if (metainfo_charset)
635                         convert_to_utf8(line, charset);
636                 fputs(line, cmitmsg);
637         } while (fgets(line, sizeof(line), stdin) != NULL);
638         fclose(cmitmsg);
639         cmitmsg = NULL;
640         return 0;
641 }
642
643 /* We have done the commit message and have the first
644  * line of the patch in line[].
645  */
646 static void handle_patch(void)
647 {
648         do {
649                 if (multipart_boundary[0] && is_multipart_boundary(line))
650                         break;
651                 /* Only unwrap transfer encoding but otherwise do not
652                  * do anything.  We do *NOT* want UTF-8 conversion
653                  * here; we are dealing with the user payload.
654                  */
655                 decode_transfer_encoding(line);
656                 fputs(line, patchfile);
657                 patch_lines++;
658         } while (fgets(line, sizeof(line), stdin) != NULL);
659 }
660
661 /* multipart boundary and transfer encoding are set up for us, and we
662  * are at the end of the sub header.  do equivalent of handle_body up
663  * to the next boundary without closing patchfile --- we will expect
664  * that the first part to contain commit message and a patch, and
665  * handle other parts as pure patches.
666  */
667 static int handle_multipart_one_part(void)
668 {
669         int seen = 0;
670         int n = 0;
671         int len;
672
673         while (fgets(line, sizeof(line), stdin) != NULL) {
674         again:
675                 len = eatspace(line);
676                 n++;
677                 if (!len)
678                         continue;
679                 if (is_multipart_boundary(line))
680                         break;
681                 if (0 <= seen && handle_inbody_header(&seen, line))
682                         continue;
683                 seen = -1; /* no more inbody headers */
684                 line[len] = '\n';
685                 handle_info();
686                 if (handle_commit_msg())
687                         goto again;
688                 handle_patch();
689                 break;
690         }
691         if (n == 0)
692                 return -1;
693         return 0;
694 }
695
696 static void handle_multipart_body(void)
697 {
698         int part_num = 0;
699
700         /* Skip up to the first boundary */
701         while (fgets(line, sizeof(line), stdin) != NULL)
702                 if (is_multipart_boundary(line)) {
703                         part_num = 1;
704                         break;
705                 }
706         if (!part_num)
707                 return;
708         /* We are on boundary line.  Start slurping the subhead. */
709         while (1) {
710                 int len = read_one_header_line(line, sizeof(line), stdin);
711                 if (!len) {
712                         if (handle_multipart_one_part() < 0)
713                                 return;
714                         /* Reset per part headers */
715                         transfer_encoding = TE_DONTCARE;
716                         charset[0] = 0;
717                 }
718                 else
719                         check_subheader_line(line, len);
720         }
721         fclose(patchfile);
722         if (!patch_lines) {
723                 fprintf(stderr, "No patch found\n");
724                 exit(1);
725         }
726 }
727
728 /* Non multipart message */
729 static void handle_body(void)
730 {
731         int seen = 0;
732
733         while (fgets(line, sizeof(line), stdin) != NULL) {
734                 int len = eatspace(line);
735                 if (!len)
736                         continue;
737                 if (0 <= seen && handle_inbody_header(&seen, line))
738                         continue;
739                 seen = -1; /* no more inbody headers */
740                 line[len] = '\n';
741                 handle_info();
742                 handle_commit_msg();
743                 handle_patch();
744                 break;
745         }
746         fclose(patchfile);
747         if (!patch_lines) {
748                 fprintf(stderr, "No patch found\n");
749                 exit(1);
750         }
751 }
752
753 static const char mailinfo_usage[] =
754         "git-mailinfo [-k] [-u | --encoding=<encoding>] msg patch <mail >info";
755
756 int main(int argc, char **argv)
757 {
758         /* NEEDSWORK: might want to do the optional .git/ directory
759          * discovery
760          */
761         git_config(git_default_config);
762
763         while (1 < argc && argv[1][0] == '-') {
764                 if (!strcmp(argv[1], "-k"))
765                         keep_subject = 1;
766                 else if (!strcmp(argv[1], "-u"))
767                         metainfo_charset = git_commit_encoding;
768                 else if (!strncmp(argv[1], "--encoding=", 11))
769                         metainfo_charset = argv[1] + 11;
770                 else
771                         usage(mailinfo_usage);
772                 argc--; argv++;
773         }
774
775         if (argc != 3)
776                 usage(mailinfo_usage);
777         cmitmsg = fopen(argv[1], "w");
778         if (!cmitmsg) {
779                 perror(argv[1]);
780                 exit(1);
781         }
782         patchfile = fopen(argv[2], "w");
783         if (!patchfile) {
784                 perror(argv[2]);
785                 exit(1);
786         }
787         while (1) {
788                 int len = read_one_header_line(line, sizeof(line), stdin);
789                 if (!len) {
790                         if (multipart_boundary[0])
791                                 handle_multipart_body();
792                         else
793                                 handle_body();
794                         break;
795                 }
796                 check_header_line(line, len);
797         }
798         return 0;
799 }