NeoMutt  2024-04-25-97-g7d2481
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
rfc2047.c
Go to the documentation of this file.
1
33#include "config.h"
34#include <ctype.h>
35#include <errno.h>
36#include <iconv.h>
37#include <stdbool.h>
38#include <string.h>
39#include "mutt/lib.h"
40#include "address/lib.h"
41#include "config/lib.h"
42#include "core/lib.h"
43#include "rfc2047.h"
44#include "envelope.h"
45#include "mime.h"
46
47#define ENCWORD_LEN_MAX 75
48#define ENCWORD_LEN_MIN 9 /* strlen ("=?.?.?.?=") */
49
50#define HSPACE(ch) (((ch) == '\0') || ((ch) == ' ') || ((ch) == '\t'))
51
52#define CONTINUATION_BYTE(ch) (((ch) & 0xc0) == 0x80)
53
65typedef size_t (*encoder_t)(char *res, const char *buf, size_t buflen, const char *tocode);
66
70static size_t b_encoder(char *res, const char *src, size_t srclen, const char *tocode)
71{
72 char *s0 = res;
73
74 memcpy(res, "=?", 2);
75 res += 2;
76 memcpy(res, tocode, strlen(tocode));
77 res += strlen(tocode);
78 memcpy(res, "?B?", 3);
79 res += 3;
80
81 while (srclen)
82 {
83 char encoded[11] = { 0 };
84 size_t rc;
85 size_t in_len = MIN(3, srclen);
86
87 rc = mutt_b64_encode(src, in_len, encoded, sizeof(encoded));
88 for (size_t i = 0; i < rc; i++)
89 *res++ = encoded[i];
90
91 srclen -= in_len;
92 src += in_len;
93 }
94
95 memcpy(res, "?=", 2);
96 res += 2;
97 return res - s0;
98}
99
103static size_t q_encoder(char *res, const char *src, size_t srclen, const char *tocode)
104{
105 static const char hex[] = "0123456789ABCDEF";
106 char *s0 = res;
107
108 memcpy(res, "=?", 2);
109 res += 2;
110 memcpy(res, tocode, strlen(tocode));
111 res += strlen(tocode);
112 memcpy(res, "?Q?", 3);
113 res += 3;
114 while (srclen--)
115 {
116 unsigned char c = *src++;
117 if (c == ' ')
118 {
119 *res++ = '_';
120 }
121 else if ((c >= 0x7f) || (c < 0x20) || (c == '_') || strchr(MimeSpecials, c))
122 {
123 *res++ = '=';
124 *res++ = hex[(c & 0xf0) >> 4];
125 *res++ = hex[c & 0x0f];
126 }
127 else
128 {
129 *res++ = c;
130 }
131 }
132 memcpy(res, "?=", 2);
133 res += 2;
134 return res - s0;
135}
136
148static char *parse_encoded_word(char *str, enum ContentEncoding *enc, char **charset,
149 size_t *charsetlen, char **text, size_t *textlen)
150{
151 regmatch_t *match = mutt_prex_capture(PREX_RFC2047_ENCODED_WORD, str);
152 if (!match)
153 return NULL;
154
155 const regmatch_t *mfull = &match[PREX_RFC2047_ENCODED_WORD_MATCH_FULL];
156 const regmatch_t *mcharset = &match[PREX_RFC2047_ENCODED_WORD_MATCH_CHARSET];
157 const regmatch_t *mencoding = &match[PREX_RFC2047_ENCODED_WORD_MATCH_ENCODING];
158 const regmatch_t *mtext = &match[PREX_RFC2047_ENCODED_WORD_MATCH_TEXT];
159
160 /* Charset */
161 *charset = str + mutt_regmatch_start(mcharset);
162 *charsetlen = mutt_regmatch_len(mcharset);
163
164 /* Encoding: either Q or B */
165 *enc = (tolower(str[mutt_regmatch_start(mencoding)]) == 'q') ? ENC_QUOTED_PRINTABLE : ENC_BASE64;
166
167 *text = str + mutt_regmatch_start(mtext);
168 *textlen = mutt_regmatch_len(mtext);
169 return str + mutt_regmatch_start(mfull);
170}
171
191static size_t try_block(const char *d, size_t dlen, const char *fromcode,
192 const char *tocode, encoder_t *encoder, size_t *wlen)
193{
194 char buf[ENCWORD_LEN_MAX - ENCWORD_LEN_MIN + 1];
195 const char *ib = NULL;
196 char *ob = NULL;
197 size_t ibl, obl;
198 int count, len, len_b, len_q;
199
200 if (fromcode)
201 {
202 iconv_t cd = mutt_ch_iconv_open(tocode, fromcode, MUTT_ICONV_NO_FLAGS);
204 ib = d;
205 ibl = dlen;
206 ob = buf;
207 obl = sizeof(buf) - strlen(tocode);
208 if ((iconv(cd, (ICONV_CONST char **) &ib, &ibl, &ob, &obl) == ICONV_ILLEGAL_SEQ) ||
209 (iconv(cd, NULL, NULL, &ob, &obl) == ICONV_ILLEGAL_SEQ))
210 {
211 ASSERT(errno == E2BIG);
212 ASSERT(ib > d);
213 return ((ib - d) == dlen) ? dlen : ib - d + 1;
214 }
215 }
216 else
217 {
218 if (dlen > (sizeof(buf) - strlen(tocode)))
219 return sizeof(buf) - strlen(tocode) + 1;
220 memcpy(buf, d, dlen);
221 ob = buf + dlen;
222 }
223
224 count = 0;
225 for (char *p = buf; p < ob; p++)
226 {
227 unsigned char c = *p;
228 ASSERT(strchr(MimeSpecials, '?'));
229 if ((c >= 0x7f) || (c < 0x20) || (*p == '_') ||
230 ((c != ' ') && strchr(MimeSpecials, *p)))
231 {
232 count++;
233 }
234 }
235
236 len = ENCWORD_LEN_MIN - 2 + strlen(tocode);
237 len_b = len + (((ob - buf) + 2) / 3) * 4;
238 len_q = len + (ob - buf) + 2 * count;
239
240 /* Apparently RFC1468 says to use B encoding for iso-2022-jp. */
241 if (mutt_istr_equal(tocode, "ISO-2022-JP"))
242 len_q = ENCWORD_LEN_MAX + 1;
243
244 if ((len_b < len_q) && (len_b <= ENCWORD_LEN_MAX))
245 {
246 *encoder = b_encoder;
247 *wlen = len_b;
248 return 0;
249 }
250 else if (len_q <= ENCWORD_LEN_MAX)
251 {
252 *encoder = q_encoder;
253 *wlen = len_q;
254 return 0;
255 }
256 else
257 {
258 return dlen;
259 }
260}
261
274static size_t encode_block(char *str, char *buf, size_t buflen, const char *fromcode,
275 const char *tocode, encoder_t encoder)
276{
277 if (!fromcode)
278 {
279 return (*encoder)(str, buf, buflen, tocode);
280 }
281
282 const iconv_t cd = mutt_ch_iconv_open(tocode, fromcode, MUTT_ICONV_NO_FLAGS);
284 const char *ib = buf;
285 size_t ibl = buflen;
286 char tmp[ENCWORD_LEN_MAX - ENCWORD_LEN_MIN + 1];
287 char *ob = tmp;
288 size_t obl = sizeof(tmp) - strlen(tocode);
289 const size_t n1 = iconv(cd, (ICONV_CONST char **) &ib, &ibl, &ob, &obl);
290 const size_t n2 = iconv(cd, NULL, NULL, &ob, &obl);
291 ASSERT((n1 != ICONV_ILLEGAL_SEQ) && (n2 != ICONV_ILLEGAL_SEQ));
292 return (*encoder)(str, tmp, ob - tmp, tocode);
293}
294
311static size_t choose_block(char *d, size_t dlen, int col, const char *fromcode,
312 const char *tocode, encoder_t *encoder, size_t *wlen)
313{
314 const bool utf8 = fromcode && mutt_istr_equal(fromcode, "utf-8");
315
316 size_t n = dlen;
317 while (true)
318 {
319 ASSERT(n > 0);
320 const size_t nn = try_block(d, n, fromcode, tocode, encoder, wlen);
321 if ((nn == 0) && (((col + *wlen) <= (ENCWORD_LEN_MAX + 1)) || (n <= 1)))
322 break;
323 n = ((nn != 0) ? nn : n) - 1;
324 ASSERT(n > 0);
325 if (utf8)
326 while ((n > 1) && CONTINUATION_BYTE(d[n]))
327 n--;
328 }
329 return n;
330}
331
341static void finalize_chunk(struct Buffer *res, struct Buffer *buf, char *charset, size_t charsetlen)
342{
343 if (!charset)
344 return;
345 char end = charset[charsetlen];
346 charset[charsetlen] = '\0';
348 charset[charsetlen] = end;
350 buf_addstr(res, buf->data);
351 FREE(&buf->data);
352 buf_init(buf);
353}
354
365static char *decode_word(const char *s, size_t len, enum ContentEncoding enc)
366{
367 const char *it = s;
368 const char *end = s + len;
369
370 ASSERT(*end == '\0');
371
372 if (enc == ENC_QUOTED_PRINTABLE)
373 {
374 struct Buffer *buf = buf_pool_get();
375 for (; it < end; it++)
376 {
377 if (*it == '_')
378 {
379 buf_addch(buf, ' ');
380 }
381 else if ((it[0] == '=') && (!(it[1] & ~127) && (hexval(it[1]) != -1)) &&
382 (!(it[2] & ~127) && (hexval(it[2]) != -1)))
383 {
384 buf_addch(buf, (hexval(it[1]) << 4) | hexval(it[2]));
385 it += 2;
386 }
387 else
388 {
389 buf_addch(buf, *it);
390 }
391 }
392 char *str = buf_strdup(buf);
393 buf_pool_release(&buf);
394 return str;
395 }
396 else if (enc == ENC_BASE64)
397 {
398 const int olen = 3 * len / 4 + 1;
399 char *out = mutt_mem_malloc(olen);
400 int dlen = mutt_b64_decode(it, out, olen);
401 if (dlen == -1)
402 {
403 FREE(&out);
404 return NULL;
405 }
406 out[dlen] = '\0';
407 return out;
408 }
409
410 ASSERT(0); /* The enc parameter has an invalid value */
411 return NULL;
412}
413
426static int encode(const char *d, size_t dlen, int col, const char *fromcode,
427 const struct Slist *charsets, char **e, size_t *elen, const char *specials)
428{
429 int rc = 0;
430 char *buf = NULL;
431 size_t bufpos, buflen;
432 char *t0 = NULL, *t1 = NULL, *t = NULL;
433 char *s0 = NULL, *s1 = NULL;
434 size_t ulen, r, wlen = 0;
435 encoder_t encoder = NULL;
436 char *tocode1 = NULL;
437 const char *tocode = NULL;
438 const char *icode = "utf-8";
439
440 /* Try to convert to UTF-8. */
441 char *u = mutt_strn_dup(d, dlen);
442 if (mutt_ch_convert_string(&u, fromcode, icode, MUTT_ICONV_NO_FLAGS) != 0)
443 {
444 rc = 1;
445 icode = 0;
446 }
447 ulen = mutt_str_len(u);
448
449 /* Find earliest and latest things we must encode. */
450 s0 = 0;
451 s1 = 0;
452 t0 = 0;
453 t1 = 0;
454 for (t = u; t < (u + ulen); t++)
455 {
456 if ((*t & 0x80) || ((*t == '=') && (t[1] == '?') && ((t == u) || HSPACE(*(t - 1)))))
457 {
458 if (!t0)
459 t0 = t;
460 t1 = t;
461 }
462 else if (specials && *t && strchr(specials, *t))
463 {
464 if (!s0)
465 s0 = t;
466 s1 = t;
467 }
468 }
469
470 /* If we have something to encode, include RFC822 specials */
471 if (t0 && s0 && (s0 < t0))
472 t0 = s0;
473 if (t1 && s1 && (s1 > t1))
474 t1 = s1;
475
476 if (!t0)
477 {
478 /* No encoding is required. */
479 *e = u;
480 *elen = ulen;
481 return rc;
482 }
483
484 /* Choose target charset. */
485 tocode = fromcode;
486 if (icode)
487 {
488 tocode1 = mutt_ch_choose(icode, charsets, u, ulen, 0, 0);
489 if (tocode1)
490 {
491 tocode = tocode1;
492 }
493 else
494 {
495 rc = 2;
496 icode = 0;
497 }
498 }
499
500 /* Hack to avoid labelling 8-bit data as us-ascii. */
501 if (!icode && mutt_ch_is_us_ascii(tocode))
502 tocode = "unknown-8bit";
503
504 /* Adjust t0 for maximum length of line. */
505 t = u + (ENCWORD_LEN_MAX + 1) - col - ENCWORD_LEN_MIN;
506 if (t < u)
507 t = u;
508 if (t < t0)
509 t0 = t;
510
511 /* Adjust t0 until we can encode a character after a space. */
512 for (; t0 > u; t0--)
513 {
514 if (!HSPACE(*(t0 - 1)))
515 continue;
516 t = t0 + 1;
517 if (icode)
518 while ((t < (u + ulen)) && CONTINUATION_BYTE(*t))
519 t++;
520 if ((try_block(t0, t - t0, icode, tocode, &encoder, &wlen) == 0) &&
521 ((col + (t0 - u) + wlen) <= (ENCWORD_LEN_MAX + 1)))
522 {
523 break;
524 }
525 }
526
527 /* Adjust t1 until we can encode a character before a space. */
528 for (; t1 < (u + ulen); t1++)
529 {
530 if (!HSPACE(*t1))
531 continue;
532 t = t1 - 1;
533 if (icode)
534 while (CONTINUATION_BYTE(*t))
535 t--;
536 if ((try_block(t, t1 - t, icode, tocode, &encoder, &wlen) == 0) &&
537 ((1 + wlen + (u + ulen - t1)) <= (ENCWORD_LEN_MAX + 1)))
538 {
539 break;
540 }
541 }
542
543 /* We shall encode the region [t0,t1). */
544
545 /* Initialise the output buffer with the us-ascii prefix. */
546 buflen = 2 * ulen;
547 buf = mutt_mem_malloc(buflen);
548 bufpos = t0 - u;
549 memcpy(buf, u, t0 - u);
550
551 col += t0 - u;
552
553 t = t0;
554 while (true)
555 {
556 /* Find how much we can encode. */
557 size_t n = choose_block(t, t1 - t, col, icode, tocode, &encoder, &wlen);
558 if (n == (t1 - t))
559 {
560 /* See if we can fit the us-ascii suffix, too. */
561 if ((col + wlen + (u + ulen - t1)) <= (ENCWORD_LEN_MAX + 1))
562 break;
563 n = t1 - t - 1;
564 if (icode)
565 while (CONTINUATION_BYTE(t[n]))
566 n--;
567 if (n == 0)
568 {
569 /* This should only happen in the really stupid case where the
570 * only word that needs encoding is one character long, but
571 * there is too much us-ascii stuff after it to use a single
572 * encoded word. We add the next word to the encoded region
573 * and try again. */
574 ASSERT(t1 < (u + ulen));
575 for (t1++; (t1 < (u + ulen)) && !HSPACE(*t1); t1++)
576 ; // do nothing
577
578 continue;
579 }
580 n = choose_block(t, n, col, icode, tocode, &encoder, &wlen);
581 }
582
583 /* Add to output buffer. */
584 const char *line_break = "\n\t";
585 const int lb_len = 2; /* strlen(line_break) */
586
587 if ((bufpos + wlen + lb_len) > buflen)
588 {
589 buflen = bufpos + wlen + lb_len;
590 mutt_mem_realloc(&buf, buflen);
591 }
592 r = encode_block(buf + bufpos, t, n, icode, tocode, encoder);
593 ASSERT(r == wlen);
594 bufpos += wlen;
595 memcpy(buf + bufpos, line_break, lb_len);
596 bufpos += lb_len;
597
598 col = 1;
599
600 t += n;
601 }
602
603 /* Add last encoded word and us-ascii suffix to buffer. */
604 buflen = bufpos + wlen + (u + ulen - t1);
605 mutt_mem_realloc(&buf, buflen + 1);
606 r = encode_block(buf + bufpos, t, t1 - t, icode, tocode, encoder);
607 ASSERT(r == wlen);
608 bufpos += wlen;
609 memcpy(buf + bufpos, t1, u + ulen - t1);
610
611 FREE(&tocode1);
612 FREE(&u);
613
614 buf[buflen] = '\0';
615
616 *e = buf;
617 *elen = buflen + 1;
618 return rc;
619}
620
628void rfc2047_encode(char **pd, const char *specials, int col, const struct Slist *charsets)
629{
630 if (!pd || !*pd)
631 return;
632
633 const char *const c_charset = cc_charset();
634 if (!c_charset)
635 return;
636
637 struct Slist *fallback = NULL;
638 if (!charsets)
639 {
640 fallback = slist_parse("utf-8", D_SLIST_SEP_COLON);
641 charsets = fallback;
642 }
643
644 char *e = NULL;
645 size_t elen = 0;
646 encode(*pd, strlen(*pd), col, c_charset, charsets, &e, &elen, specials);
647
648 slist_free(&fallback);
649 FREE(pd);
650 *pd = e;
651}
652
661void rfc2047_decode(char **pd)
662{
663 if (!pd || !*pd)
664 return;
665
666 struct Buffer *buf = buf_pool_get(); // Output buffer
667 char *s = *pd; // Read pointer
668 char *beg = NULL; // Begin of encoded word
669 enum ContentEncoding enc = ENC_OTHER; // ENC_BASE64 or ENC_QUOTED_PRINTABLE
670 char *charset = NULL; // Which charset
671 size_t charsetlen; // Length of the charset
672 char *text = NULL; // Encoded text
673 size_t textlen = 0; // Length of encoded text
674
675 /* Keep some state in case the next decoded word is using the same charset
676 * and it happens to be split in the middle of a multibyte character.
677 * See https://github.com/neomutt/neomutt/issues/1015 */
678 struct Buffer *prev = buf_pool_get(); /* Previously decoded word */
679 char *prev_charset = NULL; /* Previously used charset */
680 size_t prev_charsetlen = 0; /* Length of the previously used charset */
681
682 const struct Slist *c_assumed_charset = cc_assumed_charset();
683 const char *c_charset = cc_charset();
684 while (*s)
685 {
686 beg = parse_encoded_word(s, &enc, &charset, &charsetlen, &text, &textlen);
687 if (beg != s)
688 {
689 /* Some non-encoded text was found */
690 size_t holelen = beg ? beg - s : mutt_str_len(s);
691
692 /* Ignore whitespace between encoded words */
693 if (beg && (mutt_str_lws_len(s, holelen) == holelen))
694 {
695 s = beg;
696 continue;
697 }
698
699 /* If we have some previously decoded text, add it now */
700 if (!buf_is_empty(prev))
701 {
702 finalize_chunk(buf, prev, prev_charset, prev_charsetlen);
703 }
704
705 /* Add non-encoded part */
706 if (slist_is_empty(c_assumed_charset))
707 {
708 buf_addstr_n(buf, s, holelen);
709 }
710 else
711 {
712 char *conv = mutt_strn_dup(s, holelen);
713 mutt_ch_convert_nonmime_string(c_assumed_charset, c_charset, &conv);
714 buf_addstr(buf, conv);
715 FREE(&conv);
716 }
717 s += holelen;
718 }
719 if (beg)
720 {
721 /* Some encoded text was found */
722 text[textlen] = '\0';
723 char *decoded = decode_word(text, textlen, enc);
724 if (!decoded)
725 {
726 goto done;
727 }
728 if (!buf_is_empty(prev) && ((prev_charsetlen != charsetlen) ||
729 !mutt_strn_equal(prev_charset, charset, charsetlen)))
730 {
731 /* Different charset, convert the previous chunk and add it to the
732 * final result */
733 finalize_chunk(buf, prev, prev_charset, prev_charsetlen);
734 }
735
736 buf_addstr(prev, decoded);
737 FREE(&decoded);
738 prev_charset = charset;
739 prev_charsetlen = charsetlen;
740 s = text + textlen + 2; /* Skip final ?= */
741 }
742 }
743
744 /* Save the last chunk */
745 if (!buf_is_empty(prev))
746 {
747 finalize_chunk(buf, prev, prev_charset, prev_charsetlen);
748 }
749
750 FREE(pd);
751 *pd = buf_strdup(buf);
752
753done:
754 buf_pool_release(&buf);
755 buf_pool_release(&prev);
756}
757
766void rfc2047_encode_addrlist(struct AddressList *al, const char *tag)
767{
768 if (!al)
769 return;
770
771 int col = tag ? strlen(tag) + 2 : 32;
772 struct Address *a = NULL;
773 char *data = NULL;
774 const struct Slist *const c_send_charset = cs_subset_slist(NeoMutt->sub, "send_charset");
775 TAILQ_FOREACH(a, al, entries)
776 {
777 if (a->personal)
778 {
779 data = buf_strdup(a->personal);
780 rfc2047_encode(&data, AddressSpecials, col, c_send_charset);
781 buf_strcpy(a->personal, data);
782 FREE(&data);
783 }
784 else if (a->group && a->mailbox)
785 {
786 data = buf_strdup(a->mailbox);
787 rfc2047_encode(&data, AddressSpecials, col, c_send_charset);
788 buf_strcpy(a->mailbox, data);
789 FREE(&data);
790 }
791 }
792}
793
801void rfc2047_decode_addrlist(struct AddressList *al)
802{
803 if (!al)
804 return;
805
806 const bool assumed = !slist_is_empty(cc_assumed_charset());
807 struct Address *a = NULL;
808 char *data = NULL;
809 TAILQ_FOREACH(a, al, entries)
810 {
811 if (a->personal && ((buf_find_string(a->personal, "=?")) || assumed))
812 {
813 data = buf_strdup(a->personal);
814 rfc2047_decode(&data);
815 buf_strcpy(a->personal, data);
816 FREE(&data);
817 }
818 else if (a->group && a->mailbox && buf_find_string(a->mailbox, "=?"))
819 {
820 data = buf_strdup(a->mailbox);
821 rfc2047_decode(&data);
822 buf_strcpy(a->mailbox, data);
823 FREE(&data);
824 }
825 }
826}
827
833{
834 if (!env)
835 return;
844 rfc2047_decode(&env->x_label);
845
846 char *subj = env->subject;
847 *(char **) &env->subject = NULL;
848 rfc2047_decode(&subj);
849 mutt_env_set_subject(env, subj);
850 FREE(&subj);
851}
852
858{
859 if (!env)
860 return;
861 rfc2047_encode_addrlist(&env->from, "From");
862 rfc2047_encode_addrlist(&env->to, "To");
863 rfc2047_encode_addrlist(&env->cc, "Cc");
864 rfc2047_encode_addrlist(&env->bcc, "Bcc");
865 rfc2047_encode_addrlist(&env->reply_to, "Reply-To");
866 rfc2047_encode_addrlist(&env->mail_followup_to, "Mail-Followup-To");
867 rfc2047_encode_addrlist(&env->sender, "Sender");
868 const struct Slist *const c_send_charset = cs_subset_slist(NeoMutt->sub, "send_charset");
869 rfc2047_encode(&env->x_label, NULL, sizeof("X-Label:"), c_send_charset);
870
871 char *subj = env->subject;
872 *(char **) &env->subject = NULL;
873 rfc2047_encode(&subj, NULL, sizeof("Subject:"), c_send_charset);
874 mutt_env_set_subject(env, subj);
875 FREE(&subj);
876}
const char AddressSpecials[]
Characters with special meaning for email addresses.
Definition: address.c:45
Email Address Handling.
size_t mutt_b64_encode(const char *in, size_t inlen, char *out, size_t outlen)
Convert raw bytes to null-terminated base64 string.
Definition: base64.c:87
int mutt_b64_decode(const char *in, char *out, size_t olen)
Convert null-terminated base64 string to raw bytes.
Definition: base64.c:135
size_t buf_addstr_n(struct Buffer *buf, const char *s, size_t len)
Add a string to a Buffer, expanding it if necessary.
Definition: buffer.c:96
const char * buf_find_string(const struct Buffer *buf, const char *s)
Return a pointer to a substring found in the buffer.
Definition: buffer.c:640
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291
struct Buffer * buf_init(struct Buffer *buf)
Initialise a new Buffer.
Definition: buffer.c:61
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:241
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:571
const struct Slist * cs_subset_slist(const struct ConfigSubset *sub, const char *name)
Get a string-list config item by name.
Definition: helpers.c:242
Convenience wrapper for the config headers.
const char * cc_charset(void)
Get the cached value of $charset.
Definition: config_cache.c:116
const struct Slist * cc_assumed_charset(void)
Get the cached value of $assumed_charset.
Definition: config_cache.c:101
Convenience wrapper for the core headers.
void mutt_env_set_subject(struct Envelope *env, const char *subj)
Set both subject and real_subj to subj.
Definition: envelope.c:69
Representation of an email header (envelope)
static size_t b_encoder(char *res, const char *src, size_t srclen, const char *tocode)
Base64 Encode a string - Implements encoder_t -.
Definition: rfc2047.c:70
static size_t q_encoder(char *res, const char *src, size_t srclen, const char *tocode)
Quoted-printable Encode a string - Implements encoder_t -.
Definition: rfc2047.c:103
int mutt_mb_filter_unprintable(char **s)
Replace unprintable characters.
Definition: mbyte.c:423
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:91
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:115
#define FREE(x)
Definition: memory.h:45
#define MIN(a, b)
Definition: memory.h:32
const char MimeSpecials[]
Characters that need special treatment in MIME.
Definition: mime.c:67
Constants and macros for managing MIME encoding.
ContentEncoding
Content-Transfer-Encoding.
Definition: mime.h:47
@ ENC_OTHER
Encoding unknown.
Definition: mime.h:48
@ ENC_BASE64
Base-64 encoded text.
Definition: mime.h:52
@ ENC_QUOTED_PRINTABLE
Quoted-printable text.
Definition: mime.h:51
#define hexval(ch)
Definition: mime.h:80
char * mutt_ch_choose(const char *fromcode, const struct Slist *charsets, const char *u, size_t ulen, char **d, size_t *dlen)
Figure the best charset to encode a string.
Definition: charset.c:1111
int mutt_ch_convert_nonmime_string(const struct Slist *const assumed_charset, const char *charset, char **ps)
Try to convert a string using a list of character sets.
Definition: charset.c:331
int mutt_ch_convert_string(char **ps, const char *from, const char *to, uint8_t flags)
Convert a string between encodings.
Definition: charset.c:831
iconv_t mutt_ch_iconv_open(const char *tocode, const char *fromcode, uint8_t flags)
Set up iconv for conversions.
Definition: charset.c:594
#define MUTT_ICONV_HOOK_FROM
apply charset-hooks to fromcode
Definition: charset.h:74
#define mutt_ch_is_us_ascii(str)
Definition: charset.h:99
#define MUTT_ICONV_NO_FLAGS
No flags are set.
Definition: charset.h:73
#define ICONV_ILLEGAL_SEQ
Error value for iconv() - Illegal sequence.
Definition: charset.h:105
static bool iconv_t_valid(const iconv_t cd)
Is the conversion descriptor valid?
Definition: charset.h:114
Convenience wrapper for the library headers.
struct Slist * slist_parse(const char *str, uint32_t flags)
Parse a list of strings into a list.
Definition: slist.c:175
bool slist_is_empty(const struct Slist *list)
Is the slist empty?
Definition: slist.c:138
void slist_free(struct Slist **ptr)
Free an Slist object.
Definition: slist.c:122
char * mutt_strn_dup(const char *begin, size_t len)
Duplicate a sub-string.
Definition: string.c:380
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:672
size_t mutt_str_lws_len(const char *s, size_t n)
Measure the linear-white-space at the beginning of a string.
Definition: string.c:628
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
Definition: string.c:425
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
regmatch_t * mutt_prex_capture(enum Prex which, const char *str)
Match a precompiled regex against a string.
Definition: prex.c:296
@ PREX_RFC2047_ENCODED_WORD_MATCH_ENCODING
=?utf-8?[Q]?=E8=81...?=
Definition: prex.h:98
@ PREX_RFC2047_ENCODED_WORD_MATCH_TEXT
=?utf-8?Q?[=E8=81...]?=
Definition: prex.h:99
@ PREX_RFC2047_ENCODED_WORD_MATCH_CHARSET
=?[utf-8]?Q?=E8=81...?=
Definition: prex.h:97
@ PREX_RFC2047_ENCODED_WORD_MATCH_FULL
[=?utf-8?Q?=E8=81...?=]
Definition: prex.h:96
@ PREX_RFC2047_ENCODED_WORD
[=?utf-8?Q?=E8=81=AA=E6=98=8E=E7=9A=84?=]
Definition: prex.h:36
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
static size_t mutt_regmatch_len(const regmatch_t *match)
Return the length of a match.
Definition: regex3.h:76
static regoff_t mutt_regmatch_start(const regmatch_t *match)
Return the start of a match.
Definition: regex3.h:56
#define CONTINUATION_BYTE(ch)
Definition: rfc2047.c:52
void rfc2047_encode_addrlist(struct AddressList *al, const char *tag)
Encode any RFC2047 headers, where required, in an Address list.
Definition: rfc2047.c:766
void rfc2047_encode(char **pd, const char *specials, int col, const struct Slist *charsets)
RFC-2047-encode a string.
Definition: rfc2047.c:628
static size_t choose_block(char *d, size_t dlen, int col, const char *fromcode, const char *tocode, encoder_t *encoder, size_t *wlen)
Calculate how much data can be converted.
Definition: rfc2047.c:311
#define ENCWORD_LEN_MIN
Definition: rfc2047.c:48
void rfc2047_decode_envelope(struct Envelope *env)
Decode the fields of an Envelope.
Definition: rfc2047.c:832
static char * parse_encoded_word(char *str, enum ContentEncoding *enc, char **charset, size_t *charsetlen, char **text, size_t *textlen)
Parse a string and report RFC2047 elements.
Definition: rfc2047.c:148
size_t(* encoder_t)(char *res, const char *buf, size_t buflen, const char *tocode)
Definition: rfc2047.c:65
void rfc2047_decode(char **pd)
Decode any RFC2047-encoded header fields.
Definition: rfc2047.c:661
static size_t encode_block(char *str, char *buf, size_t buflen, const char *fromcode, const char *tocode, encoder_t encoder)
Encode a block of text using an encoder.
Definition: rfc2047.c:274
static char * decode_word(const char *s, size_t len, enum ContentEncoding enc)
Decode an RFC2047-encoded string.
Definition: rfc2047.c:365
void rfc2047_decode_addrlist(struct AddressList *al)
Decode any RFC2047 headers in an Address list.
Definition: rfc2047.c:801
void rfc2047_encode_envelope(struct Envelope *env)
Encode the fields of an Envelope.
Definition: rfc2047.c:857
static int encode(const char *d, size_t dlen, int col, const char *fromcode, const struct Slist *charsets, char **e, size_t *elen, const char *specials)
RFC2047-encode a string.
Definition: rfc2047.c:426
#define HSPACE(ch)
Definition: rfc2047.c:50
#define ENCWORD_LEN_MAX
Definition: rfc2047.c:47
static size_t try_block(const char *d, size_t dlen, const char *fromcode, const char *tocode, encoder_t *encoder, size_t *wlen)
Attempt to convert a block of text.
Definition: rfc2047.c:191
static void finalize_chunk(struct Buffer *res, struct Buffer *buf, char *charset, size_t charsetlen)
Perform charset conversion and filtering.
Definition: rfc2047.c:341
RFC2047 MIME extensions encoding / decoding routines.
#define ASSERT(COND)
Definition: signal2.h:58
An email address.
Definition: address.h:36
struct Buffer * personal
Real name of address.
Definition: address.h:37
bool group
Group mailbox?
Definition: address.h:39
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
String manipulation buffer.
Definition: buffer.h:36
char * data
Pointer to data.
Definition: buffer.h:37
The header of an Email.
Definition: envelope.h:57
struct AddressList return_path
Return path for the Email.
Definition: envelope.h:58
char *const subject
Email's subject.
Definition: envelope.h:70
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
struct AddressList reply_to
Email's 'reply-to'.
Definition: envelope.h:64
struct AddressList mail_followup_to
Email's 'mail-followup-to'.
Definition: envelope.h:65
struct AddressList cc
Email's 'Cc' list.
Definition: envelope.h:61
struct AddressList sender
Email's sender.
Definition: envelope.h:63
struct AddressList bcc
Email's 'Bcc' list.
Definition: envelope.h:62
char * x_label
X-Label.
Definition: envelope.h:76
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
String list.
Definition: slist.h:37
size_t count
Number of values in list.
Definition: slist.h:39
#define D_SLIST_SEP_COLON
Slist items are colon-separated.
Definition: types.h:112