envelope.h File Reference

Representation of an email header (envelope) More...

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

Include dependency graph for envelope.h:

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

Go to the source code of this file.

Data Structures
struct	AutocryptHeader
	Parse Autocrypt header info. More...
struct	Envelope
	The header of an Email. More...

Macros
#define	MUTT_ENV_CHANGED_IRT   (1 << 0)
	In-Reply-To changed to link/break threads.
#define	MUTT_ENV_CHANGED_REFS   (1 << 1)
	References changed to break thread.
#define	MUTT_ENV_CHANGED_XLABEL   (1 << 2)
	X-Label edited.
#define	MUTT_ENV_CHANGED_SUBJECT   (1 << 3)
	Protected header update.

Enumerations
enum	ExpandoDataEnvelope {   ED_ENV_CC_ALL = 1 , ED_ENV_FIRST_NAME , ED_ENV_FROM , ED_ENV_FROM_FULL ,   ED_ENV_INITIALS , ED_ENV_LIST_ADDRESS , ED_ENV_LIST_EMPTY , ED_ENV_MESSAGE_ID ,   ED_ENV_NAME , ED_ENV_NEWSGROUP , ED_ENV_ORGANIZATION , ED_ENV_REAL_NAME ,   ED_ENV_REPLY_TO , ED_ENV_SENDER , ED_ENV_SENDER_PLAIN , ED_ENV_SPAM ,   ED_ENV_SUBJECT , ED_ENV_THREAD_TREE , ED_ENV_THREAD_X_LABEL , ED_ENV_TO ,   ED_ENV_TO_ALL , ED_ENV_USERNAME , ED_ENV_USER_NAME , ED_ENV_X_COMMENT_TO ,   ED_ENV_X_LABEL }
	Expando UIDs for Envelopes. More...
enum	NotifyEnvelope {   NT_ENVELOPE_BCC = 1 , NT_ENVELOPE_CC , NT_ENVELOPE_FCC , NT_ENVELOPE_FOLLOWUP_TO ,   NT_ENVELOPE_FROM , NT_ENVELOPE_NEWSGROUPS , NT_ENVELOPE_REPLY_TO , NT_ENVELOPE_SUBJECT ,   NT_ENVELOPE_TO , NT_ENVELOPE_X_COMMENT_TO }
	Types of Envelope Event. More...

Functions
bool	mutt_env_cmp_strict (const struct Envelope *e1, const struct Envelope *e2)
	Strictly compare two Envelopes.
void	mutt_env_free (struct Envelope **ptr)
	Free an Envelope.
void	mutt_env_merge (struct Envelope *base, struct Envelope **extra)
	Merge the headers of two Envelopes.
struct Envelope *	mutt_env_new (void)
	Create a new Envelope.
bool	mutt_env_notify_send (struct Email *e, enum NotifyEnvelope type)
	Send an Envelope change notification.
void	mutt_env_set_subject (struct Envelope *env, const char *subj)
	Set both subject and real_subj to subj.
int	mutt_env_to_intl (struct Envelope *env, const char **tag, char **err)
	Convert an Envelope's Address fields to Punycode format.
void	mutt_env_to_local (struct Envelope *env)
	Convert an Envelope's Address fields to local format.
struct AutocryptHeader *	mutt_autocrypthdr_new (void)
	Create a new AutocryptHeader.
void	mutt_autocrypthdr_free (struct AutocryptHeader **ptr)
	Free an AutocryptHeader.

Detailed Description

Representation of an email header (envelope)

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

Macro Definition Documentation

MUTT_ENV_CHANGED_IRT

#define MUTT_ENV_CHANGED_IRT   (1 << 0)

In-Reply-To changed to link/break threads.

Definition at line 34 of file envelope.h.

MUTT_ENV_CHANGED_REFS

#define MUTT_ENV_CHANGED_REFS   (1 << 1)

References changed to break thread.

Definition at line 35 of file envelope.h.

MUTT_ENV_CHANGED_XLABEL

#define MUTT_ENV_CHANGED_XLABEL   (1 << 2)

X-Label edited.

Definition at line 36 of file envelope.h.

MUTT_ENV_CHANGED_SUBJECT

#define MUTT_ENV_CHANGED_SUBJECT   (1 << 3)

Protected header update.

Definition at line 37 of file envelope.h.

Enumeration Type Documentation

ExpandoDataEnvelope

enum ExpandoDataEnvelope

Expando UIDs for Envelopes.

See also

ED_ENVELOPE, ExpandoDomain

Enumerator
ED_ENV_CC_ALL	Envelope.cc.
ED_ENV_FIRST_NAME	Envelope.from, Envelope.to, Envelope.cc.
ED_ENV_FROM	Envelope.from (first)
ED_ENV_FROM_FULL	Envelope.from (all)
ED_ENV_INITIALS	Envelope.from (first)
ED_ENV_LIST_ADDRESS	Envelope.to, Envelope.cc.
ED_ENV_LIST_EMPTY	Envelope.to, Envelope.cc.
ED_ENV_MESSAGE_ID	Envelope.message_id.
ED_ENV_NAME	Envelope.from (first)
ED_ENV_NEWSGROUP	Envelope.newsgroups.
ED_ENV_ORGANIZATION	Envelope.organization.
ED_ENV_REAL_NAME	Envelope.to (first)
ED_ENV_REPLY_TO	Envelope.reply_to.
ED_ENV_SENDER	Envelope, make_from()
ED_ENV_SENDER_PLAIN	Envelope, make_from()
ED_ENV_SPAM	Envelope.spam.
ED_ENV_SUBJECT	Envelope.subject, Envelope.disp_subj.
ED_ENV_THREAD_TREE	Email.tree.
ED_ENV_THREAD_X_LABEL	Envelope.x_label.
ED_ENV_TO	Envelope.to, Envelope.cc (first)
ED_ENV_TO_ALL	Envelope.to (all)
ED_ENV_USERNAME	Envelope.from.
ED_ENV_USER_NAME	Envelope.to (first)
ED_ENV_X_COMMENT_TO	Envelope.x_comment_to.
ED_ENV_X_LABEL	Envelope.x_label.

Definition at line 98 of file envelope.h.

{
  ED_ENV_CC_ALL = 1,           
  ED_ENV_FIRST_NAME,           
  ED_ENV_FROM,                 
  ED_ENV_FROM_FULL,            
  ED_ENV_INITIALS,             
  ED_ENV_LIST_ADDRESS,         
  ED_ENV_LIST_EMPTY,           
  ED_ENV_MESSAGE_ID,           
  ED_ENV_NAME,                 
  ED_ENV_NEWSGROUP,            
  ED_ENV_ORGANIZATION,         
  ED_ENV_REAL_NAME,            
  ED_ENV_REPLY_TO,             
  ED_ENV_SENDER,               
  ED_ENV_SENDER_PLAIN,         
  ED_ENV_SPAM,                 
  ED_ENV_SUBJECT,              
  ED_ENV_THREAD_TREE,          
  ED_ENV_THREAD_X_LABEL,       
  ED_ENV_TO,                   
  ED_ENV_TO_ALL,               
  ED_ENV_USERNAME,             
  ED_ENV_USER_NAME,            
  ED_ENV_X_COMMENT_TO,         
  ED_ENV_X_LABEL,              
};

NotifyEnvelope

enum NotifyEnvelope

Types of Envelope Event.

Observers of NT_ENVELOPE will not be passed any Event data.

Notifications that an Envelope field has changed. Envelope doesn't support notifications, so events will be passed to the Email.

Enumerator
NT_ENVELOPE_BCC	"Bcc:" header has changed
NT_ENVELOPE_CC	"Cc:" header has changed
NT_ENVELOPE_FCC	"Fcc:" header has changed
NT_ENVELOPE_FOLLOWUP_TO	"Followup-To:" header has changed
NT_ENVELOPE_FROM	"From:" header has changed
NT_ENVELOPE_NEWSGROUPS	"Newsgroups:" header has changed
NT_ENVELOPE_REPLY_TO	"Reply-To:" header has changed
NT_ENVELOPE_SUBJECT	"Subject:" header has changed
NT_ENVELOPE_TO	"To:" header has changed
NT_ENVELOPE_X_COMMENT_TO	"X-Comment-To:" header has changed

Definition at line 135 of file envelope.h.

{
  NT_ENVELOPE_BCC  = 1,        
  NT_ENVELOPE_CC,              
  NT_ENVELOPE_FCC,             
  NT_ENVELOPE_FOLLOWUP_TO,     
  NT_ENVELOPE_FROM,            
  NT_ENVELOPE_NEWSGROUPS,      
  NT_ENVELOPE_REPLY_TO,        
  NT_ENVELOPE_SUBJECT,         
  NT_ENVELOPE_TO,              
  NT_ENVELOPE_X_COMMENT_TO,    
};

Function Documentation

mutt_env_cmp_strict()

bool mutt_env_cmp_strict	(	const struct Envelope *	e1,
		const struct Envelope *	e2 )

Strictly compare two Envelopes.

Parameters

e1	First Envelope
e2	Second Envelope

Return values

true	Envelopes are strictly identical

Definition at line 284 of file envelope.c.

{
  if (e1 && e2)
  {
    if (!mutt_str_equal(e1->message_id, e2->message_id) ||
        !mutt_str_equal(e1->subject, e2->subject) ||
        !mutt_list_equal(&e1->references, &e2->references) ||
        !mutt_addrlist_equal(&e1->from, &e2->from) ||
        !mutt_addrlist_equal(&e1->sender, &e2->sender) ||
        !mutt_addrlist_equal(&e1->reply_to, &e2->reply_to) ||
        !mutt_addrlist_equal(&e1->to, &e2->to) || !mutt_addrlist_equal(&e1->cc, &e2->cc) ||
        !mutt_addrlist_equal(&e1->return_path, &e2->return_path))
    {
      return false;
    }
    else
    {
      return true;
    }
  }
  else
  {
    return (!e1 && !e2);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_env_free()

void mutt_env_free

(

struct Envelope **

ptr

)

Free an Envelope.

Parameters

[out]

ptr

Envelope to free

Definition at line 125 of file envelope.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct Envelope *env = *ptr;
 
  mutt_addrlist_clear(&env->return_path);
  mutt_addrlist_clear(&env->from);
  mutt_addrlist_clear(&env->to);
  mutt_addrlist_clear(&env->cc);
  mutt_addrlist_clear(&env->bcc);
  mutt_addrlist_clear(&env->sender);
  mutt_addrlist_clear(&env->reply_to);
  mutt_addrlist_clear(&env->mail_followup_to);
  mutt_addrlist_clear(&env->x_original_to);
 
  FREE(&env->list_post);
  FREE(&env->list_subscribe);
  FREE(&env->list_unsubscribe);
  FREE((char **) &env->subject);
  /* real_subj is just an offset to subject and shouldn't be freed */
  FREE(&env->disp_subj);
  FREE(&env->message_id);
  FREE(&env->supersedes);
  FREE(&env->date);
  FREE(&env->x_label);
  FREE(&env->organization);
  FREE(&env->newsgroups);
  FREE(&env->xref);
  FREE(&env->followup_to);
  FREE(&env->x_comment_to);
 
  buf_dealloc(&env->spam);
 
  mutt_list_free(&env->references);
  mutt_list_free(&env->in_reply_to);
  mutt_list_free(&env->userhdrs);
 
#ifdef USE_AUTOCRYPT
  mutt_autocrypthdr_free(&env->autocrypt);
  mutt_autocrypthdr_free(&env->autocrypt_gossip);
#endif
 
  FREE(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_env_merge()

void mutt_env_merge	(	struct Envelope *	base,
		struct Envelope **	extra )

Merge the headers of two Envelopes.

Parameters

[in]	base	Envelope destination for all the headers
[out]	extra	Envelope to copy from

Any fields that are missing from base will be copied from extra. extra will be freed afterwards.

Definition at line 192 of file envelope.c.

{
  if (!base || !extra || !*extra)
    return;
 
/* copies each existing element if necessary, and sets the element
 * to NULL in the source so that mutt_env_free doesn't leave us
 * with dangling pointers. */
#define MOVE_ELEM(member)                                                      \
  if (!base->member)                                                           \
  {                                                                            \
    base->member = (*extra)->member;                                           \
    (*extra)->member = NULL;                                                   \
  }
 
#define MOVE_STAILQ(member)                                                    \
  if (STAILQ_EMPTY(&base->member))                                             \
  {                                                                            \
    STAILQ_SWAP(&base->member, &(*extra)->member, ListNode);                   \
  }
 
#define MOVE_ADDRESSLIST(member)                                               \
  if (TAILQ_EMPTY(&base->member))                                              \
  {                                                                            \
    TAILQ_SWAP(&base->member, &(*extra)->member, Address, entries);            \
  }
 
#define MOVE_BUFFER(member)                                                    \
  if (buf_is_empty(&base->member))                                             \
  {                                                                            \
    memcpy(&base->member, &(*extra)->member, sizeof(struct Buffer));           \
    buf_init(&(*extra)->member);                                               \
  }
 
  MOVE_ADDRESSLIST(return_path);
  MOVE_ADDRESSLIST(from);
  MOVE_ADDRESSLIST(to);
  MOVE_ADDRESSLIST(cc);
  MOVE_ADDRESSLIST(bcc);
  MOVE_ADDRESSLIST(sender);
  MOVE_ADDRESSLIST(reply_to);
  MOVE_ADDRESSLIST(mail_followup_to);
  MOVE_ELEM(list_post);
  MOVE_ELEM(list_subscribe);
  MOVE_ELEM(list_unsubscribe);
  MOVE_ELEM(message_id);
  MOVE_ELEM(supersedes);
  MOVE_ELEM(date);
  MOVE_ADDRESSLIST(x_original_to);
  if (!(base->changed & MUTT_ENV_CHANGED_XLABEL))
  {
    MOVE_ELEM(x_label);
  }
  if (!(base->changed & MUTT_ENV_CHANGED_REFS))
  {
    MOVE_STAILQ(references);
  }
  if (!(base->changed & MUTT_ENV_CHANGED_IRT))
  {
    MOVE_STAILQ(in_reply_to);
  }
 
  /* real_subj is subordinate to subject */
  if (!base->subject)
  {
    *(char **) &base->subject = (*extra)->subject;
    *(char **) &base->real_subj = (*extra)->real_subj;
    base->disp_subj = (*extra)->disp_subj;
    *(char **) &(*extra)->subject = NULL;
    *(char **) &(*extra)->real_subj = NULL;
    (*extra)->disp_subj = NULL;
  }
  /* spam and user headers should never be hashed, and the new envelope may
   * have better values. Use new versions regardless. */
  buf_dealloc(&base->spam);
  mutt_list_free(&base->userhdrs);
  MOVE_BUFFER(spam);
  MOVE_STAILQ(userhdrs);
#undef MOVE_ELEM
#undef MOVE_STAILQ
#undef MOVE_ADDRESSLIST
#undef MOVE_BUFFER
 
  mutt_env_free(extra);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_env_new()

struct Envelope * mutt_env_new

(

void

)

Create a new Envelope.

Return values

ptr	New Envelope

Definition at line 45 of file envelope.c.

{
  struct Envelope *env = MUTT_MEM_CALLOC(1, struct Envelope);
  TAILQ_INIT(&env->return_path);
  TAILQ_INIT(&env->from);
  TAILQ_INIT(&env->to);
  TAILQ_INIT(&env->cc);
  TAILQ_INIT(&env->bcc);
  TAILQ_INIT(&env->sender);
  TAILQ_INIT(&env->reply_to);
  TAILQ_INIT(&env->mail_followup_to);
  TAILQ_INIT(&env->x_original_to);
  STAILQ_INIT(&env->references);
  STAILQ_INIT(&env->in_reply_to);
  STAILQ_INIT(&env->userhdrs);
  return env;
}

Here is the caller graph for this function:

mutt_env_notify_send()

bool mutt_env_notify_send	(	struct Email *	e,
		enum NotifyEnvelope	type )

Send an Envelope change notification.

Parameters

e	Email
type	Notification type, e.g. NT_ENVELOPE_SUBJECT

Return values

true	Successfully sent

Definition at line 178 of file envelope.c.

{
  struct EventEmail ev_e = { 1, &e };
  return notify_send(e->notify, NT_ENVELOPE, type, &ev_e);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_env_set_subject()

void mutt_env_set_subject	(	struct Envelope *	env,
		const char *	subj )

Set both subject and real_subj to subj.

Parameters

env	Envelope
subj	Subject

Definition at line 68 of file envelope.c.

{
  mutt_str_replace((char **) &env->subject, subj);
  *(char **) &env->real_subj = NULL;
 
  if (env->subject)
  {
    regmatch_t match;
    const struct Regex *c_reply_regex = cs_subset_regex(NeoMutt->sub, "reply_regex");
    if (mutt_regex_capture(c_reply_regex, env->subject, 1, &match))
    {
      if (env->subject[match.rm_eo] != '\0')
        *(char **) &env->real_subj = env->subject + match.rm_eo;
    }
    else
    {
      *(char **) &env->real_subj = env->subject;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_env_to_intl()

int mutt_env_to_intl	(	struct Envelope *	env,
		const char **	tag,
		char **	err )

Convert an Envelope's Address fields to Punycode format.

Parameters

[in]	env	Envelope to modify
[out]	tag	Name of the failed field
[out]	err	Failed address

Return values

0	Success, all addresses converted
1	Error, tag and err will be set

Run mutt_addrlist_to_intl() on each of the Address fields in the Envelope.

Definition at line 354 of file envelope.c.

{
  if (!env)
    return 1;
 
  int rc = 0;
  H_TO_INTL(return_path);
  H_TO_INTL(from);
  H_TO_INTL(to);
  H_TO_INTL(cc);
  H_TO_INTL(bcc);
  H_TO_INTL(reply_to);
  H_TO_INTL(mail_followup_to);
  return rc;
}

Here is the caller graph for this function:

mutt_env_to_local()

void mutt_env_to_local

(

struct Envelope *

env

)

Convert an Envelope's Address fields to local format.

Parameters

env	Envelope to modify

Run mutt_addrlist_to_local() on each of the Address fields in the Envelope.

Definition at line 316 of file envelope.c.

{
  if (!env)
    return;
 
  mutt_addrlist_to_local(&env->return_path);
  mutt_addrlist_to_local(&env->from);
  mutt_addrlist_to_local(&env->to);
  mutt_addrlist_to_local(&env->cc);
  mutt_addrlist_to_local(&env->bcc);
  mutt_addrlist_to_local(&env->reply_to);
  mutt_addrlist_to_local(&env->mail_followup_to);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypthdr_new()

struct AutocryptHeader * mutt_autocrypthdr_new

(

void

)

Create a new AutocryptHeader.

Return values

ptr	New AutocryptHeader

Definition at line 94 of file envelope.c.

{
  return MUTT_MEM_CALLOC(1, struct AutocryptHeader);
}

Here is the caller graph for this function:

mutt_autocrypthdr_free()

void mutt_autocrypthdr_free

(

struct AutocryptHeader **

ptr

)

Free an AutocryptHeader.

Parameters

ptr	AutocryptHeader to free

Definition at line 103 of file envelope.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct AutocryptHeader *cur = NULL;
 
  while (*ptr)
  {
    cur = *ptr;
    *ptr = (*ptr)->next;
    FREE(&cur->addr);
    FREE(&cur->keydata);
    FREE(&cur);
  }
}

Here is the caller graph for this function: