envelope.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "envelope.h"
#include "email.h"
 
struct Envelope *mutt_env_new(void)
{
  struct Envelope *env = mutt_mem_calloc(1, sizeof(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;
}
 
void mutt_env_set_subject(struct Envelope *env, const char *subj)
{
  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;
    }
  }
}
 
#ifdef USE_AUTOCRYPT
struct AutocryptHeader *mutt_autocrypthdr_new(void)
{
  return mutt_mem_calloc(1, sizeof(struct AutocryptHeader));
}
 
void mutt_autocrypthdr_free(struct AutocryptHeader **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct AutocryptHeader *cur = NULL;
 
  while (*ptr)
  {
    cur = *ptr;
    *ptr = (*ptr)->next;
    FREE(&cur->addr);
    FREE(&cur->keydata);
    FREE(&cur);
  }
}
#endif
 
void mutt_env_free(struct Envelope **ptr)
{
  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);
}
 
bool mutt_env_notify_send(struct Email *e, enum NotifyEnvelope type)
{
  struct EventEmail ev_e = { 1, &e };
  return notify_send(e->notify, NT_ENVELOPE, type, &ev_e);
}
 
void mutt_env_merge(struct Envelope *base, struct Envelope **extra)
{
  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);
}
 
bool mutt_env_cmp_strict(const struct Envelope *e1, const struct Envelope *e2)
{
  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);
  }
}
 
void mutt_env_to_local(struct Envelope *env)
{
  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);
}
 
/* Note that 'member' in the 'env->member' expression is macro argument, not
 * "real" name of an 'env' compound member.  Real name will be substituted by
 * preprocessor at the macro-expansion time.
 * Note that #member escapes and double quotes the argument.
 */
#define H_TO_INTL(member)                                                      \
  if (mutt_addrlist_to_intl(&env->member, err) && (rc == 0))                   \
  {                                                                            \
    if (tag)                                                                   \
      *tag = #member;                                                          \
    rc = 1;                                                                    \
    err = NULL;                                                                \
  }
 
int mutt_env_to_intl(struct Envelope *env, const char **tag, char **err)
{
  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;
}
 
#undef H_TO_INTL