/*++ /* NAME /* rfc2047_code 3 /* SUMMARY /* non-ASCII header content encoding /* SYNOPSIS /* #include /* /* int rfc2047_encode( /* VSTRING *result, /* int header_context, /* const char *charset, /* const char *in, /* ssize_t len, /* const char *out_separator) /* DESCRIPTION /* rfc2047_encode() encodes the input for the specified header /* context, producing one or more encoded-word instances. The /* result is the string value of the result buffer, or null in case /* of error. /* /* rfc2047_encode() uses quoted-printable if the input is shorter /* than 20 bytes, or if fewer than 1/2 of the input bytes need to /* be encoded; otherwise it uses base64. /* /* rfc2047_encode() limits the length of an encoded-word as required /* by RFC 2047, and produces as many encoded-word instances as /* needed, separated with a caller-specified separator. /* /* Arguments: /* .IP result /* The buffer that the output will overwrite. The result is /* null-terminated. /* .IP header_context /* Specify one of: /* .RS /* .IP RFC2047_HEADER_CONTEXT_COMMENT /* The result will be used as 'comment' text, i.e. the result will /* later be enclosed with "(" and ")". /* .IP RFC2047_HEADER_CONTEXT_PHRASE /* The result will be used as 'phrase' text, for example, the full /* name for an email address. The input must not be a quoted string. /* rfc2047_encode() logs a warning and returns null if the input /* begins with a double quote. /* .RE /* .IP charset /* Null-terminated character array with a valid character set name. /* rfc2047_encode() logs a warning and returns null if a charset /* value does not meet RFC 2047 syntax requirements. /* .IP in /* Pointer to input storage. /* .IP len /* The number of input bytes. rfc2047_encode() logs a warning and /* returns null if this length is < 1. /* .IP out_separator /* Folding white-space text that will be inserted between /* multiple encoded-word instances in rfc2047_encode() /* output. rfc2047_encode() logs a warning and returns null if this /* argument does not specify whitespace text. /* DIAGNOSTICS /* rfc2047_encode() returns null in case of error. See above for /* specific error cases. /* BUGS /* The thresholds for switching from quoted-printable to base64 /* encoding are arbitrary. What is optimal for one observer may be /* suspicious for a different one. /* SEE ALSO /* RFC 2047, Message Header Extensions for Non-ASCII Text /* LICENSE /* .ad /* .fi /* The Secure Mailer license must be distributed with this software. /* AUTHOR(S) /* Wietse Venema /* porcupine.org /*--*/ /* * System library. */ #include #include #include /* * Utility library. */ #include #include #include /* * Global library. */ #include #include /* * The general form of an encoded-word is =?charset?encoding?encoded-text?= * where charset and encoding are case insensitive, and encoding is B or Q. */ /* * What ASCII characters are allowed in the 'charset' or 'encoding' tokens * of an encoded-word. */ #define RFC2047_ESPECIALS_STR "()<>@,;:\\\"/[]?.=" #define RFC2047_ALLOWED_TOKEN_CHAR(c) \ (isascii(c) && !iscntrl(c) && ch != ' ' \ && !strchr(RFC2047_ESPECIALS_STR, ch)) /* * Common definitions for the base64 and quoted-printable encoders. */ #define ENC_WORD_MAX_LEN 75 /* =?charset?encoding?encoded?= */ #define ENC_WORD_PROLOG_FMT "=?%s?%c?" /* =?charset?encoding? */ #define ENC_WORD_EPILOG_STR "?=" #define ENC_WORD_EPILOG_LEN (sizeof(ENC_WORD_EPILOG_STR) - 1) #define ENC_WORD_ENCODING_B64 'B' #define ENC_WORD_ENCODING_QP 'Q' /* * Per RFC 2047 section 1, an encoded-word contains only printable ASCII * characters. Therefore, the quoted-printable encoder must always encode * ASCII SPACE, ASCII control characters, and non-ASCII byte values. * * Per RFC 2047 section 4.2.(2), the quoted-printable encoder must always * encode the "=", "?" and "_" characters. * * Per RFC 2047 section 5.(1) these rules are sufficient for header fields that * contain unstructured text such as Subject, X- custom headers, etc. */ #define QP_ENCODE_ASCII_NON_CNTRL " =?_" /* * Per RFC 2047 section 5.(2) the quoted-printable encoder for comment text * also needs to encode "(", ")", and "\". */ #define QP_ENCODE_ASCII_NON_CNTRL_COMMENT_FIELD \ (QP_ENCODE_ASCII_NON_CNTRL "()\\") /* * Per RFC 2047 section 5.(3) as amended by erratum(4): when used as a * replacement for a 'word' entity within a 'phrase', a "Q"-encoded * encoded-text can contain only alpha digit "!", "*", "+", "-", "/", "=" * (only if followed by two hexadecimal digits), and "_". I.e not " # $ % & * ' ( ) , . : ; < > ? [ \ ] ^ ` { | } ~. * * In other words they require encoding not only RFC 5322 specials and * characters reserved for encoded-word formatting, but they also disallow * characters that RFC 5322 allows in atext: # $ % & ' ^ ` { | } ~. */ #define QP_ENCODE_ASCII_NON_CNTRL_PHRASE_WORD \ (QP_ENCODE_ASCII_NON_CNTRL LEX_822_SPECIALS "#$%&'?^`{|}~") /* * Considering the above discussion, why don't we just always base64 encode * the input? Because results from a web search suggest that some spam * filters penalize base64 encoding in headers. */ /* rfc204_b64_encode_append - encode header_entity with base64 */ static char *rfc204_b64_encode(VSTRING *result, const char *charset, const char *in, ssize_t len, const char *out_separator) { const char *cp; const char *in_end; /* * Convert the input into one or more encoded-word's of at most 75 bytes, * separated with a caller-specified output separator. */ VSTRING_RESET(result); for (cp = in, in_end = in + len; cp < in_end; /* see below */ ) { ssize_t enc_word_start, enc_word_prolog_len, space_avail, todo; /* Start an encoded-word. */ enc_word_start = VSTRING_LEN(result); vstring_sprintf_append(result, ENC_WORD_PROLOG_FMT, charset, ENC_WORD_ENCODING_B64); enc_word_prolog_len = VSTRING_LEN(result) - enc_word_start; space_avail = ENC_WORD_MAX_LEN - ENC_WORD_EPILOG_LEN - enc_word_prolog_len; /* Fill in the encoded-text portion. */ todo = 3 * (space_avail >> 2); if (todo > in_end - cp) todo = in_end - cp; (void) base64_encode_opt(result, cp, todo, BASE64_FLAG_APPEND); /* Finish the encoded-word. */ (void) vstring_strcat(result, ENC_WORD_EPILOG_STR); /* Are we done yet? */ if ((cp += todo) < in_end) vstring_strcat(result, out_separator); } return (vstring_str(result)); } /* rfc2047_qp_encode - encode header_entity with quoted-printable */ static char *rfc2047_qp_encode(VSTRING *result, const char *charset, const char *specials, const char *in, ssize_t len, const char *out_separator) { const char *cp; const char *in_end; VSTRING_RESET(result); for (cp = in, in_end = in + len; cp < in_end; /* see below */ ) { ssize_t enc_word_start, enc_word_prolog_len, space_avail; int ch; /* Start an encoded-word. */ enc_word_start = VSTRING_LEN(result); vstring_sprintf_append(result, ENC_WORD_PROLOG_FMT, charset, ENC_WORD_ENCODING_QP); enc_word_prolog_len = VSTRING_LEN(result) - enc_word_start; space_avail = ENC_WORD_MAX_LEN - ENC_WORD_EPILOG_LEN - enc_word_prolog_len; /* Fill in the encoded-text portion. */ for ( /* void */ ; cp < in_end && space_avail > 0; cp++) { ch = *(unsigned char *) cp; if (ch == 0x20) { VSTRING_ADDCH(result, '_'); space_avail -= 1; } else if (!isascii(ch) || iscntrl(ch) || strchr(specials, ch)) { if (space_avail < 3) /* Try again in the next encoded-word. */ break; vstring_sprintf_append(result, "=%02X", ch); space_avail -= 3; } else { VSTRING_ADDCH(result, ch); space_avail -= 1; } } /* Finish the encoded-word and null-terminate the result. */ (void) vstring_strcat(result, ENC_WORD_EPILOG_STR); /* Are we done yet? */ if (cp < in_end) vstring_strcat(result, out_separator); } return (vstring_str(result)); } /* rfc2047_encode - encode header text field */ char *rfc2047_encode(VSTRING *result, int header_context, const char *charset, const char *in, ssize_t len, const char *out_separator) { const char myname[] = "rfc2047_encode"; const unsigned char *cp; int ch; const char *qp_encoding_specials; /* * Sanity check the null-terminated charset name. This content is * configurable in Postfix, but there is no need to terminate the * process. */ if (*charset == 0) { msg_warn("%s: encoder called with empty charset name", myname); return (0); } for (cp = (const unsigned char *) charset; (ch = *cp) != 0; cp++) { if (!RFC2047_ALLOWED_TOKEN_CHAR(ch)) { msg_warn("%s: invalid character: 0x%x in charset name: '%s'", myname, ch, charset); return (0); } } /* * Sanity check the input size. This may be partly user controlled, so * don't panic. */ if (len < 1) { msg_warn("%s: encoder called with empty input", myname); return (0); } if (!allspace(out_separator)) { msg_warn("%s: encoder called with non-whitespace separator: '%s'", myname, out_separator); return (0); } /* * The RFC 2047 rules for quoted-printable encoding differ for comment * text and phrase text. */ switch (header_context) { case RFC2047_HEADER_CONTEXT_COMMENT: qp_encoding_specials = QP_ENCODE_ASCII_NON_CNTRL_COMMENT_FIELD; break; case RFC2047_HEADER_CONTEXT_PHRASE: qp_encoding_specials = QP_ENCODE_ASCII_NON_CNTRL_PHRASE_WORD; if (*in == '"') { msg_warn("%s: encoder called with quoted word as input: '%s'", myname, in); return (0); } break; default: msg_panic("%s: unexpected header_context: 0x%x", myname, header_context); } /* * Choose between quoted-printable or base64 encoding. * * Header strings are short, so making multiple passes over the input is not * a disaster. How many bytes would the encoder produce using * quoted-printable? We don't optimize for the shortest encoding but for * compromised readability. If the input is not short, and more than 1/2 * of the input bytes need to be encoded, then the content is mostly not * printable ASCII, and quoted-printable output is mostly not readable. * But, naive spam filters may treat base64 in headers with suspicion. */ if (len >= 20) { int need_to_qp = 0; int threshold = len / 2; const unsigned char *end = (const unsigned char *) in + len; for (cp = (const unsigned char *) in; cp < end; cp++) { ch = *cp; need_to_qp += (!isascii(ch) || isspace(ch) || iscntrl(ch) || strchr(qp_encoding_specials, ch)); if (need_to_qp >= threshold) return (rfc204_b64_encode(result, charset, in, len, out_separator)); } } return (rfc2047_qp_encode(result, charset, qp_encoding_specials, in, len, out_separator)); } #ifdef TEST #include /* fd_set */ #include #include #include #include /* * TODO(wietse) make this a proper VSTREAM interface. Instead of temporarily * swapping streams, we could temporarily swap the stream's write function. */ /* vstream_swap - capture output for testing */ static void vstream_swap(VSTREAM *one, VSTREAM *two) { VSTREAM save; save = *one; *one = *two; *two = save; } /* override the printable() call in msg output, it breaks our tests */ char *printable_except(char *string, int replacement, const char *except) { return (string); } /* * Test structure. Some tests generate their own. */ typedef struct TEST_CASE { const char *label; int (*action) (const struct TEST_CASE *); int context; const char *charset; const char *input; ssize_t in_len; const char *out_separator; const char *exp_output; const char *exp_warning; } TEST_CASE; #define PASS (0) #define FAIL (1) #define NO_OUTPUT ((char *) 0) static int test_rfc2047_encode(const TEST_CASE *tp) { static VSTRING *msg_buf; static VSTRING *result; VSTREAM *memory_stream; const char *got; if (msg_buf == 0) { msg_buf = vstring_alloc(100); result = vstring_alloc(100); } /* Run the test with custom STDERR stream. */ VSTRING_RESET(msg_buf); VSTRING_TERMINATE(msg_buf); if ((memory_stream = vstream_memopen(msg_buf, O_WRONLY)) == 0) msg_fatal("open memory stream: %m"); vstream_swap(VSTREAM_ERR, memory_stream); got = rfc2047_encode(result, tp->context, tp->charset, tp->input, tp->in_len != 0 ? tp->in_len : strlen(tp->input), tp->out_separator); vstream_swap(memory_stream, VSTREAM_ERR); if (vstream_fclose(memory_stream)) msg_fatal("close memory stream: %m"); /* Verify the results. */ if (tp->exp_warning == 0 && VSTRING_LEN(msg_buf) > 0) { msg_warn("got warning ``%s'', want ``null''", vstring_str(msg_buf)); return (FAIL); } if (tp->exp_warning != 0 && strcmp(vstring_str(msg_buf), tp->exp_warning) != 0) { msg_warn("got warning ``%s'', want ``%s''", vstring_str(msg_buf), tp->exp_warning); return (FAIL); } if (!got == !tp->exp_warning) { msg_warn("got result ``%s'', and warning ``%s''", got ? got : "null", tp->exp_warning ? tp->exp_warning : "null"); return (FAIL); } if (!got != !tp->exp_output) { msg_warn("got result ``%s'', want ``%s''", got ? got : "null", tp->exp_output ? tp->exp_output : "null"); return (FAIL); } if (got && strcmp(got, tp->exp_output) != 0) { msg_warn("got result ``%s'', want ``%s''", got, tp->exp_output); return (FAIL); } return (PASS); } /* * Input/output templates for charset tests. */ #define CHARSET_INPUT_TEMPLATE "testme" #define CHARSET_OUTPUT_SEPARATOR " " #define CHARSET_CHARSET_TEMPLATE "utf-8%c" #define CHARSET_ALLOW_TEMPLATE "=?utf-8%c?Q?testme?=" #define CHARSET_REJECT_TEMPLATE \ "rfc2047_code: warning: rfc2047_encode: invalid character: " \ "0x%x in charset name: 'utf-8%c'\n" static int validates_charset(const TEST_CASE *tp) { VSTRING *charset; VSTRING *exp_output; VSTRING *exp_warning; TEST_CASE test; int ch; int ret; fd_set asciimap; #define SET_RANGE(map, min, max) do { \ int _n; \ for (_n = (min); _n <= (max); _n++) \ FD_SET(_n, (map)); \ } while (0); #define SET_SINGLE(map, n) do { \ FD_SET(n, (map)); \ } while (0); /* * Initialize a bitmap with characters that are allowed in a charset * name. */ FD_ZERO(&asciimap); SET_SINGLE(&asciimap, '!'); SET_RANGE(&asciimap, '#', '\''); SET_RANGE(&asciimap, '*', '+'); SET_SINGLE(&asciimap, '-'); SET_RANGE(&asciimap, '0', '9'); SET_RANGE(&asciimap, 'A', 'Z'); SET_RANGE(&asciimap, '^', '~'); charset = vstring_alloc(10); exp_output = vstring_alloc(100); exp_warning = vstring_alloc(100); test.label = tp->label; test.action = 0; test.context = RFC2047_HEADER_CONTEXT_COMMENT; test.input = CHARSET_INPUT_TEMPLATE; test.in_len = 0; test.out_separator = CHARSET_OUTPUT_SEPARATOR; /* TODO: 0x0 in charset. */ for (ret = 0, ch = 0x1; ret == 0 && ch <= 0xff; ch++) { vstring_sprintf(charset, CHARSET_CHARSET_TEMPLATE, ch); test.charset = vstring_str(charset); if (FD_ISSET(ch, &asciimap)) { vstring_sprintf(exp_output, CHARSET_ALLOW_TEMPLATE, ch); test.exp_output = vstring_str(exp_output); test.exp_warning = 0; } else { test.exp_output = 0; vstring_sprintf(exp_warning, CHARSET_REJECT_TEMPLATE, ch, ch); test.exp_warning = vstring_str(exp_warning); } ret = test_rfc2047_encode(&test); } vstring_free(charset); vstring_free(exp_output); vstring_free(exp_warning); return (ret == 0 ? PASS : FAIL); } /* * Specify an explicit input length, so that we can input a null byte. */ #define ENCODE_INPUT_TEMPLATE "testme %c" #define ENCODE_INPUT_LEN (sizeof(ENCODE_INPUT_TEMPLATE) - 2) #define ENCODE_OUTPUT_SEPARATOR "\n" #define ENCODE_CHARSET "utf-8" #define ENCODE_AS_SELF_TEMPLATE "=?utf-8?Q?testme_%c?=" #define ENCODE_AS_QP_TEMPLATE "=?utf-8?Q?testme_=%02X?=" #define ENCODE_AS_CTRL_TEMPLATE "=?utf-8?Q?testme_?=" /* * TODO(wietse) split into 'encodes non-control text' and 'rejects control * text'1 */ static int encodes_text(const char *label, int context, const char *specials) { VSTRING *input; VSTRING *exp_output; TEST_CASE test; int ch; int ret; fd_set asciimap; const char *cp; /* * Initialize a bitmap with characters that need no encoding. */ FD_ZERO(&asciimap); SET_RANGE(&asciimap, 0x20, 0x7e); /* ASCII non-controls */ for (cp = specials; (ch = *(unsigned char *) cp) != 0; cp++) FD_CLR(ch, &asciimap); input = vstring_alloc(100); exp_output = vstring_alloc(100); /* * TODO(wietse) We don't use VSTRING_LEN(input) to determine how much * output was written. When the output contains a null byte, * VSTRING_LEN(input) will be smaller than ENCODE_INPUT_LEN because * vbuf_print() still supports systems without snprintf() and relies on * the equivalent of strlen() to find out how much was written. */ test.label = label; test.action = 0; test.context = context; test.charset = "utf-8"; test.in_len = ENCODE_INPUT_LEN; test.out_separator = ENCODE_OUTPUT_SEPARATOR; test.exp_warning = 0; for (ret = 0, ch = 0x0; ret == 0 && ch <= 0xff; ch++) { vstring_sprintf(input, ENCODE_INPUT_TEMPLATE, ch); test.input = vstring_str(input); if (FD_ISSET(ch, &asciimap)) { vstring_sprintf(exp_output, ENCODE_AS_SELF_TEMPLATE, ch); } else if (ch == ' ') { vstring_sprintf(exp_output, ENCODE_AS_SELF_TEMPLATE, '_'); } else { vstring_sprintf(exp_output, ENCODE_AS_QP_TEMPLATE, ch); } test.exp_output = vstring_str(exp_output); ret = test_rfc2047_encode(&test); } vstring_free(input); vstring_free(exp_output); return (ret == 0 ? PASS : FAIL); } static int encodes_comment_text(const TEST_CASE *tp) { const char specials[] = { /* RFC 2047 encoded-word formatting. */ ' ', '_', '=', '?', /* Not allowed in RFC 5322 ctext. */ '(', ')', '\\', 0, }; return (encodes_text(tp->label, RFC2047_HEADER_CONTEXT_COMMENT, specials)); } static int encodes_phrase_text(const TEST_CASE *tp) { const char specials[] = { /* RFC 2047 encoded-word formatting. */ ' ', '_', '=', '?', /* RFC 5322 specials. */ '"', '(', ')', ',', '.', ':', ';', '<', '>', '@', '[', '\\', ']', /* Not allowed in RFC 2047 section 5(3). */ '#', '$', '%', '&', '\'', '^', '`', '{', '|', '}', '~', 0, }; return (encodes_text(tp->label, RFC2047_HEADER_CONTEXT_PHRASE, specials)); } static const TEST_CASE test_cases[] = { /* * Smoke test. If this fails then all bets are off. */ {"comment_needs_no_encoding", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_COMMENT, "utf-8", "testme", 0, " ", "=?utf-8?Q?testme?=" }, /* * Charset validation. */ {"validates_charset_not_empty", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_COMMENT, /* charset= */ "", "testme", 0, " ", NO_OUTPUT, "rfc2047_code: warning: rfc2047_encode: " "encoder called with empty charset name\n" }, {"validates_charset", validates_charset}, {"encodes_comment_text", encodes_comment_text}, {"encodes_long_comment_text", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_COMMENT, "utf-8", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 0, "\n", "=?utf-8?Q?AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" "AAAAAAAAAAAAA?=\n=?utf-8?Q?AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" "AAAAAAAAAAAAAAAAAAAAAAAA?=" }, /* * Encoding validation. */ {"validates_input_not_empty", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_COMMENT, "utf-8", /* input= */ "", 0, " ", NO_OUTPUT, "rfc2047_code: warning: " "rfc2047_encode: encoder called with empty input\n" }, {"validates_whitespace_separator", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_COMMENT, "utf-8", "whatever", 0, "foo", NO_OUTPUT, "rfc2047_code: warning: " "rfc2047_encode: encoder called with non-whitespace separator: " "'foo'\n" }, {"validates_non_quoted_word", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_PHRASE, "utf-8", "\"whatever", 0, " ", NO_OUTPUT, "rfc2047_code: warning: " "rfc2047_encode: encoder called with quoted word as input: " "'\"whatever'\n" }, {"encodes_phrase_text", encodes_phrase_text}, {"encodes_long_phrase_text", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_PHRASE, "utf-8", "000102030405060708091011121314151617181920212223242526272829" "303132333435363738394041424344454647484950515253545556575859" "606162636465666768697071727374757677787980818283848586878889", 0, "\n", "=?utf-8?Q?00010203040506070809101112131415161718192021222324" "2526272829303?=\n=?utf-8?Q?132333435363738394041424344454647" "484950515253545556575859606162?=\n=?utf-8?Q?6364656667686970" "71727374757677787980818283848586878889?=" }, {"encodes_mostly_ascii_as_qp", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_PHRASE, "utf-8", "some non-ascii Δημοσ embedded in ascii", 0, "\n", "=?utf-8?Q?some_non-ascii_=CE=94=CE=B7=CE=BC=CE=BF=CF=83_embe" "dded_in_ascii?=" }, {"encodes_whole_qp_triplets_1x", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_PHRASE, "utf-8", "x some small amount of non-ascii Δημοσ embedded in ascii", 0, "\n", "=?utf-8?Q?x_some_small_amount_of_non-ascii_=CE=94=CE=B7=CE=BC=CE=B" "F=CF=83?=\n=?utf-8?Q?_embedded_in_ascii?=" }, {"encodes_whole_qp_triplets_2x", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_PHRASE, "utf-8", "xx some small amount of non-ascii Δημοσ embedded in ascii", 0, "\n", "=?utf-8?Q?xx_some_small_amount_of_non-ascii_=CE=94=CE=B7=CE=BC=CE=B" "F=CF?=\n=?utf-8?Q?=83_embedded_in_ascii?=" }, {"encodes_mostly_non_ascii_as_b64", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_PHRASE, "utf-8", "mostly non-ascii Δημοσθένους", 0, "\n", "=?utf-8?B?bW9zdGx5IG5vbi1hc2NpaSDOlM63zrzOv8+DzrjhvbPOvc6/z4XPgg==?=" }, {"encodes_whole_b64_quads_4x", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_PHRASE, "utf-8", "xxxx mostly non-ascii Δημοσθένους", 0, "\n", "=?utf-8?B?eHh4eCBtb3N0bHkgbm9uLWFzY2lpIM6UzrfOvM6/z4POuOG9s869zr/Phc" "+C?=" }, {"encodes_whole_b64_quads_5x", test_rfc2047_encode, RFC2047_HEADER_CONTEXT_PHRASE, "utf-8", "xxxxx mostly non-ascii Δημοσθένους", 0, "\n", "=?utf-8?B?eHh4eHggbW9zdGx5IG5vbi1hc2NpaSDOlM63zrzOv8+DzrjhvbPOvc6/z4" "XP?=\n=?utf-8?B?gg==?=" }, {0}, }; int main(int argc, char **argv) { const TEST_CASE *tp; int pass = 0; int fail = 0; msg_vstream_init(sane_basename((VSTRING *) 0, argv[0]), VSTREAM_ERR); for (tp = test_cases; tp->label != 0; tp++) { int test_failed; msg_info("RUN %s", tp->label); test_failed = tp->action(tp); if (test_failed) { msg_info("FAIL %s", tp->label); fail++; } else { msg_info("PASS %s", tp->label); pass++; } } msg_info("PASS=%d FAIL=%d", pass, fail); exit(fail != 0); } #endif