header.h File Reference

Convenience wrapper for the send headers. More...

#include <stdbool.h>
#include <stdio.h>
#include "copy.h"

Include dependency graph for header.h:

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

Go to the source code of this file.

Enumerations
enum	MuttWriteHeaderMode {   MUTT_WRITE_HEADER_NORMAL , MUTT_WRITE_HEADER_FCC , MUTT_WRITE_HEADER_POSTPONE , MUTT_WRITE_HEADER_EDITHDRS ,   MUTT_WRITE_HEADER_MIME }
	Modes for mutt_rfc822_write_header() More...

Functions
int	mutt_rfc822_write_header (FILE *fp, struct Envelope *env, struct Body *b, enum MuttWriteHeaderMode mode, bool privacy, bool hide_protected_subject, struct ConfigSubset *sub)
	Write out one RFC822 header line.
int	mutt_write_mime_header (struct Body *b, FILE *fp, struct ConfigSubset *sub)
	Create a MIME header.
int	mutt_write_one_header (FILE *fp, const char *tag, const char *value, const char *pfx, int wraplen, CopyHeaderFlags chflags, struct ConfigSubset *sub)
	Write one header line to a file.
void	mutt_write_references (const struct ListHead *r, FILE *fp, size_t trim)
	Add the message references to a list.

Detailed Description

Convenience wrapper for the send headers.

Authors

• Richard Russon

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

Enumeration Type Documentation

MuttWriteHeaderMode

enum MuttWriteHeaderMode

Modes for mutt_rfc822_write_header()

Enumerator
MUTT_WRITE_HEADER_NORMAL	A normal Email, write full header + MIME headers.
MUTT_WRITE_HEADER_FCC	fcc mode, like normal mode but for Bcc header
MUTT_WRITE_HEADER_POSTPONE	A postponed Email, just the envelope info.
MUTT_WRITE_HEADER_EDITHDRS	"light" mode (used for edit_hdrs)
MUTT_WRITE_HEADER_MIME	Write protected headers.

Definition at line 38 of file header.h.

{
  MUTT_WRITE_HEADER_NORMAL,   
  MUTT_WRITE_HEADER_FCC,      
  MUTT_WRITE_HEADER_POSTPONE, 
  MUTT_WRITE_HEADER_EDITHDRS, 
  MUTT_WRITE_HEADER_MIME,     
};

Function Documentation

mutt_rfc822_write_header()

int mutt_rfc822_write_header	(	FILE *	fp,
		struct Envelope *	env,
		struct Body *	b,
		enum MuttWriteHeaderMode	mode,
		bool	privacy,
		bool	hide_protected_subject,
		struct ConfigSubset *	sub )

Write out one RFC822 header line.

Parameters

fp	File to write to
env	Envelope of email
b	Attachment
mode	Mode, see MuttWriteHeaderMode
privacy	If true, remove headers that might identify the user
hide_protected_subject	If true, replace subject header
sub	Config Subset

Return values

0	Success
-1	Failure

Note

All RFC2047 encoding should be done outside of this routine, except for the "real name." This will allow this routine to be used more than once, if necessary.

Likewise, all IDN processing should happen outside of this routine.

privacy true => will omit any headers which may identify the user. Output generated is suitable for being sent through anonymous remailer chains.

hide_protected_subject: replaces the Subject header with $crypt_protected_headers_subject in NORMAL or POSTPONE mode.

Definition at line 577 of file header.c.

{
  if (((mode == MUTT_WRITE_HEADER_NORMAL) || (mode == MUTT_WRITE_HEADER_FCC) ||
       (mode == MUTT_WRITE_HEADER_POSTPONE)) &&
      !privacy)
  {
    struct Buffer *date = buf_pool_get();
    mutt_date_make_date(date, cs_subset_bool(sub, "local_date_header"));
    fprintf(fp, "Date: %s\n", buf_string(date));
    buf_pool_release(&date);
  }
 
  /* UseFrom is not consulted here so that we can still write a From:
   * field if the user sets it with the 'my_hdr' command */
  if (!TAILQ_EMPTY(&env->from) && !privacy)
  {
    mutt_addrlist_write_file(&env->from, fp, "From");
  }
 
  if (!TAILQ_EMPTY(&env->sender) && !privacy)
  {
    mutt_addrlist_write_file(&env->sender, fp, "Sender");
  }
 
  if (!TAILQ_EMPTY(&env->to))
  {
    mutt_addrlist_write_file(&env->to, fp, "To");
  }
  else if (mode == MUTT_WRITE_HEADER_EDITHDRS)
  {
    if (!OptNewsSend)
      fputs("To:\n", fp);
  }
 
  if (!TAILQ_EMPTY(&env->cc))
  {
    mutt_addrlist_write_file(&env->cc, fp, "Cc");
  }
  else if (mode == MUTT_WRITE_HEADER_EDITHDRS)
  {
    if (!OptNewsSend)
      fputs("Cc:\n", fp);
  }
 
  if (!TAILQ_EMPTY(&env->bcc))
  {
    const bool c_write_bcc = cs_subset_bool(sub, "write_bcc");
 
    if ((mode == MUTT_WRITE_HEADER_POSTPONE) ||
        (mode == MUTT_WRITE_HEADER_EDITHDRS) || (mode == MUTT_WRITE_HEADER_FCC) ||
        ((mode == MUTT_WRITE_HEADER_NORMAL) && c_write_bcc))
    {
      mutt_addrlist_write_file(&env->bcc, fp, "Bcc");
    }
  }
  else if (mode == MUTT_WRITE_HEADER_EDITHDRS)
  {
    if (!OptNewsSend)
      fputs("Bcc:\n", fp);
  }
 
  if (env->newsgroups)
    fprintf(fp, "Newsgroups: %s\n", env->newsgroups);
  else if ((mode == MUTT_WRITE_HEADER_EDITHDRS) && OptNewsSend)
    fputs("Newsgroups:\n", fp);
 
  if (env->followup_to)
    fprintf(fp, "Followup-To: %s\n", env->followup_to);
  else if ((mode == MUTT_WRITE_HEADER_EDITHDRS) && OptNewsSend)
    fputs("Followup-To:\n", fp);
 
  const bool c_x_comment_to = cs_subset_bool(sub, "x_comment_to");
  if (env->x_comment_to)
    fprintf(fp, "X-Comment-To: %s\n", env->x_comment_to);
  else if ((mode == MUTT_WRITE_HEADER_EDITHDRS) && OptNewsSend && c_x_comment_to)
    fputs("X-Comment-To:\n", fp);
 
  if (env->subject)
  {
    if (hide_protected_subject &&
        ((mode == MUTT_WRITE_HEADER_NORMAL) || (mode == MUTT_WRITE_HEADER_FCC) ||
         (mode == MUTT_WRITE_HEADER_POSTPONE)))
    {
      const char *const c_crypt_protected_headers_subject = cs_subset_string(sub, "crypt_protected_headers_subject");
      mutt_write_one_header(fp, "Subject", c_crypt_protected_headers_subject,
                            NULL, 0, CH_NO_FLAGS, sub);
    }
    else
    {
      mutt_write_one_header(fp, "Subject", env->subject, NULL, 0, CH_NO_FLAGS, sub);
    }
  }
  else if (mode == MUTT_WRITE_HEADER_EDITHDRS)
  {
    fputs("Subject:\n", fp);
  }
 
  /* save message id if the user has set it */
  if (env->message_id && !privacy)
    fprintf(fp, "Message-ID: %s\n", env->message_id);
 
  if (!TAILQ_EMPTY(&env->reply_to))
  {
    mutt_addrlist_write_file(&env->reply_to, fp, "Reply-To");
  }
  else if (mode == MUTT_WRITE_HEADER_EDITHDRS)
  {
    fputs("Reply-To:\n", fp);
  }
 
  if (!TAILQ_EMPTY(&env->mail_followup_to))
  {
    if (!OptNewsSend)
    {
      mutt_addrlist_write_file(&env->mail_followup_to, fp, "Mail-Followup-To");
    }
  }
 
  /* Add any user defined headers */
  struct UserHdrsOverride userhdrs_overrides = write_userhdrs(fp, &env->userhdrs,
                                                              privacy, sub);
 
  if ((mode == MUTT_WRITE_HEADER_NORMAL) || (mode == MUTT_WRITE_HEADER_FCC) ||
      (mode == MUTT_WRITE_HEADER_POSTPONE) || (mode == MUTT_WRITE_HEADER_MIME))
  {
    if (!STAILQ_EMPTY(&env->references))
    {
      fputs("References:", fp);
      mutt_write_references(&env->references, fp, 10);
      fputc('\n', fp);
    }
 
    /* Add the MIME headers */
    if (!userhdrs_overrides.is_overridden[USERHDRS_OVERRIDE_CONTENT_TYPE])
    {
      fputs("MIME-Version: 1.0\n", fp);
      mutt_write_mime_header(b, fp, sub);
    }
  }
 
  if (!STAILQ_EMPTY(&env->in_reply_to))
  {
    fputs("In-Reply-To:", fp);
    mutt_write_references(&env->in_reply_to, fp, 0);
    fputc('\n', fp);
  }
 
#ifdef USE_AUTOCRYPT
  const bool c_autocrypt = cs_subset_bool(sub, "autocrypt");
  if (c_autocrypt)
  {
    if (mode == MUTT_WRITE_HEADER_NORMAL || mode == MUTT_WRITE_HEADER_FCC)
      mutt_autocrypt_write_autocrypt_header(env, fp);
    if (mode == MUTT_WRITE_HEADER_MIME)
      mutt_autocrypt_write_gossip_headers(env, fp);
  }
#endif
 
  const bool c_user_agent = cs_subset_bool(sub, "user_agent");
  if (((mode == MUTT_WRITE_HEADER_NORMAL) || (mode == MUTT_WRITE_HEADER_FCC)) && !privacy &&
      c_user_agent && !userhdrs_overrides.is_overridden[USERHDRS_OVERRIDE_USER_AGENT])
  {
    /* Add a vanity header */
    fprintf(fp, "User-Agent: NeoMutt/%s%s\n", PACKAGE_VERSION, GitVer);
  }
 
  return (ferror(fp) == 0) ? 0 : -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_write_mime_header()

int mutt_write_mime_header	(	struct Body *	b,
		FILE *	fp,
		struct ConfigSubset *	sub )

Create a MIME header.

Parameters

b	Body part
fp	File to write to
sub	Config Subset

Return values

0	Success
-1	Failure

Definition at line 756 of file header.c.

{
  if (!b || !fp)
    return -1;
 
  int len;
  int tmplen;
  char buf[256] = { 0 };
 
  fprintf(fp, "Content-Type: %s/%s", BODY_TYPE(b), b->subtype);
 
  if (!TAILQ_EMPTY(&b->parameter))
  {
    len = 25 + mutt_str_len(b->subtype); /* approximate len. of content-type */
 
    struct Parameter *np = NULL;
    TAILQ_FOREACH(np, &b->parameter, entries)
    {
      if (!np->attribute || !np->value)
        continue;
 
      struct ParameterList pl_conts = TAILQ_HEAD_INITIALIZER(pl_conts);
      rfc2231_encode_string(&pl_conts, np->attribute, np->value);
      struct Parameter *cont = NULL;
      TAILQ_FOREACH(cont, &pl_conts, entries)
      {
        fputc(';', fp);
 
        buf[0] = 0;
        mutt_addr_cat(buf, sizeof(buf), cont->value, MimeSpecials);
 
        /* Dirty hack to make messages readable by Outlook Express
         * for the Mac: force quotes around the boundary parameter
         * even when they aren't needed.  */
        if (mutt_istr_equal(cont->attribute, "boundary") && mutt_str_equal(buf, cont->value))
          snprintf(buf, sizeof(buf), "\"%s\"", cont->value);
 
        tmplen = mutt_str_len(buf) + mutt_str_len(cont->attribute) + 1;
        if ((len + tmplen + 2) > 76)
        {
          fputs("\n\t", fp);
          len = tmplen + 1;
        }
        else
        {
          fputc(' ', fp);
          len += tmplen + 1;
        }
 
        fprintf(fp, "%s=%s", cont->attribute, buf);
      }
 
      mutt_param_free(&pl_conts);
    }
  }
 
  fputc('\n', fp);
 
  if (b->content_id)
    fprintf(fp, "Content-ID: <%s>\n", b->content_id);
 
  if (b->language)
    fprintf(fp, "Content-Language: %s\n", b->language);
 
  if (b->description)
    fprintf(fp, "Content-Description: %s\n", b->description);
 
  if (b->disposition != DISP_NONE)
  {
    const char *dispstr[] = { "inline", "attachment", "form-data" };
 
    if (b->disposition < sizeof(dispstr) / sizeof(char *))
    {
      fprintf(fp, "Content-Disposition: %s", dispstr[b->disposition]);
      len = 21 + mutt_str_len(dispstr[b->disposition]);
 
      if (b->use_disp && ((b->disposition != DISP_INLINE) || b->d_filename))
      {
        char *fn = b->d_filename;
        if (!fn)
          fn = b->filename;
 
        if (fn)
        {
          /* Strip off the leading path... */
          char *t = strrchr(fn, '/');
          if (t)
            t++;
          else
            t = fn;
 
          struct ParameterList pl_conts = TAILQ_HEAD_INITIALIZER(pl_conts);
          rfc2231_encode_string(&pl_conts, "filename", t);
          struct Parameter *cont = NULL;
          TAILQ_FOREACH(cont, &pl_conts, entries)
          {
            fputc(';', fp);
            buf[0] = 0;
            mutt_addr_cat(buf, sizeof(buf), cont->value, MimeSpecials);
 
            tmplen = mutt_str_len(buf) + mutt_str_len(cont->attribute) + 1;
            if ((len + tmplen + 2) > 76)
            {
              fputs("\n\t", fp);
              len = tmplen + 1;
            }
            else
            {
              fputc(' ', fp);
              len += tmplen + 1;
            }
 
            fprintf(fp, "%s=%s", cont->attribute, buf);
          }
 
          mutt_param_free(&pl_conts);
        }
      }
 
      fputc('\n', fp);
    }
    else
    {
      mutt_debug(LL_DEBUG1, "ERROR: invalid content-disposition %d\n", b->disposition);
    }
  }
 
  if (b->encoding != ENC_7BIT)
    fprintf(fp, "Content-Transfer-Encoding: %s\n", ENCODING(b->encoding));
 
  const bool c_crypt_protected_headers_write = cs_subset_bool(sub, "crypt_protected_headers_write");
  bool c_autocrypt = false;
#ifdef USE_AUTOCRYPT
  c_autocrypt = cs_subset_bool(sub, "autocrypt");
#endif
 
  if ((c_crypt_protected_headers_write || c_autocrypt) && b->mime_headers)
  {
    mutt_rfc822_write_header(fp, b->mime_headers, NULL, MUTT_WRITE_HEADER_MIME,
                             false, false, sub);
  }
 
  /* Do NOT add the terminator here!!! */
  return ferror(fp) ? -1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_write_one_header()

int mutt_write_one_header	(	FILE *	fp,
		const char *	tag,
		const char *	value,
		const char *	pfx,
		int	wraplen,
		CopyHeaderFlags	chflags,
		struct ConfigSubset *	sub )

Write one header line to a file.

Parameters

fp	File to write to
tag	Header key, e.g. "From"
value	Header value
pfx	Prefix for header
wraplen	Column to wrap at
chflags	Flags, see CopyHeaderFlags
sub	Config Subset

Return values

0	Success
-1	Failure

split several headers into individual ones and call write_one_header for each one

Definition at line 423 of file header.c.

{
  char *last = NULL, *line = NULL;
  int max = 0, w, rc = -1;
  int pfxw = mutt_strwidth(pfx);
  char *v = mutt_str_dup(value);
  bool display = (chflags & CH_DISPLAY);
 
  const bool c_weed = cs_subset_bool(sub, "weed");
  if (!display || c_weed)
    v = unfold_header(v);
 
  /* when not displaying, use sane wrap value */
  if (!display)
  {
    const short c_wrap_headers = cs_subset_number(sub, "wrap_headers");
    if ((c_wrap_headers < 78) || (c_wrap_headers > 998))
      wraplen = 78;
    else
      wraplen = c_wrap_headers;
  }
  else if (wraplen <= 0)
  {
    wraplen = 78;
  }
 
  const size_t vlen = mutt_str_len(v);
  if (tag)
  {
    /* if header is short enough, simply print it */
    if (!display && (mutt_strwidth(tag) + 2 + pfxw + mutt_strnwidth(v, vlen) <= wraplen))
    {
      mutt_debug(LL_DEBUG5, "buf[%s%s: %s] is short enough\n", NONULL(pfx), tag, v);
      if (fprintf(fp, "%s%s: %s\n", NONULL(pfx), tag, v) <= 0)
        goto out;
      rc = 0;
      goto out;
    }
    else
    {
      rc = fold_one_header(fp, tag, v, vlen, pfx, wraplen, chflags);
      goto out;
    }
  }
 
  char *p = v;
  last = v;
  line = v;
  while (p && *p)
  {
    p = strchr(p, '\n');
 
    /* find maximum line width in current header */
    if (p)
      *p = '\0';
    w = mutt_mb_width(line, 0, display);
    if (w > max)
      max = w;
    if (p)
      *p = '\n';
 
    if (!p)
      break;
 
    line = ++p;
    if ((*p != ' ') && (*p != '\t'))
    {
      if (write_one_header(fp, pfxw, max, wraplen, pfx, last, p, chflags) < 0)
        goto out;
      last = p;
      max = 0;
    }
  }
 
  if (last && *last)
    if (write_one_header(fp, pfxw, max, wraplen, pfx, last, p, chflags) < 0)
      goto out;
 
  rc = 0;
 
out:
  FREE(&v);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_write_references()

void mutt_write_references	(	const struct ListHead *	r,
		FILE *	fp,
		size_t	trim )

Add the message references to a list.

Parameters

r	String List of references
fp	File to write to
trim	Trim the list to at most this many items

Write the list in reverse because they are stored in reverse order when parsed to speed up threading.

Definition at line 519 of file header.c.

{
  struct ListNode *np = NULL;
  size_t length = 0;
 
  STAILQ_FOREACH(np, r, entries)
  {
    if (++length == trim)
      break;
  }
 
  struct ListNode **ref = MUTT_MEM_CALLOC(length, struct ListNode *);
 
  // store in reverse order
  size_t tmp = length;
  STAILQ_FOREACH(np, r, entries)
  {
    ref[--tmp] = np;
    if (tmp == 0)
      break;
  }
 
  for (size_t i = 0; i < length; i++)
  {
    fputc(' ', fp);
    fputs(ref[i]->data, fp);
    if (i != length - 1)
      fputc('\n', fp);
  }
 
  FREE(&ref);
}

Here is the caller graph for this function: