rfc2231.c File Reference

RFC2231 MIME Charset routines. More...

#include "config.h"
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "rfc2231.h"
#include "mime.h"
#include "parameter.h"
#include "rfc2047.h"

Include dependency graph for rfc2231.c:

Go to the source code of this file.

Data Structures
struct	Rfc2231Parameter
	MIME section parameter. More...

Functions
static void	purge_empty_parameters (struct ParameterList *pl)
	Remove any ill-formed Parameters from a list. More...
static char *	get_charset (char *value, char *charset, size_t chslen)
	Get the charset from an RFC2231 header. More...
static void	decode_one (char *dest, char *src)
	Decode one percent-encoded character. More...
static struct Rfc2231Parameter *	parameter_new (void)
	Create a new Rfc2231Parameter. More...
static void	list_insert (struct Rfc2231Parameter **list, struct Rfc2231Parameter *par)
	Insert parameter into an ordered list. More...
static void	parameter_free (struct Rfc2231Parameter **p)
	Free an Rfc2231Parameter. More...
static void	join_continuations (struct ParameterList *pl, struct Rfc2231Parameter *par)
	Process continuation parameters. More...
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.c.

Function Documentation

purge_empty_parameters()

static void purge_empty_parameters ( struct ParameterList *  pl )

static

Remove any ill-formed Parameters from a list.

Parameters

pl	Parameter List to check

Definition at line 64 of file rfc2231.c.

{
  struct Parameter *np = NULL, *tmp = NULL;
  TAILQ_FOREACH_SAFE(np, pl, entries, tmp)
  {
    if (!np->attribute || !np->value)
    {
      TAILQ_REMOVE(pl, np, entries);
      mutt_param_free_one(&np);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_charset()

static char * get_charset ( char *  value, char *  charset, size_t  chslen  )

static

Get the charset from an RFC2231 header.

Parameters

value	Header string
charset	Buffer for the result
chslen	Length of buffer

Return values

ptr	First character after charset

Definition at line 84 of file rfc2231.c.

{
  char *t = strchr(value, '\'');
  if (!t)
  {
    charset[0] = '\0';
    return value;
  }
 
  *t = '\0';
  mutt_str_copy(charset, value, chslen);
 
  char *u = strchr(t + 1, '\'');
  if (u)
    return u + 1;
  return t + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_one()

static void decode_one ( char *  dest, char *  src  )

static

Decode one percent-encoded character.

Parameters

[out]	dest	Where to save the result
[in]	src	Source string

Definition at line 107 of file rfc2231.c.

{
  char *d = NULL;
 
  for (d = dest; *src; src++)
  {
    if ((src[0] == '%') && isxdigit((unsigned char) src[1]) &&
        isxdigit((unsigned char) src[2]))
    {
      *d++ = (hexval(src[1]) << 4) | hexval(src[2]);
      src += 2;
    }
    else
      *d++ = *src;
  }
 
  *d = '\0';
}

Here is the caller graph for this function:

parameter_new()

static struct Rfc2231Parameter * parameter_new ( void  )

static

Create a new Rfc2231Parameter.

Return values

ptr	Newly allocated Rfc2231Parameter

Definition at line 130 of file rfc2231.c.

{
  return mutt_mem_calloc(1, sizeof(struct Rfc2231Parameter));
}

Here is the call graph for this function:

Here is the caller graph for this function:

list_insert()

static void list_insert ( struct Rfc2231Parameter **  list, struct Rfc2231Parameter *  par  )

static

Insert parameter into an ordered list.

Parameters

[out]	list	List to insert into
[in]	par	Parameter to insert

Primary sorting key: attribute Secondary sorting key: index

Definition at line 143 of file rfc2231.c.

{
  struct Rfc2231Parameter **last = list;
  struct Rfc2231Parameter *p = *list;
 
  while (p)
  {
    const int c = strcmp(par->attribute, p->attribute);
    if ((c < 0) || ((c == 0) && (par->index <= p->index)))
      break;
 
    last = &p->next;
    p = p->next;
  }
 
  par->next = p;
  *last = par;
}

Here is the caller graph for this function:

parameter_free()

static void parameter_free ( struct Rfc2231Parameter **  p )

static

Free an Rfc2231Parameter.

Parameters

[out]

p

Rfc2231Parameter to free

Definition at line 166 of file rfc2231.c.

{
  if (!p || !*p)
    return;
 
  FREE(&(*p)->attribute);
  FREE(&(*p)->value);
  FREE(p);
}

Here is the caller graph for this function:

join_continuations()

static void join_continuations ( struct ParameterList *  pl, struct Rfc2231Parameter *  par  )

static

Process continuation parameters.

Parameters

pl	Parameter List for the results
par	Continuation Parameter

Definition at line 181 of file rfc2231.c.

{
  char attribute[256] = { 0 };
  char charset[256] = { 0 };
 
  while (par)
  {
    char *value = NULL;
    size_t l = 0;
 
    mutt_str_copy(attribute, par->attribute, sizeof(attribute));
 
    const bool encoded = par->encoded;
    char *valp = NULL;
    if (encoded)
      valp = get_charset(par->value, charset, sizeof(charset));
    else
      valp = par->value;
 
    do
    {
      if (encoded && par->encoded)
        decode_one(par->value, valp);
 
      const size_t vl = strlen(par->value);
 
      mutt_mem_realloc(&value, l + vl + 1);
      strcpy(value + l, par->value);
      l += vl;
 
      struct Rfc2231Parameter *q = par->next;
      parameter_free(&par);
      par = q;
      if (par)
        valp = par->value;
    } while (par && (strcmp(par->attribute, attribute) == 0));
 
    const char *const c_charset = cs_subset_string(NeoMutt->sub, "charset");
    if (encoded)
    {
      mutt_ch_convert_string(&value, charset, c_charset, MUTT_ICONV_HOOK_FROM);
      mutt_mb_filter_unprintable(&value);
    }
 
    struct Parameter *np = mutt_param_new();
    np->attribute = mutt_str_dup(attribute);
    np->value = value;
    TAILQ_INSERT_HEAD(pl, np, entries);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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)
      {
        const char *const c_charset = cs_subset_string(NeoMutt->sub, "charset");
        mutt_ch_convert_nonmime_string(c_assumed_charset, c_charset, &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 349 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: