2 * Another stupid program, this one parsing the headers of an
3 * email to figure out authorship and subject
10 static FILE *cmitmsg
, *patchfile
, *fin
, *fout
;
12 static int keep_subject
;
13 static int keep_non_patch_brackets_in_subject
;
14 static const char *metainfo_charset
;
15 static struct strbuf line
= STRBUF_INIT
;
16 static struct strbuf name
= STRBUF_INIT
;
17 static struct strbuf email
= STRBUF_INIT
;
20 TE_DONTCARE
, TE_QP
, TE_BASE64
26 static struct strbuf charset
= STRBUF_INIT
;
27 static int patch_lines
;
28 static struct strbuf
**p_hdr_data
, **s_hdr_data
;
29 static int use_scissors
;
30 static int use_inbody_headers
= 1;
32 #define MAX_HDR_PARSED 10
33 #define MAX_BOUNDARIES 5
35 static void cleanup_space(struct strbuf
*sb
);
38 static void get_sane_name(struct strbuf
*out
, struct strbuf
*name
, struct strbuf
*email
)
40 struct strbuf
*src
= name
;
41 if (name
->len
< 3 || 60 < name
->len
|| strchr(name
->buf
, '@') ||
42 strchr(name
->buf
, '<') || strchr(name
->buf
, '>'))
47 strbuf_addbuf(out
, src
);
50 static void parse_bogus_from(const struct strbuf
*line
)
52 /* John Doe <johndoe> */
55 /* This is fallback, so do not bother if we already have an
61 bra
= strchr(line
->buf
, '<');
64 ket
= strchr(bra
, '>');
69 strbuf_add(&email
, bra
+ 1, ket
- bra
- 1);
72 strbuf_add(&name
, line
->buf
, bra
- line
->buf
);
74 get_sane_name(&name
, &name
, &email
);
77 static void handle_from(const struct strbuf
*from
)
83 strbuf_init(&f
, from
->len
);
84 strbuf_addbuf(&f
, from
);
86 at
= strchr(f
.buf
, '@');
88 parse_bogus_from(from
);
93 * If we already have one email, don't take any confusing lines
95 if (email
.len
&& strchr(at
+ 1, '@')) {
100 /* Pick up the string around '@', possibly delimited with <>
101 * pair; that is the email part.
113 el
= strcspn(at
, " \n\t\r\v\f>");
114 strbuf_reset(&email
);
115 strbuf_add(&email
, at
, el
);
116 strbuf_remove(&f
, at
- f
.buf
, el
+ (at
[el
] ? 1 : 0));
118 /* The remainder is name. It could be
120 * - "John Doe <john.doe@xz>" (a), or
121 * - "john.doe@xz (John Doe)" (b), or
122 * - "John (zzz) Doe <john.doe@xz> (Comment)" (c)
124 * but we have removed the email part, so
126 * - remove extra spaces which could stay after email (case 'c'), and
127 * - trim from both ends, possibly removing the () pair at the end
128 * (cases 'a' and 'b').
132 if (f
.buf
[0] == '(' && f
.len
&& f
.buf
[f
.len
- 1] == ')') {
133 strbuf_remove(&f
, 0, 1);
134 strbuf_setlen(&f
, f
.len
- 1);
137 get_sane_name(&name
, &f
, &email
);
141 static void handle_header(struct strbuf
**out
, const struct strbuf
*line
)
144 *out
= xmalloc(sizeof(struct strbuf
));
145 strbuf_init(*out
, line
->len
);
149 strbuf_addbuf(*out
, line
);
152 /* NOTE NOTE NOTE. We do not claim we do full MIME. We just attempt
153 * to have enough heuristics to grok MIME encoded patches often found
154 * on our mailing lists. For example, we do not even treat header lines
155 * case insensitively.
158 static int slurp_attr(const char *line
, const char *name
, struct strbuf
*attr
)
160 const char *ends
, *ap
= strcasestr(line
, name
);
164 strbuf_setlen(attr
, 0);
174 sz
= strcspn(ap
, ends
);
175 strbuf_add(attr
, ap
, sz
);
179 static struct strbuf
*content
[MAX_BOUNDARIES
];
181 static struct strbuf
**content_top
= content
;
183 static void handle_content_type(struct strbuf
*line
)
185 struct strbuf
*boundary
= xmalloc(sizeof(struct strbuf
));
186 strbuf_init(boundary
, line
->len
);
188 if (!strcasestr(line
->buf
, "text/"))
189 message_type
= TYPE_OTHER
;
190 if (slurp_attr(line
->buf
, "boundary=", boundary
)) {
191 strbuf_insert(boundary
, 0, "--", 2);
192 if (++content_top
> &content
[MAX_BOUNDARIES
]) {
193 fprintf(stderr
, "Too many boundaries to handle\n");
196 *content_top
= boundary
;
199 slurp_attr(line
->buf
, "charset=", &charset
);
202 strbuf_release(boundary
);
207 static void handle_content_transfer_encoding(const struct strbuf
*line
)
209 if (strcasestr(line
->buf
, "base64"))
210 transfer_encoding
= TE_BASE64
;
211 else if (strcasestr(line
->buf
, "quoted-printable"))
212 transfer_encoding
= TE_QP
;
214 transfer_encoding
= TE_DONTCARE
;
217 static int is_multipart_boundary(const struct strbuf
*line
)
219 return (((*content_top
)->len
<= line
->len
) &&
220 !memcmp(line
->buf
, (*content_top
)->buf
, (*content_top
)->len
));
223 static void cleanup_subject(struct strbuf
*subject
)
227 while (at
< subject
->len
) {
231 switch (subject
->buf
[at
]) {
233 if (subject
->len
<= at
+ 3)
235 if ((subject
->buf
[at
+ 1] == 'e' ||
236 subject
->buf
[at
+ 1] == 'E') &&
237 subject
->buf
[at
+ 2] == ':') {
238 strbuf_remove(subject
, at
, 3);
243 case ' ': case '\t': case ':':
244 strbuf_remove(subject
, at
, 1);
247 pos
= strchr(subject
->buf
+ at
, ']');
250 remove
= pos
- subject
->buf
+ at
+ 1;
251 if (!keep_non_patch_brackets_in_subject
||
253 memmem(subject
->buf
+ at
, remove
, "PATCH", 5)))
254 strbuf_remove(subject
, at
, remove
);
258 * If the input had a space after the ], keep
259 * it. We don't bother with finding the end of
260 * the space, since we later normalize it
263 if (isspace(subject
->buf
[at
]))
270 strbuf_trim(subject
);
273 static void cleanup_space(struct strbuf
*sb
)
276 for (pos
= 0; pos
< sb
->len
; pos
++) {
277 if (isspace(sb
->buf
[pos
])) {
279 for (cnt
= 0; isspace(sb
->buf
[pos
+ cnt
+ 1]); cnt
++);
280 strbuf_remove(sb
, pos
+ 1, cnt
);
285 static void decode_header(struct strbuf
*line
);
286 static const char *header
[MAX_HDR_PARSED
] = {
287 "From","Subject","Date",
290 static inline int cmp_header(const struct strbuf
*line
, const char *hdr
)
292 int len
= strlen(hdr
);
293 return !strncasecmp(line
->buf
, hdr
, len
) && line
->len
> len
&&
294 line
->buf
[len
] == ':' && isspace(line
->buf
[len
+ 1]);
297 static int check_header(const struct strbuf
*line
,
298 struct strbuf
*hdr_data
[], int overwrite
)
301 struct strbuf sb
= STRBUF_INIT
;
302 /* search for the interesting parts */
303 for (i
= 0; header
[i
]; i
++) {
304 int len
= strlen(header
[i
]);
305 if ((!hdr_data
[i
] || overwrite
) && cmp_header(line
, header
[i
])) {
306 /* Unwrap inline B and Q encoding, and optionally
307 * normalize the meta information to utf8.
309 strbuf_add(&sb
, line
->buf
+ len
+ 2, line
->len
- len
- 2);
311 handle_header(&hdr_data
[i
], &sb
);
313 goto check_header_out
;
318 if (cmp_header(line
, "Content-Type")) {
319 len
= strlen("Content-Type: ");
320 strbuf_add(&sb
, line
->buf
+ len
, line
->len
- len
);
322 strbuf_insert(&sb
, 0, "Content-Type: ", len
);
323 handle_content_type(&sb
);
325 goto check_header_out
;
327 if (cmp_header(line
, "Content-Transfer-Encoding")) {
328 len
= strlen("Content-Transfer-Encoding: ");
329 strbuf_add(&sb
, line
->buf
+ len
, line
->len
- len
);
331 handle_content_transfer_encoding(&sb
);
333 goto check_header_out
;
336 /* for inbody stuff */
337 if (!prefixcmp(line
->buf
, ">From") && isspace(line
->buf
[5])) {
338 ret
= 1; /* Should this return 0? */
339 goto check_header_out
;
341 if (!prefixcmp(line
->buf
, "[PATCH]") && isspace(line
->buf
[7])) {
342 for (i
= 0; header
[i
]; i
++) {
343 if (!memcmp("Subject", header
[i
], 7)) {
344 handle_header(&hdr_data
[i
], line
);
346 goto check_header_out
;
356 static int is_rfc2822_header(const struct strbuf
*line
)
359 * The section that defines the loosest possible
360 * field name is "3.6.8 Optional fields".
362 * optional-field = field-name ":" unstructured CRLF
363 * field-name = 1*ftext
364 * ftext = %d33-57 / %59-126
367 char *cp
= line
->buf
;
369 /* Count mbox From headers as headers */
370 if (!prefixcmp(cp
, "From ") || !prefixcmp(cp
, ">From "))
373 while ((ch
= *cp
++)) {
376 if ((33 <= ch
&& ch
<= 57) ||
377 (59 <= ch
&& ch
<= 126))
384 static int read_one_header_line(struct strbuf
*line
, FILE *in
)
386 /* Get the first part of the line. */
387 if (strbuf_getline(line
, in
, '\n'))
391 * Is it an empty line or not a valid rfc2822 header?
392 * If so, stop here, and return false ("not a header")
395 if (!line
->len
|| !is_rfc2822_header(line
)) {
396 /* Re-add the newline */
397 strbuf_addch(line
, '\n');
402 * Now we need to eat all the continuation lines..
403 * Yuck, 2822 header "folding"
407 struct strbuf continuation
= STRBUF_INIT
;
409 peek
= fgetc(in
); ungetc(peek
, in
);
410 if (peek
!= ' ' && peek
!= '\t')
412 if (strbuf_getline(&continuation
, in
, '\n'))
414 continuation
.buf
[0] = ' ';
415 strbuf_rtrim(&continuation
);
416 strbuf_addbuf(line
, &continuation
);
422 static struct strbuf
*decode_q_segment(const struct strbuf
*q_seg
, int rfc2047
)
424 const char *in
= q_seg
->buf
;
426 struct strbuf
*out
= xmalloc(sizeof(struct strbuf
));
427 strbuf_init(out
, q_seg
->len
);
429 while ((c
= *in
++) != 0) {
433 break; /* drop trailing newline */
434 strbuf_addch(out
, (hexval(d
) << 4) | hexval(*in
++));
437 if (rfc2047
&& c
== '_') /* rfc2047 4.2 (2) */
439 strbuf_addch(out
, c
);
444 static struct strbuf
*decode_b_segment(const struct strbuf
*b_seg
)
446 /* Decode in..ep, possibly in-place to ot */
447 int c
, pos
= 0, acc
= 0;
448 const char *in
= b_seg
->buf
;
449 struct strbuf
*out
= xmalloc(sizeof(struct strbuf
));
450 strbuf_init(out
, b_seg
->len
);
452 while ((c
= *in
++) != 0) {
457 else if ('A' <= c
&& c
<= 'Z')
459 else if ('a' <= c
&& c
<= 'z')
461 else if ('0' <= c
&& c
<= '9')
464 continue; /* garbage */
470 strbuf_addch(out
, (acc
| (c
>> 4)));
474 strbuf_addch(out
, (acc
| (c
>> 2)));
478 strbuf_addch(out
, (acc
| c
));
487 * When there is no known charset, guess.
489 * Right now we assume that if the target is UTF-8 (the default),
490 * and it already looks like UTF-8 (which includes US-ASCII as its
491 * subset, of course) then that is what it is and there is nothing
494 * Otherwise, we default to assuming it is Latin1 for historical
497 static const char *guess_charset(const struct strbuf
*line
, const char *target_charset
)
499 if (is_encoding_utf8(target_charset
)) {
500 if (is_utf8(line
->buf
))
506 static void convert_to_utf8(struct strbuf
*line
, const char *charset
)
510 if (!charset
|| !*charset
) {
511 charset
= guess_charset(line
, metainfo_charset
);
516 if (!strcasecmp(metainfo_charset
, charset
))
518 out
= reencode_string(line
->buf
, metainfo_charset
, charset
);
520 die("cannot convert from %s to %s",
521 charset
, metainfo_charset
);
522 strbuf_attach(line
, out
, strlen(out
), strlen(out
));
525 static int decode_header_bq(struct strbuf
*it
)
528 struct strbuf outbuf
= STRBUF_INIT
, *dec
;
529 struct strbuf charset_q
= STRBUF_INIT
, piecebuf
= STRBUF_INIT
;
533 while (in
- it
->buf
<= it
->len
&& (ep
= strstr(in
, "=?")) != NULL
) {
535 strbuf_reset(&charset_q
);
536 strbuf_reset(&piecebuf
);
541 * We are about to process an encoded-word
542 * that begins at ep, but there is something
543 * before the encoded word.
546 for (scan
= in
; scan
< ep
; scan
++)
550 if (scan
!= ep
|| in
== it
->buf
) {
552 * We should not lose that "something",
553 * unless we have just processed an
554 * encoded-word, and there is only LWS
555 * before the one we are about to process.
557 strbuf_add(&outbuf
, in
, ep
- in
);
561 * ep : "=?iso-2022-jp?B?GyR...?= foo"
562 * ep : "=?ISO-8859-1?Q?Foo=FCbar?= baz"
566 if (ep
- it
->buf
>= it
->len
|| !(cp
= strchr(ep
, '?')))
567 goto decode_header_bq_out
;
569 if (cp
+ 3 - it
->buf
> it
->len
)
570 goto decode_header_bq_out
;
571 strbuf_add(&charset_q
, ep
, cp
- ep
);
574 if (!encoding
|| cp
[2] != '?')
575 goto decode_header_bq_out
;
576 ep
= strstr(cp
+ 3, "?=");
578 goto decode_header_bq_out
;
579 strbuf_add(&piecebuf
, cp
+ 3, ep
- cp
- 3);
580 switch (tolower(encoding
)) {
582 goto decode_header_bq_out
;
584 dec
= decode_b_segment(&piecebuf
);
587 dec
= decode_q_segment(&piecebuf
, 1);
590 if (metainfo_charset
)
591 convert_to_utf8(dec
, charset_q
.buf
);
593 strbuf_addbuf(&outbuf
, dec
);
598 strbuf_addstr(&outbuf
, in
);
600 strbuf_addbuf(it
, &outbuf
);
601 decode_header_bq_out
:
602 strbuf_release(&outbuf
);
603 strbuf_release(&charset_q
);
604 strbuf_release(&piecebuf
);
608 static void decode_header(struct strbuf
*it
)
610 if (decode_header_bq(it
))
612 /* otherwise "it" is a straight copy of the input.
613 * This can be binary guck but there is no charset specified.
615 if (metainfo_charset
)
616 convert_to_utf8(it
, "");
619 static void decode_transfer_encoding(struct strbuf
*line
)
623 switch (transfer_encoding
) {
625 ret
= decode_q_segment(line
, 0);
628 ret
= decode_b_segment(line
);
635 strbuf_addbuf(line
, ret
);
640 static void handle_filter(struct strbuf
*line
);
642 static int find_boundary(void)
644 while (!strbuf_getline(&line
, fin
, '\n')) {
645 if (*content_top
&& is_multipart_boundary(&line
))
651 static int handle_boundary(void)
653 struct strbuf newline
= STRBUF_INIT
;
655 strbuf_addch(&newline
, '\n');
657 if (line
.len
>= (*content_top
)->len
+ 2 &&
658 !memcmp(line
.buf
+ (*content_top
)->len
, "--", 2)) {
659 /* we hit an end boundary */
660 /* pop the current boundary off the stack */
661 strbuf_release(*content_top
);
665 /* technically won't happen as is_multipart_boundary()
666 will fail first. But just in case..
668 if (--content_top
< content
) {
669 fprintf(stderr
, "Detected mismatched boundaries, "
673 handle_filter(&newline
);
674 strbuf_release(&newline
);
676 /* skip to the next boundary */
677 if (!find_boundary())
682 /* set some defaults */
683 transfer_encoding
= TE_DONTCARE
;
684 strbuf_reset(&charset
);
685 message_type
= TYPE_TEXT
;
687 /* slurp in this section's info */
688 while (read_one_header_line(&line
, fin
))
689 check_header(&line
, p_hdr_data
, 0);
691 strbuf_release(&newline
);
693 if (strbuf_getline(&line
, fin
, '\n'))
695 strbuf_addch(&line
, '\n');
699 static inline int patchbreak(const struct strbuf
*line
)
703 /* Beginning of a "diff -" header? */
704 if (!prefixcmp(line
->buf
, "diff -"))
707 /* CVS "Index: " line? */
708 if (!prefixcmp(line
->buf
, "Index: "))
712 * "--- <filename>" starts patches without headers
713 * "---<sp>*" is a manual separator
718 if (!prefixcmp(line
->buf
, "---")) {
719 /* space followed by a filename? */
720 if (line
->buf
[3] == ' ' && !isspace(line
->buf
[4]))
722 /* Just whitespace? */
723 for (i
= 3; i
< line
->len
; i
++) {
724 unsigned char c
= line
->buf
[i
];
735 static int is_scissors_line(const struct strbuf
*line
)
737 size_t i
, len
= line
->len
;
738 int scissors
= 0, gap
= 0;
739 int first_nonblank
= -1;
740 int last_nonblank
= 0, visible
, perforation
= 0, in_perforation
= 0;
741 const char *buf
= line
->buf
;
743 for (i
= 0; i
< len
; i
++) {
744 if (isspace(buf
[i
])) {
745 if (in_perforation
) {
752 if (first_nonblank
< 0)
760 (!memcmp(buf
+ i
, ">8", 2) || !memcmp(buf
+ i
, "8<", 2) ||
761 !memcmp(buf
+ i
, ">%", 2) || !memcmp(buf
+ i
, "%<", 2))) {
772 * The mark must be at least 8 bytes long (e.g. "-- >8 --").
773 * Even though there can be arbitrary cruft on the same line
774 * (e.g. "cut here"), in order to avoid misidentification, the
775 * perforation must occupy more than a third of the visible
776 * width of the line, and dashes and scissors must occupy more
777 * than half of the perforation.
780 visible
= last_nonblank
- first_nonblank
+ 1;
781 return (scissors
&& 8 <= visible
&&
782 visible
< perforation
* 3 &&
783 gap
* 2 < perforation
);
786 static int handle_commit_msg(struct strbuf
*line
)
788 static int still_looking
= 1;
794 if (!line
->len
|| (line
->len
== 1 && line
->buf
[0] == '\n'))
798 if (use_inbody_headers
&& still_looking
) {
799 still_looking
= check_header(line
, s_hdr_data
, 0);
803 /* Only trim the first (blank) line of the commit message
804 * when ignoring in-body headers.
808 /* normalize the log message to UTF-8. */
809 if (metainfo_charset
)
810 convert_to_utf8(line
, charset
.buf
);
812 if (use_scissors
&& is_scissors_line(line
)) {
814 if (fseek(cmitmsg
, 0L, SEEK_SET
))
815 die_errno("Could not rewind output message file");
816 if (ftruncate(fileno(cmitmsg
), 0))
817 die_errno("Could not truncate output message file at scissors");
821 * We may have already read "secondary headers"; purge
822 * them to give ourselves a clean restart.
824 for (i
= 0; header
[i
]; i
++) {
826 strbuf_release(s_hdr_data
[i
]);
827 s_hdr_data
[i
] = NULL
;
832 if (patchbreak(line
)) {
838 fputs(line
->buf
, cmitmsg
);
842 static void handle_patch(const struct strbuf
*line
)
844 fwrite(line
->buf
, 1, line
->len
, patchfile
);
848 static void handle_filter(struct strbuf
*line
)
850 static int filter
= 0;
852 /* filter tells us which part we left off on */
855 if (!handle_commit_msg(line
))
864 static void handle_body(void)
866 struct strbuf prev
= STRBUF_INIT
;
868 /* Skip up to the first boundary */
870 if (!find_boundary())
871 goto handle_body_out
;
875 /* process any boundary lines */
876 if (*content_top
&& is_multipart_boundary(&line
)) {
877 /* flush any leftover */
879 handle_filter(&prev
);
882 if (!handle_boundary())
883 goto handle_body_out
;
886 /* Unwrap transfer encoding */
887 decode_transfer_encoding(&line
);
889 switch (transfer_encoding
) {
893 struct strbuf
**lines
, **it
, *sb
;
895 /* Prepend any previous partial lines */
896 strbuf_insert(&line
, 0, prev
.buf
, prev
.len
);
899 /* binary data most likely doesn't have newlines */
900 if (message_type
!= TYPE_TEXT
) {
901 handle_filter(&line
);
905 * This is a decoded line that may contain
906 * multiple new lines. Pass only one chunk
907 * at a time to handle_filter()
909 lines
= strbuf_split(&line
, '\n');
910 for (it
= lines
; (sb
= *it
); it
++) {
911 if (*(it
+ 1) == NULL
) /* The last line */
912 if (sb
->buf
[sb
->len
- 1] != '\n') {
913 /* Partial line, save it for later. */
914 strbuf_addbuf(&prev
, sb
);
920 * The partial chunk is saved in "prev" and will be
921 * appended by the next iteration of read_line_with_nul().
923 strbuf_list_free(lines
);
927 handle_filter(&line
);
930 } while (!strbuf_getwholeline(&line
, fin
, '\n'));
933 strbuf_release(&prev
);
936 static void output_header_lines(FILE *fout
, const char *hdr
, const struct strbuf
*data
)
938 const char *sp
= data
->buf
;
940 char *ep
= strchr(sp
, '\n');
946 fprintf(fout
, "%s: %.*s\n", hdr
, len
, sp
);
953 static void handle_info(void)
958 for (i
= 0; header
[i
]; i
++) {
959 /* only print inbody headers if we output a patch file */
960 if (patch_lines
&& s_hdr_data
[i
])
962 else if (p_hdr_data
[i
])
967 if (!memcmp(header
[i
], "Subject", 7)) {
969 cleanup_subject(hdr
);
972 output_header_lines(fout
, "Subject", hdr
);
973 } else if (!memcmp(header
[i
], "From", 4)) {
976 fprintf(fout
, "Author: %s\n", name
.buf
);
977 fprintf(fout
, "Email: %s\n", email
.buf
);
980 fprintf(fout
, "%s: %s\n", header
[i
], hdr
->buf
);
986 static int mailinfo(FILE *in
, FILE *out
, const char *msg
, const char *patch
)
992 cmitmsg
= fopen(msg
, "w");
997 patchfile
= fopen(patch
, "w");
1004 p_hdr_data
= xcalloc(MAX_HDR_PARSED
, sizeof(*p_hdr_data
));
1005 s_hdr_data
= xcalloc(MAX_HDR_PARSED
, sizeof(*s_hdr_data
));
1009 } while (isspace(peek
));
1012 /* process the email header */
1013 while (read_one_header_line(&line
, fin
))
1014 check_header(&line
, p_hdr_data
, 1);
1022 static int git_mailinfo_config(const char *var
, const char *value
, void *unused
)
1024 if (prefixcmp(var
, "mailinfo."))
1025 return git_default_config(var
, value
, unused
);
1026 if (!strcmp(var
, "mailinfo.scissors")) {
1027 use_scissors
= git_config_bool(var
, value
);
1030 /* perhaps others here */
1034 static const char mailinfo_usage
[] =
1035 "git mailinfo [-k|-b] [-u | --encoding=<encoding> | -n] [--scissors | --no-scissors] msg patch < mail >info";
1037 int cmd_mailinfo(int argc
, const char **argv
, const char *prefix
)
1039 const char *def_charset
;
1041 /* NEEDSWORK: might want to do the optional .git/ directory
1044 git_config(git_mailinfo_config
, NULL
);
1046 def_charset
= get_commit_output_encoding();
1047 metainfo_charset
= def_charset
;
1049 while (1 < argc
&& argv
[1][0] == '-') {
1050 if (!strcmp(argv
[1], "-k"))
1052 else if (!strcmp(argv
[1], "-b"))
1053 keep_non_patch_brackets_in_subject
= 1;
1054 else if (!strcmp(argv
[1], "-u"))
1055 metainfo_charset
= def_charset
;
1056 else if (!strcmp(argv
[1], "-n"))
1057 metainfo_charset
= NULL
;
1058 else if (!prefixcmp(argv
[1], "--encoding="))
1059 metainfo_charset
= argv
[1] + 11;
1060 else if (!strcmp(argv
[1], "--scissors"))
1062 else if (!strcmp(argv
[1], "--no-scissors"))
1064 else if (!strcmp(argv
[1], "--no-inbody-headers"))
1065 use_inbody_headers
= 0;
1067 usage(mailinfo_usage
);
1072 usage(mailinfo_usage
);
1074 return !!mailinfo(stdin
, stdout
, argv
[1], argv
[2]);