rfc2231.h File Reference

RFC2231 MIME Charset routines. More...

#include <stdbool.h>

Include dependency graph for rfc2231.h:

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

Go to the source code of this file.

Functions
void	rfc2231_decode_parameters (struct ParameterList *pl)
	Decode a Parameter list. More...
struct ParameterList	rfc2231_encode_string (const char *attribute, char *value)
	Encode a string to be suitable for an RFC2231 header. More...

Variables
bool	C_Rfc2047Parameters
	Config: Decode RFC2047-encoded MIME parameters. More...

Detailed Description

RFC2231 MIME Charset routines.

Authors

• Thomas Roessler

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 rfc2231.h.

Function Documentation

rfc2231_decode_parameters()

void rfc2231_decode_parameters

(

struct ParameterList *

pl

)

Decode a Parameter list.

Parameters

pl	List to decode

Definition at line 235 of file rfc2231.c.

{
  if (!pl)
    return;

  struct Rfc2231Parameter *conthead = NULL;
  struct Rfc2231Parameter *conttmp = NULL;

  char *s = NULL, *t = NULL;
  char charset[256];

  bool encoded;
  int index;
  bool dirty = false; /* set when we may have created empty parameters. */

  purge_empty_parameters(pl);

  struct Parameter *np = NULL, *tmp = NULL;
  TAILQ_FOREACH_SAFE(np, pl, entries, tmp)
  {
    s = strchr(np->attribute, '*');
    if (!s)
    {
      /* Using RFC2047 encoding in MIME parameters is explicitly
       * forbidden by that document.  Nevertheless, it's being
       * generated by some software, including certain Lotus Notes to
       * Internet Gateways.  So we actually decode it.  */

      if (C_Rfc2047Parameters && np->value && strstr(np->value, "=?"))
        rfc2047_decode(&np->value);
      else if (C_AssumedCharset)
        mutt_ch_convert_nonmime_string(&np->value);
    }
    else if (s[1] == '\0')
    {
      s[0] = '\0';

      s = get_charset(np->value, charset, sizeof(charset));
      decode_one(np->value, s);
      mutt_ch_convert_string(&np->value, charset, C_Charset, MUTT_ICONV_HOOK_FROM);
      mutt_mb_filter_unprintable(&np->value);
      dirty = true;
    }
    else
    {
      s[0] = '\0';
      s++; /* let s point to the first character of index. */
      for (t = s; (t[0] != '\0') && isdigit((unsigned char) t[0]); t++)
        ;
      encoded = (t[0] == '*');
      t[0] = '\0';

      /* RFC2231 says that the index starts at 0 and increments by 1,
       * thus an overflow should never occur in a valid message, thus
       * the value INT_MAX in case of overflow does not really matter
       * (the goal is just to avoid undefined behaviour). */
      if (mutt_str_atoi(s, &index) != 0)
        index = INT_MAX;

      conttmp = parameter_new();
      conttmp->attribute = np->attribute;
      conttmp->value = np->value;
      conttmp->encoded = encoded;
      conttmp->index = index;

      np->attribute = NULL;
      np->value = NULL;
      TAILQ_REMOVE(pl, np, entries);
      FREE(&np);

      list_insert(&conthead, conttmp);
    }
  }

  if (conthead)
  {
    join_continuations(pl, conthead);
    dirty = true;
  }

  if (dirty)
    purge_empty_parameters(pl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rfc2231_encode_string()

struct ParameterList rfc2231_encode_string	(	const char *	attribute,
		char *	value
	)

Encode a string to be suitable for an RFC2231 header.

Parameters

attribute	Name of attribute to encode
value	Value of attribute to encode

Return values

obj	String encoded as a ParameterList
obj	Error: empty object

If the value is large, the list will contain continuation lines.

Definition at line 328 of file rfc2231.c.

{
  struct ParameterList pl;
  TAILQ_INIT(&pl);

  if (!attribute || !value)
    return pl;

  bool encode = false;
  bool add_quotes = false;
  bool free_src_value = false;
  bool split = false;
  int continuation_number = 0;
  size_t dest_value_len = 0, max_value_len = 0, cur_value_len = 0;
  char *cur = NULL, *charset = NULL, *src_value = NULL;
  struct Parameter *current = NULL;

  struct Buffer *cur_attribute = mutt_buffer_pool_get();
  struct Buffer *cur_value = mutt_buffer_pool_get();

  // Perform charset conversion
  for (cur = value; *cur; cur++)
  {
    if ((*cur < 0x20) || (*cur >= 0x7f))
    {
      encode = true;
      break;
    }
  }

  if (encode)
  {
    if (C_Charset && C_SendCharset)
    {
      charset = mutt_ch_choose(C_Charset, C_SendCharset, value,
                               mutt_str_strlen(value), &src_value, NULL);
    }
    if (src_value)
      free_src_value = true;
    if (!charset)
      charset = mutt_str_strdup(C_Charset ? C_Charset : "unknown-8bit");
  }
  if (!src_value)
    src_value = value;

  // Count the size the resultant value will need in total
  if (encode)
    dest_value_len = mutt_str_strlen(charset) + 2; /* charset'' prefix */

  for (cur = src_value; *cur; cur++)
  {
    dest_value_len++;

    if (encode)
    {
      /* These get converted to %xx so need a total of three chars */
      if ((*cur < 0x20) || (*cur >= 0x7f) || strchr(MimeSpecials, *cur) ||
          strchr("*'%", *cur))
      {
        dest_value_len += 2;
      }
    }
    else
    {
      /* rfc822_cat() will add outer quotes if it finds MimeSpecials. */
      if (!add_quotes && strchr(MimeSpecials, *cur))
        add_quotes = true;
      /* rfc822_cat() will add a backslash if it finds '\' or '"'. */
      if ((*cur == '\\') || (*cur == '"'))
        dest_value_len++;
    }
  }

  // Determine if need to split into parameter value continuations
  max_value_len = 78 - // rfc suggested line length
                  1 -  // Leading tab on continuation line
                  mutt_str_strlen(attribute) - // attribute
                  (encode ? 1 : 0) -           // '*' encoding marker
                  1 -                          // '='
                  (add_quotes ? 2 : 0) -       // "...."
                  1;                           // ';'

  if (max_value_len < 30)
    max_value_len = 30;

  if (dest_value_len > max_value_len)
  {
    split = true;
    max_value_len -= 4; /* '*n' continuation number and extra encoding
                         * space to keep loop below simpler */
  }

  // Generate list of parameter continuations
  cur = src_value;
  if (encode)
  {
    mutt_buffer_printf(cur_value, "%s''", charset);
    cur_value_len = mutt_buffer_len(cur_value);
  }

  while (*cur)
  {
    current = mutt_param_new();
    TAILQ_INSERT_TAIL(&pl, current, entries);

    mutt_buffer_strcpy(cur_attribute, attribute);
    if (split)
      mutt_buffer_add_printf(cur_attribute, "*%d", continuation_number++);
    if (encode)
      mutt_buffer_addch(cur_attribute, '*');

    while (*cur && (!split || (cur_value_len < max_value_len)))
    {
      if (encode)
      {
        if ((*cur < 0x20) || (*cur >= 0x7f) || strchr(MimeSpecials, *cur) ||
            strchr("*'%", *cur))
        {
          mutt_buffer_add_printf(cur_value, "%%%02X", (unsigned char) *cur);
          cur_value_len += 3;
        }
        else
        {
          mutt_buffer_addch(cur_value, *cur);
          cur_value_len++;
        }
      }
      else
      {
        mutt_buffer_addch(cur_value, *cur);
        cur_value_len++;
        if ((*cur == '\\') || (*cur == '"'))
          cur_value_len++;
      }

      cur++;
    }

    current->attribute = mutt_buffer_strdup(cur_attribute);
    current->value = mutt_buffer_strdup(cur_value);

    mutt_buffer_reset(cur_value);
    cur_value_len = 0;
  }

  mutt_buffer_pool_release(&cur_attribute);
  mutt_buffer_pool_release(&cur_value);

  FREE(&charset);
  if (free_src_value)
    FREE(&src_value);

  return pl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

C_Rfc2047Parameters

bool C_Rfc2047Parameters

Config: Decode RFC2047-encoded MIME parameters.

Definition at line 49 of file rfc2231.c.