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

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

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]

pd

String 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 665 of file rfc2047.c.

{
  if (!pd || !*pd)
    return;
 
  struct Buffer *buf = buf_pool_get();  // Output buffer
  char *s = *pd;                        // Read pointer
  char *beg = NULL;                     // Begin of encoded word
  enum ContentEncoding enc = ENC_OTHER; // ENC_BASE64 or ENC_QUOTED_PRINTABLE
  char *charset = NULL;                 // Which charset
  size_t charsetlen;                    // Length of the charset
  char *text = NULL;                    // Encoded text
  size_t textlen = 0;                   // Length of encoded text
 
  /* Keep some state in case the next decoded word is using the same charset
   * and it happens to be split in the middle of a multibyte character.
   * See https://github.com/neomutt/neomutt/issues/1015 */
  struct Buffer *prev = buf_pool_get(); /* Previously decoded word  */
  char *prev_charset = NULL;  /* Previously used charset                */
  size_t prev_charsetlen = 0; /* Length of the previously used charset  */
 
  const struct Slist *c_assumed_charset = cc_assumed_charset();
  const char *c_charset = cc_charset();
  while (*s)
  {
    beg = parse_encoded_word(s, &enc, &charset, &charsetlen, &text, &textlen);
    if (beg != s)
    {
      /* Some non-encoded text was found */
      size_t holelen = beg ? beg - s : mutt_str_len(s);
 
      /* Ignore whitespace between encoded words */
      if (beg && (mutt_str_lws_len(s, holelen) == holelen))
      {
        s = beg;
        continue;
      }
 
      /* If we have some previously decoded text, add it now */
      if (!buf_is_empty(prev))
      {
        finalize_chunk(buf, prev, prev_charset, prev_charsetlen);
      }
 
      /* Add non-encoded part */
      if (slist_is_empty(c_assumed_charset))
      {
        buf_addstr_n(buf, s, holelen);
      }
      else
      {
        char *conv = mutt_strn_dup(s, holelen);
        mutt_ch_convert_nonmime_string(c_assumed_charset, c_charset, &conv);
        buf_addstr(buf, conv);
        FREE(&conv);
      }
      s += holelen;
    }
    if (beg)
    {
      /* Some encoded text was found */
      text[textlen] = '\0';
      char *decoded = decode_word(text, textlen, enc);
      if (!decoded)
      {
        goto done;
      }
      if (!buf_is_empty(prev) && ((prev_charsetlen != charsetlen) ||
                                  !mutt_strn_equal(prev_charset, charset, charsetlen)))
      {
        /* Different charset, convert the previous chunk and add it to the
         * final result */
        finalize_chunk(buf, prev, prev_charset, prev_charsetlen);
      }
 
      buf_addstr(prev, decoded);
      FREE(&decoded);
      prev_charset = charset;
      prev_charsetlen = charsetlen;
      s = text + textlen + 2; /* Skip final ?= */
    }
  }
 
  /* Save the last chunk */
  if (!buf_is_empty(prev))
  {
    finalize_chunk(buf, prev, prev_charset, prev_charsetlen);
  }
 
  FREE(pd);
  *pd = buf_strdup(buf);
 
done:
  buf_pool_release(&buf);
  buf_pool_release(&prev);
}

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]	pd	String to be encoded, and resulting encoded string
[in]	specials	Special characters to be encoded
[in]	col	Starting index in string
[in]	charsets	List of charsets to choose from

Definition at line 632 of file rfc2047.c.

{
  if (!pd || !*pd)
    return;
 
  const char *const c_charset = cc_charset();
  if (!c_charset)
    return;
 
  struct Slist *fallback = NULL;
  if (!charsets)
  {
    fallback = slist_parse("utf-8", D_SLIST_SEP_COLON);
    charsets = fallback;
  }
 
  char *e = NULL;
  size_t elen = 0;
  encode(*pd, strlen(*pd), col, c_charset, charsets, &e, &elen, specials);
 
  slist_free(&fallback);
  FREE(pd);
  *pd = e;
}

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

al	AddressList

Note

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

Definition at line 805 of file rfc2047.c.

{
  if (!al)
    return;
 
  const bool assumed = !slist_is_empty(cc_assumed_charset());
  struct Address *a = NULL;
  char *data = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    if (a->personal && ((buf_find_string(a->personal, "=?")) || assumed))
    {
      data = buf_strdup(a->personal);
      rfc2047_decode(&data);
      buf_strcpy(a->personal, data);
      FREE(&data);
    }
    else if (a->group && a->mailbox && buf_find_string(a->mailbox, "=?"))
    {
      data = buf_strdup(a->mailbox);
      rfc2047_decode(&data);
      buf_strcpy(a->mailbox, data);
      FREE(&data);
    }
  }
}

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

al	AddressList
tag	Header 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 770 of file rfc2047.c.

{
  if (!al)
    return;
 
  int col = tag ? strlen(tag) + 2 : 32;
  struct Address *a = NULL;
  char *data = NULL;
  const struct Slist *const c_send_charset = cs_subset_slist(NeoMutt->sub, "send_charset");
  TAILQ_FOREACH(a, al, entries)
  {
    if (a->personal)
    {
      data = buf_strdup(a->personal);
      rfc2047_encode(&data, AddressSpecials, col, c_send_charset);
      buf_strcpy(a->personal, data);
      FREE(&data);
    }
    else if (a->group && a->mailbox)
    {
      data = buf_strdup(a->mailbox);
      rfc2047_encode(&data, AddressSpecials, col, c_send_charset);
      buf_strcpy(a->mailbox, data);
      FREE(&data);
    }
  }
}

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

env

Envelope

Definition at line 836 of file rfc2047.c.

{
  if (!env)
    return;
  rfc2047_decode_addrlist(&env->from);
  rfc2047_decode_addrlist(&env->to);
  rfc2047_decode_addrlist(&env->cc);
  rfc2047_decode_addrlist(&env->bcc);
  rfc2047_decode_addrlist(&env->reply_to);
  rfc2047_decode_addrlist(&env->mail_followup_to);
  rfc2047_decode_addrlist(&env->return_path);
  rfc2047_decode_addrlist(&env->sender);
  rfc2047_decode(&env->x_label);
 
  char *subj = env->subject;
  *(char **) &env->subject = NULL;
  rfc2047_decode(&subj);
  mutt_env_set_subject(env, subj);
  FREE(&subj);
}

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

env

Envelope

Definition at line 861 of file rfc2047.c.

{
  if (!env)
    return;
  rfc2047_encode_addrlist(&env->from, "From");
  rfc2047_encode_addrlist(&env->to, "To");
  rfc2047_encode_addrlist(&env->cc, "Cc");
  rfc2047_encode_addrlist(&env->bcc, "Bcc");
  rfc2047_encode_addrlist(&env->reply_to, "Reply-To");
  rfc2047_encode_addrlist(&env->mail_followup_to, "Mail-Followup-To");
  rfc2047_encode_addrlist(&env->sender, "Sender");
  const struct Slist *const c_send_charset = cs_subset_slist(NeoMutt->sub, "send_charset");
  rfc2047_encode(&env->x_label, NULL, sizeof("X-Label:"), c_send_charset);
 
  char *subj = env->subject;
  *(char **) &env->subject = NULL;
  rfc2047_encode(&subj, NULL, sizeof("Subject:"), c_send_charset);
  mutt_env_set_subject(env, subj);
  FREE(&subj);
}

Here is the call graph for this function:

Here is the caller graph for this function: