parse.h File Reference

Miscellaneous email parsing routines. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "mime.h"

Include dependency graph for parse.h:

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

Go to the source code of this file.

Data Structures
struct	Rfc2369ListHeaders
	Mailing-list actions from RFC 2369 headers. More...

Functions
int	mutt_check_encoding (const char *c)
	Check the encoding type.
enum ContentType	mutt_check_mime_type (const char *s)
	Check a MIME type string.
char *	mutt_extract_message_id (const char *s, size_t *len)
	Find a Message-ID.
bool	mutt_is_message_type (int type, const char *subtype)
	Determine if a mime type matches a message or not.
bool	mutt_matches_ignore (const char *s)
	Does the string match the ignore list.
void	mutt_parse_content_type (const char *s, struct Body *b)
	Parse a content type.
bool	mutt_parse_mailto (struct Envelope *env, char **body, const char *src)
	Parse a mailto:// url.
size_t	mutt_rfc2369_parse (const char *body, struct ListHead *links)
	Extract URLs from an RFC 2369 list header.
char *	mutt_rfc2369_first_mailto (const char *body)
	Extract the first mailto: URL from an RFC 2369 list.
void	mutt_rfc2369_list_headers_free (struct Rfc2369ListHeaders *headers)
	Free RFC 2369 mailing-list header values.
void	mutt_rfc2369_read_headers (FILE *fp, struct Rfc2369ListHeaders *headers)
	Read RFC 2369 mailing-list headers.
struct Body *	mutt_parse_multipart (FILE *fp, const char *boundary, LOFF_T end_off, bool digest)
	Parse a multipart structure.
void	mutt_parse_part (FILE *fp, struct Body *b)
	Parse a MIME part.
struct Body *	mutt_read_mime_header (FILE *fp, bool digest)
	Parse a MIME header.
int	mutt_rfc822_parse_line (struct Envelope *env, struct Email *e, const char *name, size_t name_len, const char *body, bool user_hdrs, bool weed, bool do_2047)
	Parse an email header.
struct Body *	mutt_rfc822_parse_message (FILE *fp, struct Body *b)
	Parse a Message/RFC822 body.
struct Envelope *	mutt_rfc822_read_header (FILE *fp, struct Email *e, bool user_hdrs, bool weed)
	Parses an RFC822 header.
size_t	mutt_rfc822_read_line (FILE *fp, struct Buffer *out)
	Read a header line from a file.
void	mutt_filter_commandline_header_tag (char *header)
	Sanitise characters in a header tag.
void	mutt_filter_commandline_header_value (char *header)
	Sanitise characters in a header value.

Detailed Description

Miscellaneous email parsing 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 parse.h.

Function Documentation

mutt_check_encoding()

int mutt_check_encoding

(

const char *

c

)

Check the encoding type.

Parameters

c	String to check

Return values

enum	ContentEncoding, e.g. ENC_QUOTED_PRINTABLE

Definition at line 404 of file parse.c.

{
  if (mutt_istr_startswith(c, "7bit"))
    return ENC_7BIT;
  if (mutt_istr_startswith(c, "8bit"))
    return ENC_8BIT;
  if (mutt_istr_startswith(c, "binary"))
    return ENC_BINARY;
  if (mutt_istr_startswith(c, "quoted-printable"))
    return ENC_QUOTED_PRINTABLE;
  if (mutt_istr_startswith(c, "base64"))
    return ENC_BASE64;
  if (mutt_istr_startswith(c, "x-uuencode"))
    return ENC_UUENCODED;
  if (mutt_istr_startswith(c, "uuencode"))
    return ENC_UUENCODED;
  return ENC_OTHER;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_check_mime_type()

enum ContentType mutt_check_mime_type

(

const char *

s

)

Check a MIME type string.

Parameters

s	String to check

Return values

enum	ContentType, e.g. TYPE_TEXT

Definition at line 333 of file parse.c.

{
  if (mutt_istr_equal("text", s))
    return TYPE_TEXT;
  if (mutt_istr_equal("multipart", s))
    return TYPE_MULTIPART;
  if (mutt_istr_equal("x-sun-attachment", s))
    return TYPE_MULTIPART;
  if (mutt_istr_equal("application", s))
    return TYPE_APPLICATION;
  if (mutt_istr_equal("message", s))
    return TYPE_MESSAGE;
  if (mutt_istr_equal("image", s))
    return TYPE_IMAGE;
  if (mutt_istr_equal("audio", s))
    return TYPE_AUDIO;
  if (mutt_istr_equal("video", s))
    return TYPE_VIDEO;
  if (mutt_istr_equal("model", s))
    return TYPE_MODEL;
  if (mutt_istr_equal("*", s))
    return TYPE_ANY;
  if (mutt_istr_equal(".*", s))
    return TYPE_ANY;
 
  return TYPE_OTHER;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_extract_message_id()

char * mutt_extract_message_id	(	const char *	s,
		size_t *	len )

Find a Message-ID.

Parameters

[in]	s	String to parse
[out]	len	Number of bytes of s parsed

Return values

ptr	Message id found
NULL	No more message ids

Definition at line 368 of file parse.c.

{
  if (!s || (*s == '\0'))
    return NULL;
 
  char *decoded = mutt_str_dup(s);
  rfc2047_decode(&decoded);
 
  char *res = NULL;
 
  for (const char *p = decoded, *beg = NULL; *p; p++)
  {
    if (*p == '<')
    {
      beg = p;
      continue;
    }
 
    if (beg && (*p == '>'))
    {
      if (len)
        *len = p - decoded + 1;
      res = mutt_strn_dup(beg, (p + 1) - beg);
      break;
    }
  }
 
  FREE(&decoded);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_is_message_type()

bool mutt_is_message_type	(	int	type,
		const char *	subtype )

Determine if a mime type matches a message or not.

Parameters

type	Message type enum value
subtype	Message subtype

Return values

true	Type is message/news or message/rfc822
false	Otherwise

Definition at line 1620 of file parse.c.

{
  if (type != TYPE_MESSAGE)
    return false;
 
  subtype = NONULL(subtype);
  return (mutt_istr_equal(subtype, "rfc822") ||
          mutt_istr_equal(subtype, "news") || mutt_istr_equal(subtype, "global"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_matches_ignore()

bool mutt_matches_ignore

(

const char *

s

)

Does the string match the ignore list.

Parameters

s	String to check

Return values

true	String matches

Checks ignore and unignore using mutt_list_match

Definition at line 320 of file parse.c.

{
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  return mutt_list_match(s, &mod_data->ignore) && !mutt_list_match(s, &mod_data->unignore);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_content_type()

void mutt_parse_content_type	(	const char *	s,
		struct Body *	b )

Parse a content type.

Parameters

s	String to parse
b	Body to save the result

WARNING: this function modifies the 's' argument to segregate type, subtype, and parametners, so, e.g., a param of "text/plain" will be changed into "text\0plain".

Definition at line 433 of file parse.c.

{
  if (!s || !b)
    return;
 
  FREE(&b->subtype);
  mutt_param_free(&b->parameter);
 
  /* First extract any existing parameters */
  char *pc = strchr(s, ';');
  if (pc)
  {
    *pc++ = 0;
    while (*pc && mutt_isspace(*pc))
      pc++;
    parse_parameters(&b->parameter, pc, false);
 
    /* Some pre-RFC1521 gateways still use the "name=filename" convention,
     * but if a filename has already been set in the content-disposition,
     * let that take precedence, and don't set it here */
    pc = mutt_param_get(&b->parameter, "name");
    if (pc && !b->filename)
      b->filename = mutt_str_dup(pc);
 
    /* this is deep and utter perversion */
    pc = mutt_param_get(&b->parameter, "conversions");
    if (pc)
      b->encoding = mutt_check_encoding(pc);
  }
 
  /* Now get the subtype */
  char *subtype = strchr(s, '/');
  if (subtype)
  {
    *subtype++ = '\0';
    for (pc = subtype; *pc && !mutt_isspace(*pc) && (*pc != ';'); pc++)
      ; // do nothing
 
    *pc = '\0';
    mutt_str_replace(&b->subtype, subtype);
  }
 
  /* Finally, get the major type */
  b->type = mutt_check_mime_type(s);
 
  if (mutt_istr_equal("x-sun-attachment", s))
    mutt_str_replace(&b->subtype, "x-sun-attachment");
 
  if (b->type == TYPE_OTHER)
  {
    mutt_str_replace(&b->xtype, s);
  }
 
  if (!b->subtype)
  {
    /* Some older non-MIME mailers (i.e., mailtool, elm) have a content-type
     * field, so we can attempt to convert the type to Body here.  */
    if (b->type == TYPE_TEXT)
    {
      b->subtype = mutt_str_dup("plain");
    }
    else if (b->type == TYPE_AUDIO)
    {
      b->subtype = mutt_str_dup("basic");
    }
    else if (b->type == TYPE_MESSAGE)
    {
      b->subtype = mutt_str_dup("rfc822");
    }
    else if (b->type == TYPE_OTHER)
    {
      char buf[128] = { 0 };
 
      b->type = TYPE_APPLICATION;
      snprintf(buf, sizeof(buf), "x-%s", s);
      b->subtype = mutt_str_dup(buf);
    }
    else
    {
      b->subtype = mutt_str_dup("x-unknown");
    }
  }
 
  /* Default character set for text types. */
  if (b->type == TYPE_TEXT)
  {
    pc = mutt_param_get(&b->parameter, "charset");
    if (pc)
    {
      /* Microsoft Outlook seems to think it is necessary to repeat
       * charset=, strip it off not to confuse ourselves */
      if (mutt_istrn_equal(pc, "charset=", sizeof("charset=") - 1))
        mutt_param_set(&b->parameter, "charset", pc + (sizeof("charset=") - 1));
    }
    else
    {
      mutt_param_set(&b->parameter, "charset",
                     mutt_ch_get_default_charset(cc_assumed_charset()));
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_mailto()

bool mutt_parse_mailto	(	struct Envelope *	env,
		char **	body,
		const char *	src )

Parse a mailto:// url.

Parameters

[in]	env	Envelope to fill
[out]	body	Body to
[in]	src	String to parse

Return values

true	Success
false	Error

Definition at line 1878 of file parse.c.

{
  if (!env || !src)
    return false;
 
  struct Url *url = url_parse(src);
  if (!url)
    return false;
 
  if (url->host)
  {
    /* this is not a path-only URL */
    url_free(&url);
    return false;
  }
 
  mutt_addrlist_parse(&env->to, url->path);
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  struct UrlQuery *np = NULL;
  STAILQ_FOREACH(np, &url->query_strings, entries)
  {
    mutt_filter_commandline_header_tag(np->name);
    const char *tag = np->name;
    char *value = np->value;
    /* Determine if this header field is on the allowed list.  Since NeoMutt
     * interprets some header fields specially (such as
     * "Attach: ~/.gnupg/secring.gpg"), care must be taken to ensure that
     * only safe fields are allowed.
     *
     * RFC2368, "4. Unsafe headers"
     * The user agent interpreting a mailto URL SHOULD choose not to create
     * a message if any of the headers are considered dangerous; it may also
     * choose to create a message with only a subset of the headers given in
     * the URL.  */
    if (mailto_header_allowed(tag, &mod_data->mail_to_allow))
    {
      if (mutt_istr_equal(tag, "body"))
      {
        if (body)
          mutt_str_replace(body, value);
      }
      else
      {
        char *scratch = NULL;
        size_t taglen = mutt_str_len(tag);
 
        mutt_filter_commandline_header_value(value);
        mutt_str_asprintf(&scratch, "%s: %s", tag, value);
        scratch[taglen] = 0; /* overwrite the colon as mutt_rfc822_parse_line expects */
        value = mutt_str_skip_email_wsp(&scratch[taglen + 1]);
        mutt_rfc822_parse_line(env, NULL, scratch, taglen, value, true, false, true);
        FREE(&scratch);
      }
    }
  }
 
  /* RFC2047 decode after the RFC822 parsing */
  rfc2047_decode_envelope(env);
 
  url_free(&url);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc2369_parse()

size_t mutt_rfc2369_parse	(	const char *	body,
		struct ListHead *	links )

Extract URLs from an RFC 2369 list header.

Parameters

body	Body of the header
links	List of extracted URLs

Return values

num	Number of URLs extracted

Definition at line 638 of file parse.c.

{
  if (!body || !links)
    return 0;
 
  if (!links->stqh_last)
    STAILQ_INIT(links);
 
  size_t count = 0;
  for (const char *beg = body; (beg = strchr(beg, '<')) != NULL; beg++)
  {
    beg++;
 
    const char *end = strchr(beg, '>');
    if (!end)
      break;
 
    if (end > beg)
    {
      mutt_list_insert_tail(links, mutt_strn_dup(beg, end - beg));
      count++;
    }
 
    beg = end;
  }
 
  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc2369_first_mailto()

char * mutt_rfc2369_first_mailto

(

const char *

body

)

Extract the first mailto: URL from an RFC 2369 list.

Parameters

body	Body of the header

Return values

ptr	First mailto: URL found, or NULL if none was found

Definition at line 672 of file parse.c.

{
  return rfc2369_first_value(body, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc2369_list_headers_free()

void mutt_rfc2369_list_headers_free

(

struct Rfc2369ListHeaders *

headers

)

Free RFC 2369 mailing-list header values.

Parameters

headers

Headers to free

Definition at line 704 of file parse.c.

{
  if (!headers)
    return;
 
  rfc2369_list_headers_ensure_init(headers);
 
  mutt_list_free(&headers->archive);
  mutt_list_free(&headers->help);
  mutt_list_free(&headers->owner);
  mutt_list_free(&headers->post);
  mutt_list_free(&headers->subscribe);
  mutt_list_free(&headers->unsubscribe);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc2369_read_headers()

void mutt_rfc2369_read_headers	(	FILE *	fp,
		struct Rfc2369ListHeaders *	headers )

Read RFC 2369 mailing-list headers.

Parameters

fp	Message stream positioned at the start of the headers
headers	Parsed header values

Definition at line 724 of file parse.c.

{
  if (!fp || !headers)
    return;
 
  rfc2369_list_headers_ensure_init(headers);
  mutt_rfc2369_list_headers_free(headers);
 
  struct Buffer *line = buf_pool_get();
  while (true)
  {
    size_t len = mutt_rfc822_read_line(fp, line);
    if ((len == 0) || buf_is_empty(line))
      break;
 
    const char *lines = buf_string(line);
    const char *p = strpbrk(lines, ": \t");
    if (!p || (*p != ':'))
    {
      time_t t = 0;
 
      /* Some MTAs quote the original mbox separator. */
      if (mutt_str_startswith(lines, ">From "))
        continue;
      if (is_from(lines, NULL, 0, &t))
        continue;
 
      break;
    }
 
    const size_t name_len = p - lines;
    const char *body = mutt_str_skip_whitespace(p + 1);
    if (*body == '\0')
      continue;
 
    struct ListHead *value = NULL;
    if ((name_len == 12) && eqi12(lines, "List-Archive"))
      value = &headers->archive;
    else if ((name_len == 9) && eqi9(lines, "List-Help"))
      value = &headers->help;
    else if ((name_len == 10) && eqi10(lines, "List-Owner"))
      value = &headers->owner;
    else if ((name_len == 9) && eqi9(lines, "List-Post"))
      value = &headers->post;
    else if ((name_len == 14) && eqi14(lines, "List-Subscribe"))
      value = &headers->subscribe;
    else if ((name_len == 16) && eqi16(lines, "List-Unsubscribe"))
      value = &headers->unsubscribe;
 
    if (!value)
      continue;
 
    mutt_list_free(value);
    mutt_rfc2369_parse(body, value);
  }
  buf_pool_release(&line);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_multipart()

struct Body * mutt_parse_multipart	(	FILE *	fp,
		const char *	boundary,
		LOFF_T	end_off,
		bool	digest )

Parse a multipart structure.

Parameters

fp	Stream to read from
boundary	Body separator
end_off	Length of the multipart body (used when the final boundary is missing to avoid reading too far)
digest	true if reading a multipart/digest

Return values

ptr	New Body containing parsed structure

Definition at line 1980 of file parse.c.

{
  int counter = 0;
 
  return parse_multipart(fp, boundary, end_off, digest, &counter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_part()

void mutt_parse_part	(	FILE *	fp,
		struct Body *	b )

Parse a MIME part.

Parameters

fp	File to read from
b	Body to store the results in

Definition at line 1949 of file parse.c.

{
  int counter = 0;
 
  parse_part(fp, b, &counter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_read_mime_header()

struct Body * mutt_read_mime_header	(	FILE *	fp,
		bool	digest )

Parse a MIME header.

Parameters

fp	stream to read from
digest	true if reading subparts of a multipart/digest

Return values

ptr	New Body containing parsed structure

Definition at line 1484 of file parse.c.

{
  if (!fp)
    return NULL;
 
  struct Body *b = mutt_body_new();
  struct Envelope *env = mutt_env_new();
  char *c = NULL;
  struct Buffer *buf = buf_pool_get();
  bool matched = false;
 
  b->hdr_offset = ftello(fp);
 
  b->encoding = ENC_7BIT; /* default from RFC1521 */
  b->type = digest ? TYPE_MESSAGE : TYPE_TEXT;
  b->disposition = DISP_INLINE;
 
  while (mutt_rfc822_read_line(fp, buf) != 0)
  {
    const char *line = buf_string(buf);
    /* Find the value of the current header */
    c = strchr(line, ':');
    if (c)
    {
      *c = '\0';
      c = mutt_str_skip_email_wsp(c + 1);
      if (*c == '\0')
      {
        mutt_debug(LL_DEBUG1, "skipping empty header field: %s\n", line);
        continue;
      }
    }
    else
    {
      mutt_debug(LL_DEBUG1, "bogus MIME header: %s\n", line);
      break;
    }
 
    size_t plen = mutt_istr_startswith(line, "content-");
    if (plen != 0)
    {
      if (mutt_istr_equal("type", line + plen))
      {
        mutt_parse_content_type(c, b);
      }
      else if (mutt_istr_equal("language", line + plen))
      {
        parse_content_language(c, b);
      }
      else if (mutt_istr_equal("transfer-encoding", line + plen))
      {
        b->encoding = mutt_check_encoding(c);
      }
      else if (mutt_istr_equal("disposition", line + plen))
      {
        parse_content_disposition(c, b);
      }
      else if (mutt_istr_equal("description", line + plen))
      {
        mutt_str_replace(&b->description, c);
        rfc2047_decode(&b->description);
      }
      else if (mutt_istr_equal("id", line + plen))
      {
        // strip <angle braces> from Content-ID: header
        char *id = c;
        int cid_len = mutt_str_len(c);
        if (cid_len > 2)
        {
          if (id[0] == '<')
          {
            id++;
            cid_len--;
          }
          if (id[cid_len - 1] == '>')
            id[cid_len - 1] = '\0';
        }
        mutt_str_replace(&b->content_id, id);
      }
    }
    else if ((plen = mutt_istr_startswith(line, "x-sun-")))
    {
      if (mutt_istr_equal("data-type", line + plen))
      {
        mutt_parse_content_type(c, b);
      }
      else if (mutt_istr_equal("encoding-info", line + plen))
      {
        b->encoding = mutt_check_encoding(c);
      }
      else if (mutt_istr_equal("content-lines", line + plen))
      {
        mutt_param_set(&b->parameter, "content-lines", c);
      }
      else if (mutt_istr_equal("data-description", line + plen))
      {
        mutt_str_replace(&b->description, c);
        rfc2047_decode(&b->description);
      }
    }
    else
    {
      if (mutt_rfc822_parse_line(env, NULL, line, strlen(line), c, false, false, false))
      {
        matched = true;
      }
    }
  }
  b->offset = ftello(fp); /* Mark the start of the real data */
  if ((b->type == TYPE_TEXT) && !b->subtype)
    b->subtype = mutt_str_dup("plain");
  else if ((b->type == TYPE_MESSAGE) && !b->subtype)
    b->subtype = mutt_str_dup("rfc822");
 
  buf_pool_release(&buf);
 
  if (matched)
  {
    b->mime_headers = env;
    rfc2047_decode_envelope(b->mime_headers);
  }
  else
  {
    mutt_env_free(&env);
  }
 
  return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc822_parse_line()

int mutt_rfc822_parse_line	(	struct Envelope *	env,
		struct Email *	e,
		const char *	name,
		size_t	name_len,
		const char *	body,
		bool	user_hdrs,
		bool	weed,
		bool	do_2047 )

Parse an email header.

Parameters

env	Envelope of the email
e	Email
name	Header field name, e.g. 'to'
name_len	Must be equivalent to strlen(name)
body	Header field body, e.g. 'john@.nosp@m.exam.nosp@m.ple.c.nosp@m.om'
user_hdrs	If true, save into the Envelope's userhdrs
weed	If true, perform header weeding (filtering)
do_2047	If true, perform RFC2047 decoding of the field

Return values

1	The field is recognised
0	The field is not recognised

Process a line from an email header. Each line that is recognised is parsed and the information put in the Envelope or Header.

Definition at line 798 of file parse.c.

{
  if (!env || !name)
    return 0;
 
  bool matched = false;
 
  switch (name[0] | 0x20)
  {
    case 'a':
      if ((name_len == 13) && eqi12(name + 1, "pparently-to"))
      {
        mutt_addrlist_parse(&env->to, body);
        matched = true;
      }
      else if ((name_len == 15) && eqi14(name + 1, "pparently-from"))
      {
        mutt_addrlist_parse(&env->from, body);
        matched = true;
      }
#ifdef USE_AUTOCRYPT
      else if ((name_len == 9) && eqi8(name + 1, "utocrypt"))
      {
        const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
        if (c_autocrypt)
        {
          env->autocrypt = parse_autocrypt(env->autocrypt, body);
          matched = true;
        }
      }
      else if ((name_len == 16) && eqi15(name + 1, "utocrypt-gossip"))
      {
        const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
        if (c_autocrypt)
        {
          env->autocrypt_gossip = parse_autocrypt(env->autocrypt_gossip, body);
          matched = true;
        }
      }
#endif
      break;
 
    case 'b':
      if ((name_len == 3) && eqi2(name + 1, "cc"))
      {
        mutt_addrlist_parse(&env->bcc, body);
        matched = true;
      }
      break;
 
    case 'c':
      if ((name_len == 2) && eqi1(name + 1, "c"))
      {
        mutt_addrlist_parse(&env->cc, body);
        matched = true;
      }
      else
      {
        if ((name_len >= 12) && eqi8(name, "content-"))
        {
          if ((name_len == 12) && eqi4(name + 8, "type"))
          {
            if (e)
              mutt_parse_content_type(body, e->body);
            matched = true;
          }
          else if ((name_len == 16) && eqi8(name + 8, "language"))
          {
            if (e)
              parse_content_language(body, e->body);
            matched = true;
          }
          else if ((name_len == 25) && eqi17(name + 8, "transfer-encoding"))
          {
            if (e)
              e->body->encoding = mutt_check_encoding(body);
            matched = true;
          }
          else if ((name_len == 14) && eqi8(name + 6, "t-length"))
          {
            if (e)
            {
              unsigned long len = 0;
              e->body->length = mutt_str_atoul(body, &len) ? MIN(len, CONTENT_TOO_BIG) : -1;
            }
            matched = true;
          }
          else if ((name_len == 19) && eqi11(name + 8, "description"))
          {
            if (e)
            {
              mutt_str_replace(&e->body->description, body);
              rfc2047_decode(&e->body->description);
            }
            matched = true;
          }
          else if ((name_len == 19) && eqi11(name + 8, "disposition"))
          {
            if (e)
              parse_content_disposition(body, e->body);
            matched = true;
          }
        }
      }
      break;
 
    case 'd':
      if ((name_len != 4) || !eqi4(name, "date"))
        break;
 
      mutt_str_replace(&env->date, body);
      if (e)
      {
        struct Tz tz = { 0 };
        // the caller will check e->date_sent for -1
        e->date_sent = mutt_date_parse_date(body, &tz);
        if (e->date_sent > 0)
        {
          e->zhours = tz.zhours;
          e->zminutes = tz.zminutes;
          e->zoccident = tz.zoccident;
        }
      }
      matched = true;
      break;
 
    case 'e':
      if ((name_len == 7) && eqi6(name + 1, "xpires") && e)
      {
        const time_t expired = mutt_date_parse_date(body, NULL);
        if ((expired != -1) && (expired < mutt_date_now()))
        {
          e->expired = true;
        }
      }
      break;
 
    case 'f':
      if ((name_len == 4) && eqi4(name, "from"))
      {
        mutt_addrlist_parse(&env->from, body);
        matched = true;
      }
      else if ((name_len == 11) && eqi10(name + 1, "ollowup-to"))
      {
        if (!env->followup_to)
        {
          env->followup_to = mutt_str_dup(mutt_str_skip_whitespace(body));
          mutt_str_remove_trailing_ws(env->followup_to);
        }
        matched = true;
      }
      break;
 
    case 'i':
      if ((name_len != 11) || !eqi10(name + 1, "n-reply-to"))
        break;
 
      mutt_list_free(&env->in_reply_to);
      char *body2 = mutt_str_dup(body); // Create a mutable copy
      mutt_filter_commandline_header_value(body2);
      parse_references(&env->in_reply_to, body2);
      FREE(&body2);
      matched = true;
      break;
 
    case 'l':
      if ((name_len == 5) && eqi4(name + 1, "ines"))
      {
        if (e)
        {
          unsigned int ui = 0; // we don't want a negative number of lines
          mutt_str_atoui(body, &ui);
          e->lines = ui;
        }
 
        matched = true;
      }
      else if ((name_len == 9) && eqi8(name + 1, "ist-post"))
      {
        /* RFC2369 */
        if (!mutt_strn_equal(mutt_str_skip_whitespace(body), "NO", 2))
        {
          char *mailto = mutt_rfc2369_first_mailto(body);
          if (mailto)
          {
            FREE(&env->list_post);
            env->list_post = mailto;
            const bool c_auto_subscribe = cs_subset_bool(NeoMutt->sub, "auto_subscribe");
            if (c_auto_subscribe)
              mutt_auto_subscribe(env->list_post);
          }
        }
        matched = true;
      }
      else if ((name_len == 14) && eqi13(name + 1, "ist-subscribe"))
      {
        /* RFC2369 */
        char *uri = rfc2369_first_value(body, false);
        if (uri)
        {
          FREE(&env->list_subscribe);
          env->list_subscribe = uri;
        }
        matched = true;
      }
      else if ((name_len == 16) && eqi15(name + 1, "ist-unsubscribe"))
      {
        /* RFC2369 */
        char *uri = rfc2369_first_value(body, false);
        if (uri)
        {
          FREE(&env->list_unsubscribe);
          env->list_unsubscribe = uri;
        }
        matched = true;
      }
      break;
 
    case 'm':
      if ((name_len == 12) && eqi11(name + 1, "ime-version"))
      {
        if (e)
          e->mime = true;
        matched = true;
      }
      else if ((name_len == 10) && eqi9(name + 1, "essage-id"))
      {
        /* We add a new "Message-ID:" when building a message */
        FREE(&env->message_id);
        env->message_id = mutt_extract_message_id(body, NULL);
        matched = true;
      }
      else
      {
        if ((name_len >= 13) && eqi4(name + 1, "ail-"))
        {
          if ((name_len == 13) && eqi8(name + 5, "reply-to"))
          {
            /* override the Reply-To: field */
            mutt_addrlist_clear(&env->reply_to);
            mutt_addrlist_parse(&env->reply_to, body);
            matched = true;
          }
          else if ((name_len == 16) && eqi11(name + 5, "followup-to"))
          {
            mutt_addrlist_parse(&env->mail_followup_to, body);
            matched = true;
          }
        }
      }
      break;
 
    case 'n':
      if ((name_len == 10) && eqi9(name + 1, "ewsgroups"))
      {
        FREE(&env->newsgroups);
        env->newsgroups = mutt_str_dup(mutt_str_skip_whitespace(body));
        mutt_str_remove_trailing_ws(env->newsgroups);
        matched = true;
      }
      break;
 
    case 'o':
      /* field 'Organization:' saves only for pager! */
      if ((name_len == 12) && eqi11(name + 1, "rganization"))
      {
        if (!env->organization && !mutt_istr_equal(body, "unknown"))
          env->organization = mutt_str_dup(body);
      }
      break;
 
    case 'r':
      if ((name_len == 10) && eqi9(name + 1, "eferences"))
      {
        mutt_list_free(&env->references);
        parse_references(&env->references, body);
        matched = true;
      }
      else if ((name_len == 8) && eqi8(name, "reply-to"))
      {
        mutt_addrlist_parse(&env->reply_to, body);
        matched = true;
      }
      else if ((name_len == 11) && eqi10(name + 1, "eturn-path"))
      {
        mutt_addrlist_parse(&env->return_path, body);
        matched = true;
      }
      else if ((name_len == 8) && eqi8(name, "received"))
      {
        if (e && (e->received == 0))
        {
          const char *d = strrchr(body, ';');
          if (d)
          {
            d = mutt_str_skip_email_wsp(d + 1);
            // the caller will check e->received for -1
            e->received = mutt_date_parse_date(d, NULL);
          }
        }
      }
      break;
 
    case 's':
      if ((name_len == 7) && eqi6(name + 1, "ubject"))
      {
        if (!env->subject)
          mutt_env_set_subject(env, body);
        matched = true;
      }
      else if ((name_len == 6) && eqi5(name + 1, "ender"))
      {
        mutt_addrlist_parse(&env->sender, body);
        matched = true;
      }
      else if ((name_len == 6) && eqi5(name + 1, "tatus"))
      {
        if (e)
        {
          while (*body)
          {
            switch (*body)
            {
              case 'O':
              {
                e->old = true;
                break;
              }
              case 'R':
                e->read = true;
                break;
              case 'r':
                e->replied = true;
                break;
            }
            body++;
          }
        }
        matched = true;
      }
      else if (e && (name_len == 10) && eqi1(name + 1, "u") &&
               (eqi8(name + 2, "persedes") || eqi8(name + 2, "percedes")))
      {
        FREE(&env->supersedes);
        env->supersedes = mutt_str_dup(body);
      }
      break;
 
    case 't':
      if ((name_len == 2) && eqi1(name + 1, "o"))
      {
        mutt_addrlist_parse(&env->to, body);
        matched = true;
      }
      break;
 
    case 'x':
      if ((name_len == 8) && eqi8(name, "x-status"))
      {
        if (e)
        {
          while (*body)
          {
            switch (*body)
            {
              case 'A':
                e->replied = true;
                break;
              case 'D':
                e->deleted = true;
                break;
              case 'F':
                e->flagged = true;
                break;
              default:
                break;
            }
            body++;
          }
        }
        matched = true;
      }
      else if ((name_len == 7) && eqi6(name + 1, "-label"))
      {
        FREE(&env->x_label);
        env->x_label = mutt_str_dup(body);
        matched = true;
      }
      else if ((name_len == 12) && eqi11(name + 1, "-comment-to"))
      {
        if (!env->x_comment_to)
          env->x_comment_to = mutt_str_dup(body);
        matched = true;
      }
      else if ((name_len == 4) && eqi4(name, "xref"))
      {
        if (!env->xref)
          env->xref = mutt_str_dup(body);
        matched = true;
      }
      else if ((name_len == 13) && eqi12(name + 1, "-original-to"))
      {
        mutt_addrlist_parse(&env->x_original_to, body);
        matched = true;
      }
      break;
 
    default:
      break;
  }
 
  /* Keep track of the user-defined headers */
  if (!matched && user_hdrs)
  {
    const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
    char *dup = NULL;
    mutt_str_asprintf(&dup, "%s: %s", name, body);
 
    if (!weed || !c_weed || !mutt_matches_ignore(dup))
    {
      struct ListNode *np = mutt_list_insert_tail(&env->userhdrs, dup);
      if (do_2047)
      {
        rfc2047_decode(&np->data);
      }
    }
    else
    {
      FREE(&dup);
    }
  }
 
  return matched;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc822_parse_message()

struct Body * mutt_rfc822_parse_message	(	FILE *	fp,
		struct Body *	b )

Parse a Message/RFC822 body.

Parameters

fp	Stream to read from
b	Info about the message/rfc822 body part

Return values

ptr	New Body containing parsed message

Note

This assumes that 'b->length' has been set!

Definition at line 1964 of file parse.c.

{
  int counter = 0;
 
  return rfc822_parse_message(fp, b, &counter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc822_read_header()

struct Envelope * mutt_rfc822_read_header	(	FILE *	fp,
		struct Email *	e,
		bool	user_hdrs,
		bool	weed )

Parses an RFC822 header.

Parameters

fp	Stream to read from
e	Current Email (optional)
user_hdrs	If set, store user headers Used for recall-message and postpone modes
weed	If this parameter is set and the user has activated the $weed option, honor the header weed list for user headers. Used for recall-message

Return values

ptr	Newly allocated envelope structure

Caller should free the Envelope using mutt_env_free().

Definition at line 1325 of file parse.c.

{
  if (!fp)
    return NULL;
 
  struct Envelope *env = mutt_env_new();
  char *p = NULL;
  LOFF_T loc = ftello(fp);
  if (loc < 0)
  {
    mutt_debug(LL_DEBUG1, "ftello: %s (errno %d)\n", strerror(errno), errno);
    loc = 0;
  }
 
  struct Buffer *line = buf_pool_get();
 
  if (e)
  {
    if (!e->body)
    {
      e->body = mutt_body_new();
 
      /* set the defaults from RFC1521 */
      e->body->type = TYPE_TEXT;
      e->body->subtype = mutt_str_dup("plain");
      e->body->encoding = ENC_7BIT;
      e->body->length = -1;
 
      /* RFC2183 says this is arbitrary */
      e->body->disposition = DISP_INLINE;
    }
  }
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  while (true)
  {
    LOFF_T line_start_loc = loc;
    size_t len = mutt_rfc822_read_line(fp, line);
    if (buf_is_empty(line))
    {
      break;
    }
    loc += len;
    const char *lines = buf_string(line);
    p = strpbrk(lines, ": \t");
    if (!p || (*p != ':'))
    {
      time_t t = 0;
 
      /* some bogus MTAs will quote the original "From " line */
      if (mutt_str_startswith(lines, ">From "))
      {
        continue; /* just ignore */
      }
      else if (is_from(lines, NULL, 0, &t))
      {
        /* MH sometimes has the From_ line in the middle of the header! */
        if (e && (e->received == 0))
          e->received = t - mutt_date_local_tz(t);
        continue;
      }
 
      /* We need to seek back to the start of the body. Note that we
       * keep track of loc ourselves, since calling ftello() incurs
       * a syscall, which can be expensive to do for every single line */
      (void) mutt_file_seek(fp, line_start_loc, SEEK_SET);
      break; /* end of header */
    }
    size_t name_len = p - lines;
 
    char buf[1024] = { 0 };
    if (mutt_replacelist_match(&mod_data->spam, buf, sizeof(buf), lines))
    {
      if (!mutt_regexlist_match(&mod_data->no_spam, lines))
      {
        /* if spam tag already exists, figure out how to amend it */
        if ((!buf_is_empty(&env->spam)) && (*buf != '\0'))
        {
          /* If `$spam_separator` defined, append with separator */
          const char *const c_spam_separator = cs_subset_string(NeoMutt->sub, "spam_separator");
          if (c_spam_separator)
          {
            buf_addstr(&env->spam, c_spam_separator);
            buf_addstr(&env->spam, buf);
          }
          else /* overwrite */
          {
            buf_reset(&env->spam);
            buf_addstr(&env->spam, buf);
          }
        }
        else if (buf_is_empty(&env->spam) && (*buf != '\0'))
        {
          /* spam tag is new, and match expr is non-empty; copy */
          buf_addstr(&env->spam, buf);
        }
        else if (buf_is_empty(&env->spam))
        {
          /* match expr is empty; plug in null string if no existing tag */
          buf_addstr(&env->spam, "");
        }
 
        if (!buf_is_empty(&env->spam))
          mutt_debug(LL_DEBUG5, "spam = %s\n", env->spam.data);
      }
    }
 
    *p = '\0';
    p = mutt_str_skip_email_wsp(p + 1);
    if (*p == '\0')
      continue; /* skip empty header fields */
 
    mutt_rfc822_parse_line(env, e, lines, name_len, p, user_hdrs, weed, true);
  }
 
  buf_pool_release(&line);
 
  if (e)
  {
    e->body->hdr_offset = e->offset;
    e->body->offset = ftello(fp);
 
    rfc2047_decode_envelope(env);
 
    if (e->received < 0)
    {
      mutt_debug(LL_DEBUG1, "resetting invalid received time to 0\n");
      e->received = 0;
    }
 
    /* check for missing or invalid date */
    if (e->date_sent <= 0)
    {
      mutt_debug(LL_DEBUG1, "no date found, using received time from msg separator\n");
      e->date_sent = e->received;
    }
 
#ifdef USE_AUTOCRYPT
    const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
    if (c_autocrypt)
    {
      mutt_autocrypt_process_autocrypt_header(e, env);
      /* No sense in taking up memory after the header is processed */
      mutt_autocrypthdr_free(&env->autocrypt);
    }
#endif
  }
 
  return env;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_rfc822_read_line()

size_t mutt_rfc822_read_line	(	FILE *	fp,
		struct Buffer *	buf )

Read a header line from a file.

Parameters

fp	File to read from
buf	Buffer to store the result

Return values

num	Number of bytes read from fp

Reads an arbitrarily long header field, and looks ahead for continuation lines.

Definition at line 1245 of file parse.c.

{
  if (!fp || !buf)
    return 0;
 
  size_t read = 0;
  char line[1024] = { 0 }; /* RFC2822 specifies a maximum line length of 998 */
 
  buf_reset(buf);
  while (true)
  {
    if (!fgets(line, sizeof(line), fp))
    {
      return 0;
    }
 
    const size_t linelen = mutt_str_len(line);
    if (linelen == 0)
    {
      break;
    }
 
    if (mutt_str_is_email_wsp(line[0]) && buf_is_empty(buf))
    {
      read = linelen;
      break;
    }
 
    read += linelen;
 
    size_t off = linelen - 1;
    if (line[off] == '\n')
    {
      /* We did get a full line: remove trailing space */
      do
      {
        line[off] = '\0';
      } while (off && mutt_str_is_email_wsp(line[--off]));
 
      /* check to see if the next line is a continuation line */
      int ch = fgetc(fp);
      if ((ch != ' ') && (ch != '\t'))
      {
        /* next line is a separate header field or EOH */
        ungetc(ch, fp);
        buf_addstr(buf, line);
        break;
      }
      read++;
 
      /* eat tabs and spaces from the beginning of the continuation line */
      while (((ch = fgetc(fp)) == ' ') || (ch == '\t'))
      {
        read++;
      }
 
      ungetc(ch, fp);
      line[off + 1] = ' '; /* string is still terminated because we removed
                              at least one whitespace char above */
    }
 
    buf_addstr(buf, line);
  }
 
  return read;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_filter_commandline_header_tag()

void mutt_filter_commandline_header_tag

(

char *

header

)

Sanitise characters in a header tag.

Parameters

header

String to sanitise

Definition at line 73 of file parse.c.

{
  if (!header)
    return;
 
  for (; (*header != '\0'); header++)
  {
    if ((*header < 33) || (*header > 126) || (*header == ':'))
      *header = '?';
  }
}

Here is the caller graph for this function:

mutt_filter_commandline_header_value()

void mutt_filter_commandline_header_value

(

char *

header

)

Sanitise characters in a header value.

Parameters

header

String to sanitise

It might be preferable to use mutt_filter_unprintable() instead. This filter is being lax, but preventing a header injection via an embedded newline.

Definition at line 93 of file parse.c.

{
  if (!header)
    return;
 
  for (; (*header != '\0'); header++)
  {
    if ((*header == '\n') || (*header == '\r'))
      *header = ' ';
  }
}

Here is the caller graph for this function: