* please see the file GPL in the top level source directory.
*/
-#if HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include <lib-lib/lib-lib.h>
+#include <utime.h>
-#include <lib-lib/mem.h>
-#include <lib-lib/str.h>
-#include <lib-lib/ascii.h>
-#include <lib-lib/macros.h>
-#include <lib-lib/file.h>
-
-#include "mutt.h"
-#include "enter.h"
-#include "mutt_curses.h"
-#include "rfc2047.h"
-#include "rfc3676.h"
+#include <lib-mime/mime.h>
+#include <lib-mime/rfc3676.h>
+#include <lib-sys/unix.h>
+#include <lib-ui/curses.h>
+#include <lib-ui/enter.h>
+#include <lib-mx/mx.h>
+
+#include "alias.h"
#include "keymap.h"
-#include "mime.h"
#include "copy.h"
-#include "mx.h"
-#include "mutt_crypt.h"
+#include <lib-crypt/crypt.h>
#include "mutt_idna.h"
-#include "url.h"
#include "attach.h"
-#include "lib/debug.h"
-
-#include <ctype.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-#include <dirent.h>
-#include <time.h>
-#include <sys/types.h>
-#include <utime.h>
-
#ifdef USE_NNTP
-#include "nntp.h"
+#include <nntp/nntp.h>
#endif
#ifdef MIXMASTER
else if (SignOffString)
fputs ("\n", f);
mutt_copy_stream (tmpfp, f);
- fclose (tmpfp);
+ m_fclose(&tmpfp);
if (thepid != -1)
mutt_wait_filter (thepid);
}
}
/* compare two e-mail addresses and return 1 if they are equivalent */
-static int mutt_addrcmp (ADDRESS * a, ADDRESS * b)
+static int mutt_addrcmp (address_t * a, address_t * b)
{
if (!a->mailbox || !b->mailbox)
return 0;
}
/* search an e-mail address in a list */
-static int mutt_addrsrc (ADDRESS * a, ADDRESS * lst)
+static int mutt_addrsrc (address_t * a, address_t * lst)
{
for (; lst; lst = lst->next) {
if (mutt_addrcmp (a, lst))
}
/* removes addresses from "b" which are contained in "a" */
-static ADDRESS *mutt_remove_xrefs (ADDRESS * a, ADDRESS * b)
+static address_t *mutt_remove_xrefs (address_t * a, address_t * b)
{
- ADDRESS *top, *p, *prev = NULL;
+ address_t *top, *p, *prev = NULL;
top = b;
while (b) {
if (prev) {
prev->next = b->next;
b->next = NULL;
- rfc822_free_address (&b);
+ address_list_wipe(&b);
b = prev;
}
else {
top = top->next;
b->next = NULL;
- rfc822_free_address (&b);
+ address_list_wipe(&b);
b = top;
}
}
/* remove any address which matches the current user. if `leave_only' is
* nonzero, don't remove the user's address if it is the only one in the list
*/
-static ADDRESS *remove_user (ADDRESS * a, int leave_only)
+static address_t *remove_user (address_t * a, int leave_only)
{
- ADDRESS *top = NULL, *last = NULL;
+ address_t *top = NULL, *last = NULL;
while (a) {
if (!mutt_addr_is_user (a)) {
last->next = NULL;
}
else {
- ADDRESS *tmp = a;
+ address_t *tmp = a;
a = a->next;
if (!leave_only || a || last) {
tmp->next = NULL;
- rfc822_free_address (&tmp);
+ address_list_wipe(&tmp);
}
else
last = top = tmp;
return top;
}
-static ADDRESS *find_mailing_lists (ADDRESS * t, ADDRESS * c)
+static address_t *find_mailing_lists (address_t * t, address_t * c)
{
- ADDRESS *top = NULL, *ptr = NULL;
+ address_t *top = NULL, *ptr = NULL;
for (; t || c; t = c, c = NULL) {
for (; t; t = t->next) {
if (mutt_is_mail_list (t) && !t->group) {
if (top) {
- ptr->next = rfc822_cpy_adr_real (t);
+ ptr->next = address_dup (t);
ptr = ptr->next;
}
else
- ptr = top = rfc822_cpy_adr_real (t);
+ ptr = top = address_dup (t);
}
}
}
return top;
}
-static int edit_address (ADDRESS ** a, const char *field)
+static int edit_address (address_t ** a, const char *field)
{
char buf[HUGE_STRING];
char *err = NULL;
rfc822_write_address (buf, sizeof (buf), *a, 0);
if (mutt_get_field (field, buf, sizeof (buf), M_ALIAS) != 0)
return (-1);
- rfc822_free_address (a);
+ address_list_wipe(a);
*a = mutt_expand_aliases (mutt_parse_adrlist (NULL, buf));
if ((idna_ok = mutt_addrlist_to_idna (*a, &err)) != 0) {
mutt_error (_("Error: '%s' is a bad IDN."), err);
static int edit_envelope (ENVELOPE * en, int flags)
{
char buf[HUGE_STRING];
- LIST *uh = UserHeader;
+ string_list_t *uh = UserHeader;
regmatch_t pat_match[1];
#ifdef USE_NNTP
return (-1);
}
- str_replace (&en->subject, buf);
+ m_strreplace(&en->subject, buf);
return 0;
}
#ifdef USE_NNTP
-char *nntp_get_header(const char *s)
+static char *nntp_get_header(const char *s)
{
return m_strdup(skipspaces(s));
}
static void process_user_recips (ENVELOPE * env)
{
- LIST *uh = UserHeader;
+ string_list_t *uh = UserHeader;
for (; uh; uh = uh->next) {
if (ascii_strncasecmp ("to:", uh->data, 3) == 0)
static void process_user_header (ENVELOPE * env)
{
- LIST *uh = UserHeader;
- LIST *last = env->userhdrs;
+ string_list_t *uh = UserHeader;
+ string_list_t *last = env->userhdrs;
if (last)
while (last->next)
for (; uh; uh = uh->next) {
if (ascii_strncasecmp ("from:", uh->data, 5) == 0) {
/* User has specified a default From: address. Remove default address */
- rfc822_free_address (&env->from);
+ address_list_wipe(&env->from);
env->from = rfc822_parse_adrlist (env->from, uh->data + 5);
}
else if (ascii_strncasecmp ("reply-to:", uh->data, 9) == 0) {
- rfc822_free_address (&env->reply_to);
+ address_list_wipe(&env->reply_to);
env->reply_to = rfc822_parse_adrlist (env->reply_to, uh->data + 9);
}
else if (ascii_strncasecmp ("message-id:", uh->data, 11) == 0)
- str_replace (&env->message_id, uh->data + 11);
+ m_strreplace(&env->message_id, uh->data + 11);
else if (ascii_strncasecmp ("to:", uh->data, 3) != 0 &&
ascii_strncasecmp ("cc:", uh->data, 3) != 0 &&
ascii_strncasecmp ("bcc:", uh->data, 4) != 0 &&
ascii_strncasecmp ("supersedes:", uh->data, 11) != 0 &&
ascii_strncasecmp ("subject:", uh->data, 8) != 0) {
if (last) {
- last->next = mutt_new_list ();
+ last->next = string_item_new();
last = last->next;
}
else
- last = env->userhdrs = mutt_new_list ();
+ last = env->userhdrs = string_item_new();
last->data = m_strdup(uh->data);
}
}
mutt_parse_mime_message (ctx, cur);
mutt_message_hook (ctx, cur, M_MESSAGEHOOK);
- if (WithCrypto && (cur->security & ENCRYPT) && option (OPTFORWDECODE)) {
+ if ((cur->security & ENCRYPT) && option (OPTFORWDECODE)) {
/* make sure we have the user's passphrase before proceeding... */
crypt_valid_passphrase (cur->security);
}
int cmflags = M_CM_PREFIX | M_CM_DECODE | M_CM_CHARCONV | M_CM_REPLYING;
int chflags = CH_DECODE;
- if (WithCrypto && (cur->security & ENCRYPT)) {
+ if ((cur->security & ENCRYPT)) {
/* make sure we have the user's passphrase before proceeding... */
crypt_valid_passphrase (cur->security);
}
return 0;
}
-static int default_to (ADDRESS ** to, ENVELOPE * env, int flags, int hmfupto)
+static int default_to (address_t ** to, ENVELOPE * env, int flags, int hmfupto)
{
char prompt[STRING];
- ADDRESS *tmp;
if (flags && env->mail_followup_to && hmfupto == M_YES) {
- rfc822_append (to, env->mail_followup_to);
+ address_list_append(to, address_list_dup(env->mail_followup_to));
return 0;
}
_("Message came from a mailing list. List-reply to mailing list?")))
{
case M_YES:
- tmp = find_mailing_lists (env->to, env->cc);
- rfc822_append (to, tmp);
- rfc822_free_address (&tmp);
+ address_list_append(to, find_mailing_lists (env->to, env->cc));
return 0;
case -1:
return -1; /* abort */
if (!option (OPTREPLYSELF) && mutt_addr_is_user (env->from)) {
/* mail is from the user, assume replying to recipients */
- rfc822_append (to, env->to);
+ address_list_append(to, address_list_dup(env->to));
}
else if (env->reply_to) {
if ((mutt_addrcmp (env->from, env->reply_to) && !env->reply_to->next) ||
* in his From header.
*
*/
- rfc822_append (to, env->from);
+ address_list_append(to, address_list_dup(env->from));
}
else if (!(mutt_addrcmp (env->from, env->reply_to) &&
!env->reply_to->next) && quadoption (OPT_REPLYTO) != M_YES) {
env->reply_to->mailbox, env->reply_to->next ? ",..." : "");
switch (query_quadoption (OPT_REPLYTO, prompt)) {
case M_YES:
- rfc822_append (to, env->reply_to);
+ address_list_append(to, address_list_dup(env->reply_to));
break;
case M_NO:
- rfc822_append (to, env->from);
+ address_list_append(to, address_list_dup(env->from));
break;
default:
}
}
else
- rfc822_append (to, env->reply_to);
+ address_list_append(to, address_list_dup(env->reply_to));
}
else
- rfc822_append (to, env->from);
+ address_list_append(to, address_list_dup(env->from));
return (0);
}
int mutt_fetch_recips (ENVELOPE * out, ENVELOPE * in, int flags)
{
char prompt[STRING];
- ADDRESS *tmp;
int hmfupto = -1;
if ((flags & (SENDLISTREPLY | SENDGROUPREPLY)) && in->mail_followup_to) {
}
if (flags & SENDLISTREPLY) {
- tmp = find_mailing_lists (in->to, in->cc);
- rfc822_append (&out->to, tmp);
- rfc822_free_address (&tmp);
+ address_list_append(&out->to, find_mailing_lists(in->to, in->cc));
if (in->mail_followup_to && hmfupto == M_YES &&
default_to (&out->cc, in, flags & SENDLISTREPLY, hmfupto) == -1)
return (-1); /* abort */
if ((flags & SENDGROUPREPLY)
- && (!in->mail_followup_to || hmfupto != M_YES)) {
- /* if(!mutt_addr_is_user(in->to)) */
- rfc822_append (&out->cc, in->to);
- rfc822_append (&out->cc, in->cc);
+ && (!in->mail_followup_to || hmfupto != M_YES))
+ {
+ address_t **tmp = address_list_append(&out->cc, address_list_dup(in->to));
+ address_list_append(tmp, address_list_dup(in->cc));
}
}
return 0;
}
-LIST *mutt_make_references (ENVELOPE * e)
-{
- LIST *t = NULL, *l = NULL;
-
- if (e->references)
- l = mutt_copy_list (e->references);
- else
- l = mutt_copy_list (e->in_reply_to);
-
- if (e->message_id) {
- t = mutt_new_list ();
- t->data = m_strdup(e->message_id);
- t->next = l;
- l = t;
- }
-
- return l;
-}
-
void mutt_fix_reply_recipients (ENVELOPE * env)
{
mutt_expand_aliases_env (env);
}
/* the CC field can get cluttered, especially with lists */
- env->to = mutt_remove_duplicates (env->to);
- env->cc = mutt_remove_duplicates (env->cc);
+ address_list_uniq(env->to);
+ address_list_uniq(env->cc);
env->cc = mutt_remove_xrefs (env->to, env->cc);
if (env->cc && !env->to) {
/* set the default subject for the message. */
mutt_make_string (buffer, sizeof (buffer), NONULL (ForwFmt), ctx, cur);
- str_replace (&env->subject, buffer);
+ m_strreplace(&env->subject, buffer);
}
void mutt_make_misc_reply_headers (ENVELOPE * env, CONTEXT * ctx,
#endif
}
+static string_list_t *mutt_make_references (ENVELOPE * e)
+{
+ string_list_t *t = NULL, *l = NULL;
+
+ if (e->references)
+ l = string_list_dup(e->references);
+ else
+ l = string_list_dup(e->in_reply_to);
+
+ if (e->message_id) {
+ t = string_item_new();
+ t->data = m_strdup(e->message_id);
+ t->next = l;
+ l = t;
+ }
+
+ return l;
+}
+
void mutt_add_to_reference_headers (ENVELOPE * env, ENVELOPE * curenv,
- LIST *** pp, LIST *** qq)
+ string_list_t *** pp, string_list_t *** qq)
{
- LIST **p = NULL, **q = NULL;
+ string_list_t **p = NULL, **q = NULL;
if (pp)
p = *pp;
*p = mutt_make_references (curenv);
if (curenv->message_id) {
- *q = mutt_new_list ();
+ *q = string_item_new();
(*q)->data = m_strdup(curenv->message_id);
}
if (!curenv) {
HEADER *h;
- LIST **p = NULL, **q = NULL;
+ string_list_t **p = NULL, **q = NULL;
int i;
for (i = 0; i < ctx->vcount; i++) {
else if (i == -1)
return -1;
}
- /* if (WithCrypto && (flags & SENDKEY)) */
- else if ((WithCrypto & APPLICATION_PGP) && (flags & SENDKEY)) {
+ else if (flags & SENDKEY) {
BODY *tmp;
- if ((WithCrypto & APPLICATION_PGP)
- && (tmp = crypt_pgp_make_key_attachment (NULL)) == NULL)
+ if ((tmp = crypt_pgp_make_key_attachment (NULL)) == NULL)
return -1;
tmp->next = msg->content;
void mutt_set_followup_to (ENVELOPE * e)
{
- ADDRESS *t = NULL;
- ADDRESS *from;
+ address_t *from;
/*
* Only generate the Mail-Followup-To if the user has requested it, and
if (!e->mail_followup_to) {
if (mutt_is_list_cc (0, e->to, e->cc)) {
+ address_t **tmp;
/*
* this message goes to known mailing lists, so create a proper
* mail-followup-to header
*/
- t = rfc822_append (&e->mail_followup_to, e->to);
- rfc822_append (&t, e->cc);
+ tmp = address_list_append(&e->mail_followup_to, address_list_dup(e->to));
+ address_list_append(tmp, address_list_dup(e->cc));
}
/* remove ourselves from the mail-followup-to header */
if (e->mail_followup_to && !mutt_is_list_recipient (0, e->to, e->cc)) {
if (e->reply_to)
- from = rfc822_cpy_adr (e->reply_to);
+ from = address_list_dup (e->reply_to);
else if (e->from)
- from = rfc822_cpy_adr (e->from);
+ from = address_list_dup (e->from);
else
from = mutt_default_from ();
if (from) {
- /* Normally, this loop will not even be entered. */
- for (t = from; t && t->next; t = t->next);
-
- t->next = e->mail_followup_to; /* t cannot be NULL at this point. */
+ address_list_append(&from->next, e->mail_followup_to);
e->mail_followup_to = from;
}
}
- e->mail_followup_to = mutt_remove_duplicates (e->mail_followup_to);
+ address_list_uniq(e->mail_followup_to);
}
}
/* look through the recipients of the message we are replying to, and if
we find an address that matches $alternates, we use that as the default
from field */
-static ADDRESS *set_reverse_name (ENVELOPE * env)
+static address_t *set_reverse_name (ENVELOPE * env)
{
- ADDRESS *tmp;
+ address_t *tmp;
for (tmp = env->to; tmp; tmp = tmp->next) {
if (mutt_addr_is_user (tmp))
if (!tmp && mutt_addr_is_user (env->from))
tmp = env->from;
if (tmp) {
- tmp = rfc822_cpy_adr_real (tmp);
+ tmp = address_dup (tmp);
if (!option (OPTREVREAL))
p_delete(&tmp->personal);
if (!tmp->personal)
return (tmp);
}
-ADDRESS *mutt_default_from (void)
+address_t *mutt_default_from (void)
{
- ADDRESS *adr;
+ address_t *adr;
const char *fqdn = mutt_fqdn (1);
/*
*/
if (From)
- adr = rfc822_cpy_adr_real (From);
+ adr = address_dup (From);
else if (option (OPTUSEDOMAIN)) {
- adr = rfc822_new_address ();
+ adr = address_new ();
adr->mailbox = p_new(char, m_strlen(Username) + m_strlen(fqdn) + 2);
sprintf (adr->mailbox, "%s@%s", NONULL (Username), NONULL (fqdn)); /* __SPRINTF_CHECKED__ */
}
else {
- adr = rfc822_new_address ();
+ adr = address_new ();
adr->mailbox = m_strdup(NONULL (Username));
}
int i;
/* Write out the message in MIME form. */
- mutt_mktemp (tempfile);
- if ((tempfp = safe_fopen (tempfile, "w")) == NULL)
- return (-1);
+ tempfp = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
+ if (!tempfp)
+ return -1;
#ifdef MIXMASTER
mutt_write_rfc822_header (tempfp, msg->env, msg->content, 0,
fputc ('\n', tempfp); /* tie off the header. */
if ((mutt_write_mime_body (msg->content, tempfp) == -1)) {
- fclose (tempfp);
+ m_fclose(&tempfp);
unlink (tempfile);
return (-1);
}
- if (fclose (tempfp) != 0) {
+ if (m_fclose(&tempfp) != 0) {
mutt_perror (tempfile);
unlink (tempfile);
return (-1);
fseeko (fp, -1, SEEK_END);
if ((c = fgetc (fp)) != '\n')
fputc ('\n', fp);
- safe_fclose (&fp);
+ m_fclose(&fp);
}
int mutt_resend_message (FILE * fp, CONTEXT * ctx, HEADER * cur)
{
- HEADER *msg = mutt_new_header ();
+ HEADER *msg = header_new();
if (mutt_prepare_template (fp, ctx, msg, cur, 1) < 0)
return -1;
CONTEXT * ctx, /* current mailbox */
HEADER * cur)
{ /* current message */
- char buffer[LONG_STRING];
char fcc[_POSIX_PATH_MAX] = ""; /* where to copy this message */
FILE *tempfp = NULL;
BODY *pbody;
}
- if ((WithCrypto & APPLICATION_PGP) && (flags & SENDPOSTPONED))
+ if (flags & SENDPOSTPONED)
signas = m_strdup(PgpSignAs);
/* Delay expansion of aliases until absolutely necessary--shouldn't
*/
if (!msg) {
- msg = mutt_new_header ();
+ msg = header_new();
if (flags == SENDPOSTPONED) {
if ((flags =
}
if (!msg->env)
- msg->env = mutt_new_envelope ();
+ msg->env = envelope_new();
}
/* Parse and use an eventual list-post header */
/* Use any list-post header as a template */
url_parse_mailto (msg->env, NULL, cur->env->list_post);
/* We don't let them set the sender's address. */
- rfc822_free_address (&msg->env->from);
+ address_list_wipe(&msg->env->from);
}
if (!(flags & (SENDKEY | SENDPOSTPONED | SENDRESEND))) {
- pbody = mutt_new_body ();
+ pbody = body_new();
pbody->next = msg->content; /* don't kill command-line attachments */
msg->content = pbody;
msg->content->disposition = DISPINLINE;
if (option (OPTTEXTFLOWED) && msg->content->type == TYPETEXT
&& !ascii_strcasecmp (msg->content->subtype, "plain")) {
- mutt_set_parameter ("format", "flowed", &msg->content->parameter);
+ parameter_setval(&msg->content->parameter, "format", "flowed");
if (option (OPTDELSP))
- mutt_set_parameter ("delsp", "yes", &msg->content->parameter);
+ parameter_setval(&msg->content->parameter, "delsp", "yes");
}
if (!tempfile) {
- mutt_mktemp (buffer);
- tempfp = safe_fopen (buffer, "w+");
+ char buffer[_POSIX_PATH_MAX];
+ tempfp = m_tempfile(buffer, sizeof(buffer), NONULL(Tempdir), NULL);
msg->content->filename = m_strdup(buffer);
- }
- else {
- tempfp = safe_fopen (tempfile, "a+");
+ } else {
+ tempfp = safe_fopen(tempfile, "a+");
msg->content->filename = m_strdup(tempfile);
}
if (!tempfp) {
- debug_print (1, ("can't create tempfile %s (errno=%d)\n",
- msg->content->filename, errno));
mutt_perror (msg->content->filename);
goto cleanup;
}
msg->env->newsgroups = m_strdup(((NNTP_DATA *) ctx->data)->group);
#endif
- if (!(flags & SENDMAILX) &&
- !(option (OPTAUTOEDIT) && option (OPTEDITHDRS)) &&
+ if (!(option (OPTAUTOEDIT) && option (OPTEDITHDRS)) &&
!((flags & SENDREPLY) && option (OPTFASTREPLY))) {
if (edit_envelope (msg->env, flags) == -1)
goto cleanup;
msg->replied = 0;
if (killfrom) {
- rfc822_free_address (&msg->env->from);
+ address_list_wipe(&msg->env->from);
killfrom = 0;
}
process_user_header (msg->env);
- if (option (OPTSIGONTOP)
- && (!(flags & (SENDMAILX | SENDKEY)) && Editor
- && m_strcmp(Editor, "builtin") != 0))
+ if (option (OPTSIGONTOP) && (!(flags & SENDKEY) && Editor))
append_signature (tempfp);
/* include replies/forwarded messages, unless we are given a template */
&& generate_body (tempfp, msg, flags, ctx, cur) == -1)
goto cleanup;
- if (!option (OPTSIGONTOP)
- && (!(flags & (SENDMAILX | SENDKEY)) && Editor
- && m_strcmp(Editor, "builtin") != 0))
+ if (!option (OPTSIGONTOP) && (!(flags & SENDKEY) && Editor))
append_signature (tempfp);
/*
* can take effect.
*/
- if (WithCrypto && !(flags & SENDMAILX)) {
- if (option (OPTCRYPTAUTOSIGN))
- msg->security |= SIGN;
- if (option (OPTCRYPTAUTOENCRYPT))
- msg->security |= ENCRYPT;
- if (option (OPTCRYPTREPLYENCRYPT) && cur && (cur->security & ENCRYPT))
- msg->security |= ENCRYPT;
- if (option (OPTCRYPTREPLYSIGN) && cur && (cur->security & SIGN))
- msg->security |= SIGN;
- if (option (OPTCRYPTREPLYSIGNENCRYPTED) && cur
- && (cur->security & ENCRYPT))
- msg->security |= SIGN;
- if (WithCrypto & APPLICATION_PGP && (msg->security & (ENCRYPT | SIGN))) {
- if (option (OPTPGPAUTOINLINE))
- msg->security |= INLINE;
- if (option (OPTPGPREPLYINLINE) && cur && (cur->security & INLINE))
- msg->security |= INLINE;
- }
+ if (option (OPTCRYPTAUTOSIGN))
+ msg->security |= SIGN;
+ if (option (OPTCRYPTAUTOENCRYPT))
+ msg->security |= ENCRYPT;
+ if (option (OPTCRYPTREPLYENCRYPT) && cur && (cur->security & ENCRYPT))
+ msg->security |= ENCRYPT;
+ if (option (OPTCRYPTREPLYSIGN) && cur && (cur->security & SIGN))
+ msg->security |= SIGN;
+ if (option (OPTCRYPTREPLYSIGNENCRYPTED) && cur
+ && (cur->security & ENCRYPT))
+ msg->security |= SIGN;
+ if (msg->security & (ENCRYPT | SIGN)) {
+ if (option (OPTPGPAUTOINLINE))
+ msg->security |= INLINE;
+ if (option (OPTPGPREPLYINLINE) && cur && (cur->security & INLINE))
+ msg->security |= INLINE;
}
- if (WithCrypto && msg->security) {
+ if (msg->security) {
/*
* When reypling / forwarding, use the original message's
* crypto system. According to the documentation,
* disable individual mechanisms at run-time?
*/
if (cur) {
- if ((WithCrypto & APPLICATION_PGP) && option (OPTCRYPTAUTOPGP)
- && (cur->security & APPLICATION_PGP))
+ if (option (OPTCRYPTAUTOPGP) && (cur->security & APPLICATION_PGP))
msg->security |= APPLICATION_PGP;
- else if ((WithCrypto & APPLICATION_SMIME)
- && option (OPTCRYPTAUTOSMIME)
+ else if (option (OPTCRYPTAUTOSMIME)
&& (cur->security & APPLICATION_SMIME))
msg->security |= APPLICATION_SMIME;
}
* for the decision.
*/
if (!(msg->security & (APPLICATION_SMIME | APPLICATION_PGP))) {
- if ((WithCrypto & APPLICATION_SMIME) && option (OPTCRYPTAUTOSMIME)
- && option (OPTSMIMEISDEFAULT))
+ if (option (OPTCRYPTAUTOSMIME) && option (OPTSMIMEISDEFAULT))
msg->security |= APPLICATION_SMIME;
- else if ((WithCrypto & APPLICATION_PGP) && option (OPTCRYPTAUTOPGP))
+ else if (option (OPTCRYPTAUTOPGP))
msg->security |= APPLICATION_PGP;
- else if ((WithCrypto & APPLICATION_SMIME)
- && option (OPTCRYPTAUTOSMIME))
+ else if (option (OPTCRYPTAUTOSMIME))
msg->security |= APPLICATION_SMIME;
}
}
&& !(flags & (SENDRESEND | SENDPOSTPONED)))
msg->env->from->personal = m_strdup(Realname);
- if (!((WithCrypto & APPLICATION_PGP) && (flags & SENDKEY)))
- safe_fclose (&tempfp);
+ if (!(flags & SENDKEY))
+ m_fclose(&tempfp);
- if (flags & SENDMAILX) {
- if (mutt_builtin_editor (msg->content->filename, msg, cur) == -1)
- goto cleanup;
- }
- else if (!(flags & SENDBATCH)) {
+ if (!(flags & SENDBATCH)) {
struct stat st;
time_t mtime = mutt_decrease_mtime (msg->content->filename, NULL);
query_quadoption (OPT_FORWEDIT,
_("Edit forwarded message?")) == M_YES)) {
/* If the this isn't a text message, look for a mailcap edit command */
- if (mutt_needs_mailcap (msg->content)) {
+ if (rfc1524_mailcap_isneeded(msg->content)) {
if (!mutt_edit_attachment (msg->content))
goto cleanup;
- } else if (!Editor || m_strcmp("builtin", Editor) == 0)
- mutt_builtin_editor (msg->content->filename, msg, cur);
- else if (option (OPTEDITHDRS)) {
+ } else if (option (OPTEDITHDRS)) {
mutt_env_to_local (msg->env);
mutt_edit_headers (Editor, msg->content->filename, msg, fcc,
sizeof (fcc));
}
mutt_select_fcc (fcc, sizeof (fcc), msg);
if (killfrom) {
- rfc822_free_address (&msg->env->from);
+ address_list_wipe(&msg->env->from);
killfrom = 0;
}
}
mutt_update_encoding (msg->content);
- if (!(flags & (SENDMAILX | SENDBATCH))) {
+ if (!(flags & SENDBATCH)) {
main_loop:
fcc_error = 0; /* reset value since we may have failed before */
clear_content = NULL;
free_clear_content = 0;
- if (WithCrypto) {
- if (msg->security) {
- /* save the decrypted attachments */
- clear_content = msg->content;
+ if (msg->security) {
+ /* save the decrypted attachments */
+ clear_content = msg->content;
- if ((crypt_get_keys (msg, &pgpkeylist) == -1) ||
- mutt_protect (msg, pgpkeylist) == -1) {
- msg->content = mutt_remove_multipart (msg->content);
+ if ((crypt_get_keys (msg, &pgpkeylist) == -1) ||
+ mutt_protect (msg, pgpkeylist) == -1) {
+ msg->content = mutt_remove_multipart (msg->content);
- p_delete(&pgpkeylist);
+ p_delete(&pgpkeylist);
- decode_descriptions (msg->content);
- goto main_loop;
- }
- encode_descriptions (msg->content, 0);
+ decode_descriptions (msg->content);
+ goto main_loop;
}
+ encode_descriptions (msg->content, 0);
+ }
- /*
- * at this point, msg->content is one of the following three things:
- * - multipart/signed. In this case, clear_content is a child.
- * - multipart/encrypted. In this case, clear_content exists
- * independently
- * - application/pgp. In this case, clear_content exists independently.
- * - something else. In this case, it's the same as clear_content.
- */
+ /*
+ * at this point, msg->content is one of the following three things:
+ * - multipart/signed. In this case, clear_content is a child.
+ * - multipart/encrypted. In this case, clear_content exists
+ * independently
+ * - application/pgp. In this case, clear_content exists independently.
+ * - something else. In this case, it's the same as clear_content.
+ */
- /* This is ugly -- lack of "reporting back" from mutt_protect(). */
+ /* This is ugly -- lack of "reporting back" from mutt_protect(). */
- if (clear_content && (msg->content != clear_content)
- && (msg->content->parts != clear_content))
- free_clear_content = 1;
- }
+ if (clear_content && (msg->content != clear_content)
+ && (msg->content->parts != clear_content))
+ free_clear_content = 1;
- if (!option (OPTNOCURSES) && !(flags & SENDMAILX))
+ if (!option (OPTNOCURSES))
mutt_message _("Sending message...");
mutt_prepare_envelope (msg->env, 1);
* I'd like to think a bit more about this before including it.
*/
-#ifdef USE_IMAP
if ((flags & SENDBATCH) && fcc[0] && mx_get_magic (fcc) == M_IMAP)
fcc[0] = '\0';
-#endif
if (*fcc && m_strcmp("/dev/null", fcc) != 0) {
BODY *tmpbody = msg->content;
BODY *save_sig = NULL;
BODY *save_parts = NULL;
- if (WithCrypto && msg->security && option (OPTFCCCLEAR))
+ if (msg->security && option (OPTFCCCLEAR))
msg->content = clear_content;
/* check to see if the user wants copies of all attachments */
if (!option (OPTFCCATTACH) && msg->content->type == TYPEMULTIPART) {
- if (WithCrypto
- && (m_strcmp(msg->content->subtype, "encrypted") == 0 ||
- m_strcmp(msg->content->subtype, "signed") == 0)) {
+ if ((m_strcmp(msg->content->subtype, "encrypted") == 0 ||
+ m_strcmp(msg->content->subtype, "signed") == 0))
+ {
if (clear_content->type == TYPEMULTIPART) {
if (!(msg->security & ENCRYPT) && (msg->security & SIGN)) {
/* save initial signature and attachments */
msg->content = tmpbody;
- if (WithCrypto && save_sig) {
+ if (save_sig) {
/* cleanup the second signature structures */
if (save_content->parts) {
- mutt_free_body (&save_content->parts->next);
+ body_list_wipe(&save_content->parts->next);
save_content->parts = NULL;
}
- mutt_free_body (&save_content);
+ body_list_wipe(&save_content);
/* restore old signature and attachments */
msg->content->parts->next = save_sig;
msg->content->parts->parts->next = save_parts;
}
- else if (WithCrypto && save_content) {
+ else if (save_content) {
/* destroy the new encrypted body. */
- mutt_free_body (&save_content);
+ body_list_wipe(&save_content);
}
}
*/
if (fcc_error || (i = send_message (msg)) == -1) {
if (!(flags & SENDBATCH)) {
- if (!WithCrypto);
- else if ((msg->security & ENCRYPT) || ((msg->security & SIGN)
- && msg->content->type ==
- TYPEAPPLICATION)) {
- mutt_free_body (&msg->content); /* destroy PGP data */
+ if ((msg->security & ENCRYPT)
+ || ((msg->security & SIGN)
+ && msg->content->type == TYPEAPPLICATION)) {
+ body_list_wipe(&msg->content); /* destroy PGP data */
msg->content = clear_content; /* restore clear text. */
}
else if ((msg->security & SIGN) && msg->content->type == TYPEMULTIPART) {
- mutt_free_body (&msg->content->parts->next); /* destroy sig */
+ body_list_wipe(&msg->content->parts->next); /* destroy sig */
msg->content = mutt_remove_multipart (msg->content);
}
goto cleanup;
}
}
- else if (!option (OPTNOCURSES) && !(flags & SENDMAILX))
+ else if (!option (OPTNOCURSES))
mutt_message (i != 0 ? _("Sending in background.") :
#ifdef USE_NNTP
(flags & SENDNEWS) ? _("Article posted.") :
- _("Mail sent."));
+ _("Mail sent.")
#else
- _("Mail sent."));
+ _("Mail sent.")
#endif
-
- if (WithCrypto && (msg->security & ENCRYPT))
+ );
+ if (msg->security & ENCRYPT)
p_delete(&pgpkeylist);
- if (WithCrypto && free_clear_content)
- mutt_free_body (&clear_content);
+ if (free_clear_content)
+ body_list_wipe(&clear_content);
if (flags & SENDREPLY) {
if (cur && ctx)
cleanup:
- if ((WithCrypto & APPLICATION_PGP) && (flags & SENDPOSTPONED)) {
+ if (flags & SENDPOSTPONED) {
if (signas) {
p_delete(&PgpSignAs);
PgpSignAs = signas;
}
}
- safe_fclose (&tempfp);
- mutt_free_header (&msg);
+ m_fclose(&tempfp);
+ header_delete(&msg);
return rv;
}
projects / apps / madmutt.git / blobdiff