rfc2231.h File Reference

RFC2231 MIME Charset routines. More...

#include <stddef.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...
size_t	rfc2231_encode_string (struct ParameterList *head, const char *attribute, char *value)
	Encode a string to be suitable for an RFC2231 header. 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 236 of file rfc2231.c.

{
  if (!pl)
    return;
 
  struct Rfc2231Parameter *conthead = NULL;
  struct Rfc2231Parameter *conttmp = NULL;
 
  char *s = NULL, *t = NULL;
  char charset[256] = { 0 };
 
  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)
  {
    /* Single value, non encoded:
     *   attr=value
     */
    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.  */
 
      const bool c_rfc2047_parameters = cs_subset_bool(NeoMutt->sub, "rfc2047_parameters");
      const struct Slist *const c_assumed_charset = cs_subset_slist(NeoMutt->sub, "assumed_charset");
      if (c_rfc2047_parameters && np->value && strstr(np->value, "=?"))
        rfc2047_decode(&np->value);
      else if (c_assumed_charset)
        mutt_ch_convert_nonmime_string(&np->value);
    }
    /* Single value with encoding:
     *   attr*=us-ascii''the%20value
     */
    else if (s[1] == '\0')
    {
      s[0] = '\0';
 
      s = get_charset(np->value, charset, sizeof(charset));
      decode_one(np->value, s);
      const char *const c_charset = cs_subset_string(NeoMutt->sub, "charset");
      mutt_ch_convert_string(&np->value, charset, c_charset, MUTT_ICONV_HOOK_FROM);
      mutt_mb_filter_unprintable(&np->value);
      dirty = true;
    }
    /* A parameter continuation, which may or may not be encoded:
     *   attr*0=value
     *     -or-
     *   attr*0*=us-ascii''the%20value
     */
    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++)
        ; // do nothing
 
      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_full(s, &index))
        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()

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

Encode a string to be suitable for an RFC2231 header.

Parameters

head	String encoded as a ParameterList, empty on error
attribute	Name of attribute to encode
value	Value of attribute to encode

Return values

num	Number of Parameters in the List

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

Definition at line 344 of file rfc2231.c.

{
  if (!attribute || !value)
    return 0;
 
  size_t count = 0;
  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)
  {
    const char *const c_charset = cs_subset_string(NeoMutt->sub, "charset");
    const struct Slist *const c_send_charset = cs_subset_slist(NeoMutt->sub, "send_charset");
    if (c_charset && c_send_charset)
    {
      charset = mutt_ch_choose(c_charset, c_send_charset, value,
                               mutt_str_len(value), &src_value, NULL);
    }
    if (src_value)
      free_src_value = true;
    if (!charset)
      charset = mutt_str_dup(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_len(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_len(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(head, current, entries);
    count++;
 
    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 count;
}

Here is the call graph for this function:

Here is the caller graph for this function: