NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
rfc2047.h File Reference

RFC2047 MIME extensions encoding / decoding routines. More...

+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void rfc2047_decode (char **pd)
 Decode any RFC2047-encoded header fields.
 
void rfc2047_encode (char **pd, const char *specials, int col, const struct Slist *charsets)
 RFC-2047-encode a string.
 
void rfc2047_decode_addrlist (struct AddressList *al)
 Decode any RFC2047 headers in an Address list.
 
void rfc2047_encode_addrlist (struct AddressList *al, const char *tag)
 Encode any RFC2047 headers, where required, in an Address list.
 
void rfc2047_decode_envelope (struct Envelope *env)
 Decode the fields of an Envelope.
 
void rfc2047_encode_envelope (struct Envelope *env)
 Encode the fields of an Envelope.
 

Detailed Description

RFC2047 MIME extensions encoding / decoding routines.

Authors
  • Richard Russon
  • Pietro Cerutti

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file rfc2047.h.

Function Documentation

◆ rfc2047_decode()

void rfc2047_decode ( char **  pd)

Decode any RFC2047-encoded header fields.

Parameters
[in,out]pdString to be decoded, and resulting decoded string

Try to decode anything that looks like a valid RFC2047 encoded header field, ignoring RFC822 parsing rules. If decoding fails, for example due to an invalid base64 string, the original input is left untouched.

Definition at line 661 of file rfc2047.c.

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}
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
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:571
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
#define FREE(x)
Definition: memory.h:45
ContentEncoding
Content-Transfer-Encoding.
Definition: mime.h:47
@ ENC_OTHER
Encoding unknown.
Definition: mime.h:48
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
bool slist_is_empty(const struct Slist *list)
Is the slist empty?
Definition: slist.c:138
char * mutt_strn_dup(const char *begin, size_t len)
Duplicate a sub-string.
Definition: string.c:380
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
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
static char * decode_word(const char *s, size_t len, enum ContentEncoding enc)
Decode an RFC2047-encoded string.
Definition: rfc2047.c:365
static void finalize_chunk(struct Buffer *res, struct Buffer *buf, char *charset, size_t charsetlen)
Perform charset conversion and filtering.
Definition: rfc2047.c:341
String manipulation buffer.
Definition: buffer.h:36
String list.
Definition: slist.h:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ rfc2047_encode()

void rfc2047_encode ( char **  pd,
const char *  specials,
int  col,
const struct Slist charsets 
)

RFC-2047-encode a string.

Parameters
[in,out]pdString to be encoded, and resulting encoded string
[in]specialsSpecial characters to be encoded
[in]colStarting index in string
[in]charsetsList of charsets to choose from

Definition at line 628 of file rfc2047.c.

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}
struct Slist * slist_parse(const char *str, uint32_t flags)
Parse a list of strings into a list.
Definition: slist.c:175
void slist_free(struct Slist **ptr)
Free an Slist object.
Definition: slist.c:122
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 D_SLIST_SEP_COLON
Slist items are colon-separated.
Definition: types.h:112
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ rfc2047_decode_addrlist()

void rfc2047_decode_addrlist ( struct AddressList *  al)

Decode any RFC2047 headers in an Address list.

Parameters
alAddressList
Note
rfc2047_decode() may realloc the data pointer it's given, so work on a copy to avoid breaking the Buffer

Definition at line 801 of file rfc2047.c.

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}
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
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
void rfc2047_decode(char **pd)
Decode any RFC2047-encoded header fields.
Definition: rfc2047.c:661
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
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ rfc2047_encode_addrlist()

void rfc2047_encode_addrlist ( struct AddressList *  al,
const char *  tag 
)

Encode any RFC2047 headers, where required, in an Address list.

Parameters
alAddressList
tagHeader tag (used for wrapping calculation)
Note
rfc2047_encode() may realloc the data pointer it's given, so work on a copy to avoid breaking the Buffer

Definition at line 766 of file rfc2047.c.

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}
const char AddressSpecials[]
Characters with special meaning for email addresses.
Definition: address.c:45
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
void rfc2047_encode(char **pd, const char *specials, int col, const struct Slist *charsets)
RFC-2047-encode a string.
Definition: rfc2047.c:628
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ rfc2047_decode_envelope()

void rfc2047_decode_envelope ( struct Envelope env)

Decode the fields of an Envelope.

Parameters
envEnvelope

Definition at line 832 of file rfc2047.c.

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}
void mutt_env_set_subject(struct Envelope *env, const char *subj)
Set both subject and real_subj to subj.
Definition: envelope.c:69
void rfc2047_decode_addrlist(struct AddressList *al)
Decode any RFC2047 headers in an Address list.
Definition: rfc2047.c:801
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
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ rfc2047_encode_envelope()

void rfc2047_encode_envelope ( struct Envelope env)

Encode the fields of an Envelope.

Parameters
envEnvelope

Definition at line 857 of file rfc2047.c.

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}
void rfc2047_encode_addrlist(struct AddressList *al, const char *tag)
Encode any RFC2047 headers, where required, in an Address list.
Definition: rfc2047.c:766
+ Here is the call graph for this function:
+ Here is the caller graph for this function: