Code

Windows: TMP and TEMP environment variables specify a temporary directory.
[git.git] / builtin-mailinfo.c
1 /*
2  * Another stupid program, this one parsing the headers of an
3  * email to figure out authorship and subject
4  */
5 #include "cache.h"
6 #include "builtin.h"
7 #include "utf8.h"
9 static FILE *cmitmsg, *patchfile, *fin, *fout;
11 static int keep_subject;
12 static const char *metainfo_charset;
13 static char line[1000];
14 static char name[1000];
15 static char email[1000];
17 static enum  {
18         TE_DONTCARE, TE_QP, TE_BASE64,
19 } transfer_encoding;
20 static enum  {
21         TYPE_TEXT, TYPE_OTHER,
22 } message_type;
24 static char charset[256];
25 static int patch_lines;
26 static char **p_hdr_data, **s_hdr_data;
28 #define MAX_HDR_PARSED 10
29 #define MAX_BOUNDARIES 5
31 static char *sanity_check(char *name, char *email)
32 {
33         int len = strlen(name);
34         if (len < 3 || len > 60)
35                 return email;
36         if (strchr(name, '@') || strchr(name, '<') || strchr(name, '>'))
37                 return email;
38         return name;
39 }
41 static int bogus_from(char *line)
42 {
43         /* John Doe <johndoe> */
44         char *bra, *ket, *dst, *cp;
46         /* This is fallback, so do not bother if we already have an
47          * e-mail address.
48          */
49         if (*email)
50                 return 0;
52         bra = strchr(line, '<');
53         if (!bra)
54                 return 0;
55         ket = strchr(bra, '>');
56         if (!ket)
57                 return 0;
59         for (dst = email, cp = bra+1; cp < ket; )
60                 *dst++ = *cp++;
61         *dst = 0;
62         for (cp = line; isspace(*cp); cp++)
63                 ;
64         for (bra--; isspace(*bra); bra--)
65                 *bra = 0;
66         cp = sanity_check(cp, email);
67         strcpy(name, cp);
68         return 1;
69 }
71 static int handle_from(char *in_line)
72 {
73         char line[1000];
74         char *at;
75         char *dst;
77         strcpy(line, in_line);
78         at = strchr(line, '@');
79         if (!at)
80                 return bogus_from(line);
82         /*
83          * If we already have one email, don't take any confusing lines
84          */
85         if (*email && strchr(at+1, '@'))
86                 return 0;
88         /* Pick up the string around '@', possibly delimited with <>
89          * pair; that is the email part.  White them out while copying.
90          */
91         while (at > line) {
92                 char c = at[-1];
93                 if (isspace(c))
94                         break;
95                 if (c == '<') {
96                         at[-1] = ' ';
97                         break;
98                 }
99                 at--;
100         }
101         dst = email;
102         for (;;) {
103                 unsigned char c = *at;
104                 if (!c || c == '>' || isspace(c)) {
105                         if (c == '>')
106                                 *at = ' ';
107                         break;
108                 }
109                 *at++ = ' ';
110                 *dst++ = c;
111         }
112         *dst++ = 0;
114         /* The remainder is name.  It could be "John Doe <john.doe@xz>"
115          * or "john.doe@xz (John Doe)", but we have whited out the
116          * email part, so trim from both ends, possibly removing
117          * the () pair at the end.
118          */
119         at = line + strlen(line);
120         while (at > line) {
121                 unsigned char c = *--at;
122                 if (!isspace(c)) {
123                         at[(c == ')') ? 0 : 1] = 0;
124                         break;
125                 }
126         }
128         at = line;
129         for (;;) {
130                 unsigned char c = *at;
131                 if (!c || !isspace(c)) {
132                         if (c == '(')
133                                 at++;
134                         break;
135                 }
136                 at++;
137         }
138         at = sanity_check(at, email);
139         strcpy(name, at);
140         return 1;
143 static int handle_header(char *line, char *data, int ofs)
145         if (!line || !data)
146                 return 1;
148         strcpy(data, line+ofs);
150         return 0;
153 /* NOTE NOTE NOTE.  We do not claim we do full MIME.  We just attempt
154  * to have enough heuristics to grok MIME encoded patches often found
155  * on our mailing lists.  For example, we do not even treat header lines
156  * case insensitively.
157  */
159 static int slurp_attr(const char *line, const char *name, char *attr)
161         const char *ends, *ap = strcasestr(line, name);
162         size_t sz;
164         if (!ap) {
165                 *attr = 0;
166                 return 0;
167         }
168         ap += strlen(name);
169         if (*ap == '"') {
170                 ap++;
171                 ends = "\"";
172         }
173         else
174                 ends = "; \t";
175         sz = strcspn(ap, ends);
176         memcpy(attr, ap, sz);
177         attr[sz] = 0;
178         return 1;
181 struct content_type {
182         char *boundary;
183         int boundary_len;
184 };
186 static struct content_type content[MAX_BOUNDARIES];
188 static struct content_type *content_top = content;
190 static int handle_content_type(char *line)
192         char boundary[256];
194         if (strcasestr(line, "text/") == NULL)
195                  message_type = TYPE_OTHER;
196         if (slurp_attr(line, "boundary=", boundary + 2)) {
197                 memcpy(boundary, "--", 2);
198                 if (content_top++ >= &content[MAX_BOUNDARIES]) {
199                         fprintf(stderr, "Too many boundaries to handle\n");
200                         exit(1);
201                 }
202                 content_top->boundary_len = strlen(boundary);
203                 content_top->boundary = xmalloc(content_top->boundary_len+1);
204                 strcpy(content_top->boundary, boundary);
205         }
206         if (slurp_attr(line, "charset=", charset)) {
207                 int i, c;
208                 for (i = 0; (c = charset[i]) != 0; i++)
209                         charset[i] = tolower(c);
210         }
211         return 0;
214 static int handle_content_transfer_encoding(char *line)
216         if (strcasestr(line, "base64"))
217                 transfer_encoding = TE_BASE64;
218         else if (strcasestr(line, "quoted-printable"))
219                 transfer_encoding = TE_QP;
220         else
221                 transfer_encoding = TE_DONTCARE;
222         return 0;
225 static int is_multipart_boundary(const char *line)
227         return (!memcmp(line, content_top->boundary, content_top->boundary_len));
230 static int eatspace(char *line)
232         int len = strlen(line);
233         while (len > 0 && isspace(line[len-1]))
234                 line[--len] = 0;
235         return len;
238 static char *cleanup_subject(char *subject)
240         for (;;) {
241                 char *p;
242                 int len, remove;
243                 switch (*subject) {
244                 case 'r': case 'R':
245                         if (!memcmp("e:", subject+1, 2)) {
246                                 subject += 3;
247                                 continue;
248                         }
249                         break;
250                 case ' ': case '\t': case ':':
251                         subject++;
252                         continue;
254                 case '[':
255                         p = strchr(subject, ']');
256                         if (!p) {
257                                 subject++;
258                                 continue;
259                         }
260                         len = strlen(p);
261                         remove = p - subject;
262                         if (remove <= len *2) {
263                                 subject = p+1;
264                                 continue;
265                         }
266                         break;
267                 }
268                 eatspace(subject);
269                 return subject;
270         }
273 static void cleanup_space(char *buf)
275         unsigned char c;
276         while ((c = *buf) != 0) {
277                 buf++;
278                 if (isspace(c)) {
279                         buf[-1] = ' ';
280                         c = *buf;
281                         while (isspace(c)) {
282                                 int len = strlen(buf);
283                                 memmove(buf, buf+1, len);
284                                 c = *buf;
285                         }
286                 }
287         }
290 static void decode_header(char *it, unsigned itsize);
291 static const char *header[MAX_HDR_PARSED] = {
292         "From","Subject","Date",
293 };
295 static int check_header(char *line, unsigned linesize, char **hdr_data, int overwrite)
297         int i;
299         /* search for the interesting parts */
300         for (i = 0; header[i]; i++) {
301                 int len = strlen(header[i]);
302                 if ((!hdr_data[i] || overwrite) &&
303                     !strncasecmp(line, header[i], len) &&
304                     line[len] == ':' && isspace(line[len + 1])) {
305                         /* Unwrap inline B and Q encoding, and optionally
306                          * normalize the meta information to utf8.
307                          */
308                         decode_header(line + len + 2, linesize - len - 2);
309                         hdr_data[i] = xmalloc(1000 * sizeof(char));
310                         if (! handle_header(line, hdr_data[i], len + 2)) {
311                                 return 1;
312                         }
313                 }
314         }
316         /* Content stuff */
317         if (!strncasecmp(line, "Content-Type", 12) &&
318                 line[12] == ':' && isspace(line[12 + 1])) {
319                 decode_header(line + 12 + 2, linesize - 12 - 2);
320                 if (! handle_content_type(line)) {
321                         return 1;
322                 }
323         }
324         if (!strncasecmp(line, "Content-Transfer-Encoding", 25) &&
325                 line[25] == ':' && isspace(line[25 + 1])) {
326                 decode_header(line + 25 + 2, linesize - 25 - 2);
327                 if (! handle_content_transfer_encoding(line)) {
328                         return 1;
329                 }
330         }
332         /* for inbody stuff */
333         if (!memcmp(">From", line, 5) && isspace(line[5]))
334                 return 1;
335         if (!memcmp("[PATCH]", line, 7) && isspace(line[7])) {
336                 for (i = 0; header[i]; i++) {
337                         if (!memcmp("Subject: ", header[i], 9)) {
338                                 if (! handle_header(line, hdr_data[i], 0)) {
339                                         return 1;
340                                 }
341                         }
342                 }
343         }
345         /* no match */
346         return 0;
349 static int is_rfc2822_header(char *line)
351         /*
352          * The section that defines the loosest possible
353          * field name is "3.6.8 Optional fields".
354          *
355          * optional-field = field-name ":" unstructured CRLF
356          * field-name = 1*ftext
357          * ftext = %d33-57 / %59-126
358          */
359         int ch;
360         char *cp = line;
362         /* Count mbox From headers as headers */
363         if (!memcmp(line, "From ", 5) || !memcmp(line, ">From ", 6))
364                 return 1;
366         while ((ch = *cp++)) {
367                 if (ch == ':')
368                         return cp != line;
369                 if ((33 <= ch && ch <= 57) ||
370                     (59 <= ch && ch <= 126))
371                         continue;
372                 break;
373         }
374         return 0;
377 /*
378  * sz is size of 'line' buffer in bytes.  Must be reasonably
379  * long enough to hold one physical real-world e-mail line.
380  */
381 static int read_one_header_line(char *line, int sz, FILE *in)
383         int len;
385         /*
386          * We will read at most (sz-1) bytes and then potentially
387          * re-add NUL after it.  Accessing line[sz] after this is safe
388          * and we can allow len to grow up to and including sz.
389          */
390         sz--;
392         /* Get the first part of the line. */
393         if (!fgets(line, sz, in))
394                 return 0;
396         /*
397          * Is it an empty line or not a valid rfc2822 header?
398          * If so, stop here, and return false ("not a header")
399          */
400         len = eatspace(line);
401         if (!len || !is_rfc2822_header(line)) {
402                 /* Re-add the newline */
403                 line[len] = '\n';
404                 line[len + 1] = '\0';
405                 return 0;
406         }
408         /*
409          * Now we need to eat all the continuation lines..
410          * Yuck, 2822 header "folding"
411          */
412         for (;;) {
413                 int peek, addlen;
414                 static char continuation[1000];
416                 peek = fgetc(in); ungetc(peek, in);
417                 if (peek != ' ' && peek != '\t')
418                         break;
419                 if (!fgets(continuation, sizeof(continuation), in))
420                         break;
421                 addlen = eatspace(continuation);
422                 if (len < sz - 1) {
423                         if (addlen >= sz - len)
424                                 addlen = sz - len - 1;
425                         memcpy(line + len, continuation, addlen);
426                         line[len] = '\n';
427                         len += addlen;
428                 }
429         }
430         line[len] = 0;
432         return 1;
435 static int decode_q_segment(char *in, char *ot, unsigned otsize, char *ep, int rfc2047)
437         char *otbegin = ot;
438         char *otend = ot + otsize;
439         int c;
440         while ((c = *in++) != 0 && (in <= ep)) {
441                 if (ot == otend) {
442                         *--ot = '\0';
443                         return -1;
444                 }
445                 if (c == '=') {
446                         int d = *in++;
447                         if (d == '\n' || !d)
448                                 break; /* drop trailing newline */
449                         *ot++ = ((hexval(d) << 4) | hexval(*in++));
450                         continue;
451                 }
452                 if (rfc2047 && c == '_') /* rfc2047 4.2 (2) */
453                         c = 0x20;
454                 *ot++ = c;
455         }
456         *ot = 0;
457         return (ot - otbegin);
460 static int decode_b_segment(char *in, char *ot, unsigned otsize, char *ep)
462         /* Decode in..ep, possibly in-place to ot */
463         int c, pos = 0, acc = 0;
464         char *otbegin = ot;
465         char *otend = ot + otsize;
467         while ((c = *in++) != 0 && (in <= ep)) {
468                 if (ot == otend) {
469                         *--ot = '\0';
470                         return -1;
471                 }
472                 if (c == '+')
473                         c = 62;
474                 else if (c == '/')
475                         c = 63;
476                 else if ('A' <= c && c <= 'Z')
477                         c -= 'A';
478                 else if ('a' <= c && c <= 'z')
479                         c -= 'a' - 26;
480                 else if ('0' <= c && c <= '9')
481                         c -= '0' - 52;
482                 else if (c == '=') {
483                         /* padding is almost like (c == 0), except we do
484                          * not output NUL resulting only from it;
485                          * for now we just trust the data.
486                          */
487                         c = 0;
488                 }
489                 else
490                         continue; /* garbage */
491                 switch (pos++) {
492                 case 0:
493                         acc = (c << 2);
494                         break;
495                 case 1:
496                         *ot++ = (acc | (c >> 4));
497                         acc = (c & 15) << 4;
498                         break;
499                 case 2:
500                         *ot++ = (acc | (c >> 2));
501                         acc = (c & 3) << 6;
502                         break;
503                 case 3:
504                         *ot++ = (acc | c);
505                         acc = pos = 0;
506                         break;
507                 }
508         }
509         *ot = 0;
510         return (ot - otbegin);
513 /*
514  * When there is no known charset, guess.
515  *
516  * Right now we assume that if the target is UTF-8 (the default),
517  * and it already looks like UTF-8 (which includes US-ASCII as its
518  * subset, of course) then that is what it is and there is nothing
519  * to do.
520  *
521  * Otherwise, we default to assuming it is Latin1 for historical
522  * reasons.
523  */
524 static const char *guess_charset(const char *line, const char *target_charset)
526         if (is_encoding_utf8(target_charset)) {
527                 if (is_utf8(line))
528                         return NULL;
529         }
530         return "latin1";
533 static void convert_to_utf8(char *line, unsigned linesize, const char *charset)
535         char *out;
537         if (!charset || !*charset) {
538                 charset = guess_charset(line, metainfo_charset);
539                 if (!charset)
540                         return;
541         }
543         if (!strcmp(metainfo_charset, charset))
544                 return;
545         out = reencode_string(line, metainfo_charset, charset);
546         if (!out)
547                 die("cannot convert from %s to %s\n",
548                     charset, metainfo_charset);
549         strlcpy(line, out, linesize);
550         free(out);
553 static int decode_header_bq(char *it, unsigned itsize)
555         char *in, *out, *ep, *cp, *sp;
556         char outbuf[1000];
557         int rfc2047 = 0;
559         in = it;
560         out = outbuf;
561         while ((ep = strstr(in, "=?")) != NULL) {
562                 int sz, encoding;
563                 char charset_q[256], piecebuf[256];
564                 rfc2047 = 1;
566                 if (in != ep) {
567                         sz = ep - in;
568                         memcpy(out, in, sz);
569                         out += sz;
570                         in += sz;
571                 }
572                 /* E.g.
573                  * ep : "=?iso-2022-jp?B?GyR...?= foo"
574                  * ep : "=?ISO-8859-1?Q?Foo=FCbar?= baz"
575                  */
576                 ep += 2;
577                 cp = strchr(ep, '?');
578                 if (!cp)
579                         return rfc2047; /* no munging */
580                 for (sp = ep; sp < cp; sp++)
581                         charset_q[sp - ep] = tolower(*sp);
582                 charset_q[cp - ep] = 0;
583                 encoding = cp[1];
584                 if (!encoding || cp[2] != '?')
585                         return rfc2047; /* no munging */
586                 ep = strstr(cp + 3, "?=");
587                 if (!ep)
588                         return rfc2047; /* no munging */
589                 switch (tolower(encoding)) {
590                 default:
591                         return rfc2047; /* no munging */
592                 case 'b':
593                         sz = decode_b_segment(cp + 3, piecebuf, sizeof(piecebuf), ep);
594                         break;
595                 case 'q':
596                         sz = decode_q_segment(cp + 3, piecebuf, sizeof(piecebuf), ep, 1);
597                         break;
598                 }
599                 if (sz < 0)
600                         return rfc2047;
601                 if (metainfo_charset)
602                         convert_to_utf8(piecebuf, sizeof(piecebuf), charset_q);
604                 sz = strlen(piecebuf);
605                 if (outbuf + sizeof(outbuf) <= out + sz)
606                         return rfc2047; /* no munging */
607                 strcpy(out, piecebuf);
608                 out += sz;
609                 in = ep + 2;
610         }
611         strcpy(out, in);
612         strlcpy(it, outbuf, itsize);
613         return rfc2047;
616 static void decode_header(char *it, unsigned itsize)
619         if (decode_header_bq(it, itsize))
620                 return;
621         /* otherwise "it" is a straight copy of the input.
622          * This can be binary guck but there is no charset specified.
623          */
624         if (metainfo_charset)
625                 convert_to_utf8(it, itsize, "");
628 static int decode_transfer_encoding(char *line, unsigned linesize, int inputlen)
630         char *ep;
632         switch (transfer_encoding) {
633         case TE_QP:
634                 ep = line + inputlen;
635                 return decode_q_segment(line, line, linesize, ep, 0);
636         case TE_BASE64:
637                 ep = line + inputlen;
638                 return decode_b_segment(line, line, linesize, ep);
639         case TE_DONTCARE:
640         default:
641                 return inputlen;
642         }
645 static int handle_filter(char *line, unsigned linesize, int linelen);
647 static int find_boundary(void)
649         while(fgets(line, sizeof(line), fin) != NULL) {
650                 if (is_multipart_boundary(line))
651                         return 1;
652         }
653         return 0;
656 static int handle_boundary(void)
658         char newline[]="\n";
659 again:
660         if (!memcmp(line+content_top->boundary_len, "--", 2)) {
661                 /* we hit an end boundary */
662                 /* pop the current boundary off the stack */
663                 free(content_top->boundary);
665                 /* technically won't happen as is_multipart_boundary()
666                    will fail first.  But just in case..
667                  */
668                 if (content_top-- < content) {
669                         fprintf(stderr, "Detected mismatched boundaries, "
670                                         "can't recover\n");
671                         exit(1);
672                 }
673                 handle_filter(newline, sizeof(newline), strlen(newline));
675                 /* skip to the next boundary */
676                 if (!find_boundary())
677                         return 0;
678                 goto again;
679         }
681         /* set some defaults */
682         transfer_encoding = TE_DONTCARE;
683         charset[0] = 0;
684         message_type = TYPE_TEXT;
686         /* slurp in this section's info */
687         while (read_one_header_line(line, sizeof(line), fin))
688                 check_header(line, sizeof(line), p_hdr_data, 0);
690         /* eat the blank line after section info */
691         return (fgets(line, sizeof(line), fin) != NULL);
694 static inline int patchbreak(const char *line)
696         /* Beginning of a "diff -" header? */
697         if (!memcmp("diff -", line, 6))
698                 return 1;
700         /* CVS "Index: " line? */
701         if (!memcmp("Index: ", line, 7))
702                 return 1;
704         /*
705          * "--- <filename>" starts patches without headers
706          * "---<sp>*" is a manual separator
707          */
708         if (!memcmp("---", line, 3)) {
709                 line += 3;
710                 /* space followed by a filename? */
711                 if (line[0] == ' ' && !isspace(line[1]))
712                         return 1;
713                 /* Just whitespace? */
714                 for (;;) {
715                         unsigned char c = *line++;
716                         if (c == '\n')
717                                 return 1;
718                         if (!isspace(c))
719                                 break;
720                 }
721                 return 0;
722         }
723         return 0;
727 static int handle_commit_msg(char *line, unsigned linesize)
729         static int still_looking = 1;
730         char *endline = line + linesize;
732         if (!cmitmsg)
733                 return 0;
735         if (still_looking) {
736                 char *cp = line;
737                 if (isspace(*line)) {
738                         for (cp = line + 1; *cp; cp++) {
739                                 if (!isspace(*cp))
740                                         break;
741                         }
742                         if (!*cp)
743                                 return 0;
744                 }
745                 if ((still_looking = check_header(cp, endline - cp, s_hdr_data, 0)) != 0)
746                         return 0;
747         }
749         /* normalize the log message to UTF-8. */
750         if (metainfo_charset)
751                 convert_to_utf8(line, endline - line, charset);
753         if (patchbreak(line)) {
754                 fclose(cmitmsg);
755                 cmitmsg = NULL;
756                 return 1;
757         }
759         fputs(line, cmitmsg);
760         return 0;
763 static int handle_patch(char *line, int len)
765         fwrite(line, 1, len, patchfile);
766         patch_lines++;
767         return 0;
770 static int handle_filter(char *line, unsigned linesize, int linelen)
772         static int filter = 0;
774         /* filter tells us which part we left off on
775          * a non-zero return indicates we hit a filter point
776          */
777         switch (filter) {
778         case 0:
779                 if (!handle_commit_msg(line, linesize))
780                         break;
781                 filter++;
782         case 1:
783                 if (!handle_patch(line, linelen))
784                         break;
785                 filter++;
786         default:
787                 return 1;
788         }
790         return 0;
793 static void handle_body(void)
795         int rc = 0;
796         static char newline[2000];
797         static char *np = newline;
798         int len = strlen(line);
800         /* Skip up to the first boundary */
801         if (content_top->boundary) {
802                 if (!find_boundary())
803                         return;
804         }
806         do {
807                 /* process any boundary lines */
808                 if (content_top->boundary && is_multipart_boundary(line)) {
809                         /* flush any leftover */
810                         if (np != newline)
811                                 handle_filter(newline, sizeof(newline),
812                                               np - newline);
813                         if (!handle_boundary())
814                                 return;
815                 }
817                 /* Unwrap transfer encoding */
818                 len = decode_transfer_encoding(line, sizeof(line), len);
819                 if (len < 0) {
820                         error("Malformed input line");
821                         return;
822                 }
824                 switch (transfer_encoding) {
825                 case TE_BASE64:
826                 case TE_QP:
827                 {
828                         char *op = line;
830                         /* binary data most likely doesn't have newlines */
831                         if (message_type != TYPE_TEXT) {
832                                 rc = handle_filter(line, sizeof(line), len);
833                                 break;
834                         }
836                         /*
837                          * This is a decoded line that may contain
838                          * multiple new lines.  Pass only one chunk
839                          * at a time to handle_filter()
840                          */
841                         do {
842                                 while (op < line + len && *op != '\n')
843                                         *np++ = *op++;
844                                 *np = *op;
845                                 if (*np != 0) {
846                                         /* should be sitting on a new line */
847                                         *(++np) = 0;
848                                         op++;
849                                         rc = handle_filter(newline, sizeof(newline), np - newline);
850                                         np = newline;
851                                 }
852                         } while (op < line + len);
853                         /*
854                          * The partial chunk is saved in newline and will be
855                          * appended by the next iteration of read_line_with_nul().
856                          */
857                         break;
858                 }
859                 default:
860                         rc = handle_filter(line, sizeof(line), len);
861                 }
862                 if (rc)
863                         /* nothing left to filter */
864                         break;
865         } while ((len = read_line_with_nul(line, sizeof(line), fin)));
867         return;
870 static void output_header_lines(FILE *fout, const char *hdr, char *data)
872         while (1) {
873                 char *ep = strchr(data, '\n');
874                 int len;
875                 if (!ep)
876                         len = strlen(data);
877                 else
878                         len = ep - data;
879                 fprintf(fout, "%s: %.*s\n", hdr, len, data);
880                 if (!ep)
881                         break;
882                 data = ep + 1;
883         }
886 static void handle_info(void)
888         char *sub;
889         char *hdr;
890         int i;
892         for (i = 0; header[i]; i++) {
894                 /* only print inbody headers if we output a patch file */
895                 if (patch_lines && s_hdr_data[i])
896                         hdr = s_hdr_data[i];
897                 else if (p_hdr_data[i])
898                         hdr = p_hdr_data[i];
899                 else
900                         continue;
902                 if (!memcmp(header[i], "Subject", 7)) {
903                         if (keep_subject)
904                                 sub = hdr;
905                         else {
906                                 sub = cleanup_subject(hdr);
907                                 cleanup_space(sub);
908                         }
909                         output_header_lines(fout, "Subject", sub);
910                 } else if (!memcmp(header[i], "From", 4)) {
911                         handle_from(hdr);
912                         fprintf(fout, "Author: %s\n", name);
913                         fprintf(fout, "Email: %s\n", email);
914                 } else {
915                         cleanup_space(hdr);
916                         fprintf(fout, "%s: %s\n", header[i], hdr);
917                 }
918         }
919         fprintf(fout, "\n");
922 static int mailinfo(FILE *in, FILE *out, int ks, const char *encoding,
923                     const char *msg, const char *patch)
925         int peek;
926         keep_subject = ks;
927         metainfo_charset = encoding;
928         fin = in;
929         fout = out;
931         cmitmsg = fopen(msg, "w");
932         if (!cmitmsg) {
933                 perror(msg);
934                 return -1;
935         }
936         patchfile = fopen(patch, "w");
937         if (!patchfile) {
938                 perror(patch);
939                 fclose(cmitmsg);
940                 return -1;
941         }
943         p_hdr_data = xcalloc(MAX_HDR_PARSED, sizeof(char *));
944         s_hdr_data = xcalloc(MAX_HDR_PARSED, sizeof(char *));
946         do {
947                 peek = fgetc(in);
948         } while (isspace(peek));
949         ungetc(peek, in);
951         /* process the email header */
952         while (read_one_header_line(line, sizeof(line), fin))
953                 check_header(line, sizeof(line), p_hdr_data, 1);
955         handle_body();
956         handle_info();
958         return 0;
961 static const char mailinfo_usage[] =
962         "git-mailinfo [-k] [-u | --encoding=<encoding>] msg patch <mail >info";
964 int cmd_mailinfo(int argc, const char **argv, const char *prefix)
966         const char *def_charset;
968         /* NEEDSWORK: might want to do the optional .git/ directory
969          * discovery
970          */
971         git_config(git_default_config, NULL);
973         def_charset = (git_commit_encoding ? git_commit_encoding : "utf-8");
974         metainfo_charset = def_charset;
976         while (1 < argc && argv[1][0] == '-') {
977                 if (!strcmp(argv[1], "-k"))
978                         keep_subject = 1;
979                 else if (!strcmp(argv[1], "-u"))
980                         metainfo_charset = def_charset;
981                 else if (!strcmp(argv[1], "-n"))
982                         metainfo_charset = NULL;
983                 else if (!prefixcmp(argv[1], "--encoding="))
984                         metainfo_charset = argv[1] + 11;
985                 else
986                         usage(mailinfo_usage);
987                 argc--; argv++;
988         }
990         if (argc != 3)
991                 usage(mailinfo_usage);
993         return !!mailinfo(stdin, stdout, keep_subject, metainfo_charset, argv[1], argv[2]);