FILE* mutt_bcache_put(body_cache_t *bcache, const char *id, int tmp)
{
char path[_POSIX_PATH_MAX];
FILE* fp;
char* s;
struct stat sb;
if (!id || !*id || !bcache)
return NULL;
snprintf (path, sizeof (path), "%s%s%s", bcache->path, id,
tmp ? ".tmp" : "");
if ((fp = safe_fopen (path, "w+")))
goto out;
if (errno == EEXIST)
/* clean up leftover tmp file */
mutt_unlink (path);
s = strchr (path + 1, '/');
while (!(fp = safe_fopen (path, "w+")) && errno == ENOENT && s) {
/* create missing path components */
*s = '\0';
if (stat (path, &sb) < 0 && (errno != ENOENT || mkdir (path, 0777) < 0))
return NULL;
*s = '/';
s = strchr (s + 1, '/');
}
out:
dprint (3, (debugfile, "bcache: put: '%s'\n", path));
return fp;
}
int mutt_do_pager (const char *banner,
const char *tempfile,
int do_color,
pager_t *info)
{
int rc;
if (!Pager || mutt_strcmp (Pager, "builtin") == 0)
rc = mutt_pager (banner, tempfile, do_color, info);
else
{
char cmd[STRING];
endwin ();
mutt_expand_file_fmt (cmd, sizeof(cmd), Pager, tempfile);
if (mutt_system (cmd) == -1)
{
mutt_error (_("Error running \"%s\"!"), cmd);
rc = -1;
}
else
rc = 0;
mutt_unlink (tempfile);
}
return rc;
}
int _mutt_rename_file (char *oldfile, char *newfile, int overwrite)
{
FILE *ofp, *nfp;
if (access (oldfile, F_OK) != 0)
return 1;
if (!overwrite && access (newfile, F_OK) == 0)
return 2;
if ((ofp = fopen (oldfile, "r")) == NULL)
return 3;
if ((nfp = safe_fopen (newfile, "w")) == NULL) {
fclose (ofp);
return 3;
}
mutt_copy_stream (ofp, nfp);
fclose (nfp);
fclose (ofp);
mutt_unlink (oldfile);
return 0;
}
int mutt_print_attachment (FILE *fp, BODY *a)
{
char newfile[_POSIX_PATH_MAX] = "";
char type[STRING];
pid_t thepid;
FILE *ifp, *fpout;
short unlink_newfile = 0;
snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
if (rfc1524_mailcap_lookup (a, type, NULL, M_PRINT))
{
char command[_POSIX_PATH_MAX+STRING];
rfc1524_entry *entry;
int piped = FALSE;
dprint (2, (debugfile, "Using mailcap...\n"));
entry = rfc1524_new_entry ();
rfc1524_mailcap_lookup (a, type, entry, M_PRINT);
if (rfc1524_expand_filename (entry->nametemplate, a->filename,
newfile, sizeof (newfile)))
{
if (!fp)
{
if (safe_symlink(a->filename, newfile) == -1)
{
if (mutt_yesorno (_("Can't match nametemplate, continue?"), M_YES) != M_YES)
{
rfc1524_free_entry (&entry);
return 0;
}
strfcpy (newfile, a->filename, sizeof (newfile));
}
else
unlink_newfile = 1;
}
}
/* in recv mode, save file to newfile first */
if (fp)
mutt_save_attachment (fp, a, newfile, 0, NULL);
strfcpy (command, entry->printcommand, sizeof (command));
piped = rfc1524_expand_command (a, newfile, type, command, sizeof (command));
mutt_endwin (NULL);
/* interactive program */
if (piped)
{
if ((ifp = fopen (newfile, "r")) == NULL)
{
mutt_perror ("fopen");
rfc1524_free_entry (&entry);
return (0);
}
if ((thepid = mutt_create_filter (command, &fpout, NULL, NULL)) < 0)
{
mutt_perror _("Can't create filter");
rfc1524_free_entry (&entry);
safe_fclose (&ifp);
return 0;
}
mutt_copy_stream (ifp, fpout);
safe_fclose (&fpout);
safe_fclose (&ifp);
if (mutt_wait_filter (thepid) || option (OPTWAITKEY))
mutt_any_key_to_continue (NULL);
}
else
{
if (mutt_system (command) || option (OPTWAITKEY))
mutt_any_key_to_continue (NULL);
}
if (fp)
mutt_unlink (newfile);
else if (unlink_newfile)
unlink(newfile);
rfc1524_free_entry (&entry);
return (1);
}
if (!ascii_strcasecmp ("text/plain", type) ||
!ascii_strcasecmp ("application/postscript", type))
{
return (mutt_pipe_attachment (fp, a, NONULL(PrintCmd), NULL));
}
else if (mutt_can_decode (a))
{
/* decode and print */
int rc = 0;
ifp = NULL;
fpout = NULL;
mutt_mktemp (newfile, sizeof (newfile));
if (mutt_decode_save_attachment (fp, a, newfile, M_PRINTING, 0) == 0)
{
dprint (2, (debugfile, "successfully decoded %s type attachment to %s\n",
type, newfile));
if ((ifp = fopen (newfile, "r")) == NULL)
{
mutt_perror ("fopen");
goto bail0;
}
dprint (2, (debugfile, "successfully opened %s read-only\n", newfile));
mutt_endwin (NULL);
if ((thepid = mutt_create_filter (NONULL(PrintCmd), &fpout, NULL, NULL)) < 0)
{
mutt_perror _("Can't create filter");
goto bail0;
}
dprint (2, (debugfile, "Filter created.\n"));
mutt_copy_stream (ifp, fpout);
safe_fclose (&fpout);
safe_fclose (&ifp);
if (mutt_wait_filter (thepid) != 0 || option (OPTWAITKEY))
mutt_any_key_to_continue (NULL);
rc = 1;
}
bail0:
safe_fclose (&ifp);
safe_fclose (&fpout);
mutt_unlink (newfile);
return rc;
}
else
{
mutt_error _("I don't know how to print that!");
return 0;
}
}
/* return 1 if require full screen redraw, 0 otherwise */
int mutt_compose_attachment (BODY *a)
{
char type[STRING];
char command[STRING];
char newfile[_POSIX_PATH_MAX] = "";
rfc1524_entry *entry = rfc1524_new_entry ();
short unlink_newfile = 0;
int rc = 0;
snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
if (rfc1524_mailcap_lookup (a, type, entry, M_COMPOSE))
{
if (entry->composecommand || entry->composetypecommand)
{
if (entry->composetypecommand)
strfcpy (command, entry->composetypecommand, sizeof (command));
else
strfcpy (command, entry->composecommand, sizeof (command));
if (rfc1524_expand_filename (entry->nametemplate,
a->filename, newfile, sizeof (newfile)))
{
dprint(1, (debugfile, "oldfile: %s\t newfile: %s\n",
a->filename, newfile));
if (safe_symlink (a->filename, newfile) == -1)
{
if (mutt_yesorno (_("Can't match nametemplate, continue?"), M_YES) != M_YES)
goto bailout;
}
else
unlink_newfile = 1;
}
else
strfcpy(newfile, a->filename, sizeof(newfile));
if (rfc1524_expand_command (a, newfile, type,
command, sizeof (command)))
{
/* For now, editing requires a file, no piping */
mutt_error _("Mailcap compose entry requires %%s");
}
else
{
int r;
mutt_endwin (NULL);
if ((r = mutt_system (command)) == -1)
mutt_error (_("Error running \"%s\"!"), command);
if (r != -1 && entry->composetypecommand)
{
BODY *b;
FILE *fp, *tfp;
char tempfile[_POSIX_PATH_MAX];
if ((fp = safe_fopen (a->filename, "r")) == NULL)
{
mutt_perror _("Failure to open file to parse headers.");
goto bailout;
}
b = mutt_read_mime_header (fp, 0);
if (b)
{
if (b->parameter)
{
mutt_free_parameter (&a->parameter);
a->parameter = b->parameter;
b->parameter = NULL;
}
if (b->description) {
FREE (&a->description);
a->description = b->description;
b->description = NULL;
}
if (b->form_name)
{
FREE (&a->form_name);
a->form_name = b->form_name;
b->form_name = NULL;
}
/* Remove headers by copying out data to another file, then
* copying the file back */
fseeko (fp, b->offset, 0);
mutt_mktemp (tempfile, sizeof (tempfile));
if ((tfp = safe_fopen (tempfile, "w")) == NULL)
{
mutt_perror _("Failure to open file to strip headers.");
goto bailout;
}
mutt_copy_stream (fp, tfp);
safe_fclose (&fp);
safe_fclose (&tfp);
mutt_unlink (a->filename);
if (mutt_rename_file (tempfile, a->filename) != 0)
{
mutt_perror _("Failure to rename file.");
goto bailout;
}
mutt_free_body (&b);
}
}
}
}
}
else
{
rfc1524_free_entry (&entry);
mutt_message (_("No mailcap compose entry for %s, creating empty file."),
type);
return 1;
}
rc = 1;
bailout:
if(unlink_newfile)
unlink(newfile);
rfc1524_free_entry (&entry);
return rc;
}
/* returns -1 on error, 0 or the return code from mutt_do_pager() on success */
int mutt_view_attachment (FILE *fp, BODY *a, int flag, HEADER *hdr,
ATTACHPTR **idx, short idxlen)
{
char tempfile[_POSIX_PATH_MAX] = "";
char pagerfile[_POSIX_PATH_MAX] = "";
int is_message;
int use_mailcap;
int use_pipe = 0;
int use_pager = 1;
char type[STRING];
char command[HUGE_STRING];
char descrip[STRING];
char *fname;
rfc1524_entry *entry = NULL;
int rc = -1;
int unlink_tempfile = 0;
is_message = mutt_is_message_type(a->type, a->subtype);
if (WithCrypto && is_message && a->hdr && (a->hdr->security & ENCRYPT) &&
!crypt_valid_passphrase(a->hdr->security))
return (rc);
use_mailcap = (flag == M_MAILCAP ||
(flag == M_REGULAR && mutt_needs_mailcap (a)));
snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
if (use_mailcap)
{
entry = rfc1524_new_entry ();
if (!rfc1524_mailcap_lookup (a, type, entry, 0))
{
if (flag == M_REGULAR)
{
/* fallback to view as text */
rfc1524_free_entry (&entry);
mutt_error _("No matching mailcap entry found. Viewing as text.");
flag = M_AS_TEXT;
use_mailcap = 0;
}
else
goto return_error;
}
}
if (use_mailcap)
{
if (!entry->command)
{
mutt_error _("MIME type not defined. Cannot view attachment.");
goto return_error;
}
strfcpy (command, entry->command, sizeof (command));
if (fp)
{
fname = safe_strdup (a->filename);
mutt_sanitize_filename (fname, 1);
}
else
fname = a->filename;
if (rfc1524_expand_filename (entry->nametemplate, fname,
tempfile, sizeof (tempfile)))
{
if (fp == NULL && mutt_strcmp(tempfile, a->filename))
{
/* send case: the file is already there */
if (safe_symlink (a->filename, tempfile) == -1)
{
if (mutt_yesorno (_("Can't match nametemplate, continue?"), M_YES) == M_YES)
strfcpy (tempfile, a->filename, sizeof (tempfile));
else
goto return_error;
}
else
unlink_tempfile = 1;
}
}
else if (fp == NULL) /* send case */
strfcpy (tempfile, a->filename, sizeof (tempfile));
if (fp)
{
/* recv case: we need to save the attachment to a file */
FREE (&fname);
if (mutt_save_attachment (fp, a, tempfile, 0, NULL) == -1)
goto return_error;
}
use_pipe = rfc1524_expand_command (a, tempfile, type,
command, sizeof (command));
use_pager = entry->copiousoutput;
}
if (use_pager)
{
if (fp && !use_mailcap && a->filename)
{
/* recv case */
strfcpy (pagerfile, a->filename, sizeof (pagerfile));
mutt_adv_mktemp (pagerfile, sizeof(pagerfile));
}
else
mutt_mktemp (pagerfile, sizeof (pagerfile));
}
if (use_mailcap)
{
pid_t thepid = 0;
int tempfd = -1, pagerfd = -1;
if (!use_pager)
mutt_endwin (NULL);
if (use_pager || use_pipe)
{
if (use_pager && ((pagerfd = safe_open (pagerfile, O_CREAT | O_EXCL | O_WRONLY)) == -1))
{
mutt_perror ("open");
goto return_error;
}
if (use_pipe && ((tempfd = open (tempfile, 0)) == -1))
{
if(pagerfd != -1)
close(pagerfd);
mutt_perror ("open");
goto return_error;
}
if ((thepid = mutt_create_filter_fd (command, NULL, NULL, NULL,
use_pipe ? tempfd : -1, use_pager ? pagerfd : -1, -1)) == -1)
{
if(pagerfd != -1)
close(pagerfd);
if(tempfd != -1)
close(tempfd);
mutt_error _("Cannot create filter");
goto return_error;
}
if (use_pager)
{
if (a->description)
snprintf (descrip, sizeof (descrip),
_("---Command: %-20.20s Description: %s"),
command, a->description);
else
snprintf (descrip, sizeof (descrip),
_("---Command: %-30.30s Attachment: %s"), command, type);
}
if ((mutt_wait_filter (thepid) || (entry->needsterminal &&
option (OPTWAITKEY))) && !use_pager)
mutt_any_key_to_continue (NULL);
if (tempfd != -1)
close (tempfd);
if (pagerfd != -1)
close (pagerfd);
}
else
{
/* interactive command */
if (mutt_system (command) ||
(entry->needsterminal && option (OPTWAITKEY)))
mutt_any_key_to_continue (NULL);
}
}
else
{
/* Don't use mailcap; the attachment is viewed in the pager */
if (flag == M_AS_TEXT)
{
/* just let me see the raw data */
if (mutt_save_attachment (fp, a, pagerfile, 0, NULL))
goto return_error;
}
else
{
/* Use built-in handler */
set_option (OPTVIEWATTACH); /* disable the "use 'v' to view this part"
* message in case of error */
if (mutt_decode_save_attachment (fp, a, pagerfile, M_DISPLAY, 0))
{
unset_option (OPTVIEWATTACH);
goto return_error;
}
unset_option (OPTVIEWATTACH);
}
if (a->description)
strfcpy (descrip, a->description, sizeof (descrip));
else if (a->filename)
snprintf (descrip, sizeof (descrip), _("---Attachment: %s: %s"),
a->filename, type);
else
snprintf (descrip, sizeof (descrip), _("---Attachment: %s"), type);
}
/* We only reach this point if there have been no errors */
if (use_pager)
{
pager_t info;
memset (&info, 0, sizeof (info));
info.fp = fp;
info.bdy = a;
info.ctx = Context;
info.idx = idx;
info.idxlen = idxlen;
info.hdr = hdr;
rc = mutt_do_pager (descrip, pagerfile,
M_PAGER_ATTACHMENT | (is_message ? M_PAGER_MESSAGE : 0), &info);
*pagerfile = '\0';
}
else
rc = 0;
return_error:
if (entry)
rfc1524_free_entry (&entry);
if (fp && tempfile[0])
mutt_unlink (tempfile);
else if (unlink_tempfile)
unlink(tempfile);
if (pagerfile[0])
mutt_unlink (pagerfile);
return rc;
}
void mutt_edit_headers (const char *editor,
const char *body,
HEADER *msg,
char *fcc,
size_t fcclen)
{
char path[_POSIX_PATH_MAX]; /* tempfile used to edit headers + body */
char buffer[LONG_STRING];
char *p;
FILE *ifp, *ofp;
int i, keep;
int in_reply_to = 0; /* did we see the in-reply-to field ? */
ENVELOPE *n;
time_t mtime;
struct stat st;
LIST *cur, *last = NULL, *tmp;
mutt_mktemp (path);
if ((ofp = safe_fopen (path, "w")) == NULL)
{
mutt_perror (path);
return;
}
mutt_write_rfc822_header (ofp, msg->env, NULL, 1, 0);
fputc ('\n', ofp); /* tie off the header. */
/* now copy the body of the message. */
if ((ifp = fopen (body, "r")) == NULL)
{
mutt_perror (body);
return;
}
mutt_copy_stream (ifp, ofp);
fclose (ifp);
fclose (ofp);
if (stat (path, &st) == -1)
{
mutt_perror (path);
return;
}
mtime = st.st_mtime;
mutt_edit_file (editor, path);
stat (path, &st);
if (mtime == st.st_mtime)
{
dprint (1, (debugfile, "ci_edit_headers(): temp file was not modified.\n"));
/* the file has not changed! */
mutt_unlink (path);
return;
}
mutt_unlink (body);
mutt_free_list (&msg->env->userhdrs);
/* Read the temp file back in */
if ((ifp = fopen (path, "r")) == NULL)
{
mutt_perror (path);
return;
}
if ((ofp = safe_fopen (body, "w")) == NULL)
{
/* intentionally leak a possible temporary file here */
fclose (ifp);
mutt_perror (body);
return;
}
n = mutt_read_rfc822_header (ifp, NULL, 1, 0);
while ((i = fread (buffer, 1, sizeof (buffer), ifp)) > 0)
fwrite (buffer, 1, i, ofp);
fclose (ofp);
fclose (ifp);
mutt_unlink (path);
/* restore old info. */
n->references = msg->env->references;
msg->env->references = NULL;
mutt_free_envelope (&msg->env);
msg->env = n;
mutt_expand_aliases_env (msg->env);
/* search through the user defined headers added to see if either a
* fcc: or attach-file: field was specified.
*/
cur = msg->env->userhdrs;
while (cur)
{
keep = 1;
/* keep track of whether or not we see the in-reply-to field. if we did
* not, remove the references: field later so that we can generate a new
* message based upon this one.
*/
if (mutt_strncasecmp ("in-reply-to. good thing you replied:", cur->data, 12) == 0)
in_reply_to = 1;
else if (fcc && mutt_strncasecmp ("fcc:", cur->data, 4) == 0)
{
p = cur->data + 4;
SKIPWS (p);
if (*p)
{
strfcpy (fcc, p, fcclen);
mutt_pretty_mailbox (fcc);
}
keep = 0;
}
else if (mutt_strncasecmp ("attach file:", cur->data, 7) == 0)
{
BODY *body;
BODY *parts;
char *q;
p = cur->data + 7;
SKIPWS (p);
if (*p)
{
if ((q = strpbrk (p, " \t")))
{
mutt_substrcpy (path, p, q, sizeof (path));
SKIPWS (q);
}
else
strfcpy (path, p, sizeof (path));
mutt_expand_path (path, sizeof (path));
if ((body = mutt_make_file_attach (path)))
{
body->description = safe_strdup (q);
for (parts = msg->content; parts->next; parts = parts->next) ;
parts->next = body;
}
else
{
mutt_pretty_mailbox (path);
mutt_error (_("%s: unable to attach file. try again"), path);
}
}
keep = 0;
}
#ifdef HAVE_PGP
else if (mutt_strncasecmp ("pgp:", cur->data, 4) == 0)
{
msg->pgp = mutt_parse_pgp_hdr (cur->data + 4, 0);
keep = 0;
}
#endif
if (keep)
{
last = cur;
cur = cur->next;
}
else
{
if (last)
last->next = cur->next;
else
msg->env->userhdrs = cur->next;
tmp = cur;
cur = cur->next;
tmp->next = NULL;
mutt_free_list (&tmp);
}
}
if (!in_reply_to)
mutt_free_list (&msg->env->references);
}
int mutt_display_message (HEADER *cur)
{
char tempfile[_POSIX_PATH_MAX], buf[LONG_STRING];
int rc = 0, builtin = 0;
int cmflags = M_CM_DECODE | M_CM_DISPLAY | M_CM_CHARCONV;
FILE *fpout = NULL;
FILE *fpfilterout = NULL;
pid_t filterpid = -1;
int res;
snprintf (buf, sizeof (buf), "%s/%s", TYPE (cur->content),
cur->content->subtype);
mutt_parse_mime_message (Context, cur);
mutt_message_hook (Context, cur, M_MESSAGEHOOK);
/* see if crypto is needed for this message. if so, we should exit curses */
if (WithCrypto && cur->security)
{
if (cur->security & ENCRYPT)
{
if (cur->security & APPLICATION_SMIME)
crypt_smime_getkeys (cur->env);
if(!crypt_valid_passphrase(cur->security))
return 0;
cmflags |= M_CM_VERIFY;
}
else if (cur->security & SIGN)
{
/* find out whether or not the verify signature */
if (query_quadoption (OPT_VERIFYSIG, _("Verify PGP signature?")) == M_YES)
{
cmflags |= M_CM_VERIFY;
}
}
}
if (cmflags & M_CM_VERIFY || cur->security & ENCRYPT)
{
if (cur->security & APPLICATION_PGP)
{
if (cur->env->from)
crypt_pgp_invoke_getkeys (cur->env->from);
crypt_invoke_message (APPLICATION_PGP);
}
if (cur->security & APPLICATION_SMIME)
crypt_invoke_message (APPLICATION_SMIME);
}
mutt_mktemp (tempfile, sizeof (tempfile));
if ((fpout = safe_fopen (tempfile, "w")) == NULL)
{
mutt_error _("Could not create temporary file!");
return (0);
}
if (DisplayFilter && *DisplayFilter)
{
fpfilterout = fpout;
fpout = NULL;
/* mutt_endwin (NULL); */
filterpid = mutt_create_filter_fd (DisplayFilter, &fpout, NULL, NULL,
-1, fileno(fpfilterout), -1);
if (filterpid < 0)
{
mutt_error (_("Cannot create display filter"));
safe_fclose (&fpfilterout);
unlink (tempfile);
return 0;
}
}
if (!Pager || mutt_strcmp (Pager, "builtin") == 0)
builtin = 1;
else
{
struct hdr_format_info hfi;
hfi.ctx = Context;
hfi.pager_progress = ExtPagerProgress;
hfi.hdr = cur;
mutt_make_string_info (buf, sizeof (buf), NONULL(PagerFmt), &hfi, M_FORMAT_MAKEPRINT);
fputs (buf, fpout);
fputs ("\n\n", fpout);
}
res = mutt_copy_message (fpout, Context, cur, cmflags,
(option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) | CH_DECODE | CH_FROM | CH_DISPLAY);
if ((safe_fclose (&fpout) != 0 && errno != EPIPE) || res < 0)
{
mutt_error (_("Could not copy message"));
if (fpfilterout != NULL)
{
mutt_wait_filter (filterpid);
safe_fclose (&fpfilterout);
}
mutt_unlink (tempfile);
return 0;
}
if (fpfilterout != NULL && mutt_wait_filter (filterpid) != 0)
mutt_any_key_to_continue (NULL);
safe_fclose (&fpfilterout); /* XXX - check result? */
if (WithCrypto)
{
/* update crypto information for this message */
cur->security &= ~(GOODSIGN|BADSIGN);
cur->security |= crypt_query (cur->content);
/* Remove color cache for this message, in case there
are color patterns for both ~g and ~V */
cur->pair = 0;
}
if (builtin)
{
pager_t info;
if (WithCrypto
&& (cur->security & APPLICATION_SMIME) && (cmflags & M_CM_VERIFY))
{
if (cur->security & GOODSIGN)
{
if (!crypt_smime_verify_sender(cur))
mutt_message ( _("S/MIME signature successfully verified."));
else
mutt_error ( _("S/MIME certificate owner does not match sender."));
}
else if (cur->security & PARTSIGN)
mutt_message (_("Warning: Part of this message has not been signed."));
else if (cur->security & SIGN || cur->security & BADSIGN)
mutt_error ( _("S/MIME signature could NOT be verified."));
}
if (WithCrypto
&& (cur->security & APPLICATION_PGP) && (cmflags & M_CM_VERIFY))
{
if (cur->security & GOODSIGN)
mutt_message (_("PGP signature successfully verified."));
else if (cur->security & PARTSIGN)
mutt_message (_("Warning: Part of this message has not been signed."));
else if (cur->security & SIGN)
mutt_message (_("PGP signature could NOT be verified."));
}
/* Invoke the builtin pager */
memset (&info, 0, sizeof (pager_t));
info.hdr = cur;
info.ctx = Context;
rc = mutt_pager (NULL, tempfile, M_PAGER_MESSAGE, &info);
}
else
{
int r;
mutt_endwin (NULL);
snprintf (buf, sizeof (buf), "%s %s", NONULL(Pager), tempfile);
if ((r = mutt_system (buf)) == -1)
mutt_error (_("Error running \"%s\"!"), buf);
unlink (tempfile);
if (!option (OPTNOCURSES))
keypad (stdscr, TRUE);
if (r != -1)
mutt_set_flag (Context, cur, M_READ, 1);
if (r != -1 && option (OPTPROMPTAFTER))
{
mutt_unget_event (mutt_any_key_to_continue _("Command: "), 0);
rc = km_dokey (MENU_PAGER);
}
else
rc = 0;
}
return rc;
}
static void attach_forward_bodies (FILE * fp, struct header * hdr,
ATTACHPTR ** idx, short idxlen,
struct body * cur,
short nattach)
{
short i;
short mime_fwd_all = 0;
short mime_fwd_any = 1;
struct header *parent = NULL;
struct header *tmphdr = NULL;
struct body **last;
char tmpbody[_POSIX_PATH_MAX];
FILE *tmpfp = NULL;
char prefix[STRING];
int rc = 0;
STATE st;
/*
* First, find the parent message.
* Note: This could be made an option by just
* putting the following lines into an if block.
*/
parent = find_parent (idx, idxlen, cur, nattach);
if (parent == NULL)
parent = hdr;
tmphdr = mutt_new_header ();
tmphdr->env = mutt_new_envelope ();
mutt_make_forward_subject (tmphdr->env, Context, parent);
mutt_mktemp (tmpbody, sizeof (tmpbody));
if ((tmpfp = safe_fopen (tmpbody, "w")) == NULL)
{
mutt_error (("Can't open temporary file %s."), tmpbody);
return;
}
mutt_forward_intro (tmpfp, parent);
/* prepare the prefix here since we'll need it later. */
if (bit_val(options, OPTFORWQUOTE))
{
if (!bit_val(options, OPTTEXTFLOWED))
_mutt_make_string (prefix, sizeof (prefix), NONULL (Prefix), Context,
parent, 0);
else
strfcpy (prefix, ">", sizeof (prefix));
}
include_header (bit_val(options, OPTFORWQUOTE), fp, parent,
tmpfp, prefix);
/*
* Now, we have prepared the first part of the message body: The
* original message's header.
*
* The next part is more interesting: either include the message bodies,
* or attach them.
*/
if ((!cur || mutt_can_decode (cur)) &&
(rc = query_quadoption (OPT_MIMEFWD,
("Forward as attachments?"))) == M_YES)
mime_fwd_all = 1;
else if (rc == -1)
goto bail;
/*
* shortcut MIMEFWDREST when there is only one attachment. Is
* this intuitive?
*/
if (!mime_fwd_all && !cur && (nattach > 1)
&& !check_can_decode (idx, idxlen, cur))
{
if ((rc = query_quadoption (OPT_MIMEFWDREST,
("Can't decode all tagged attachments. MIME-forward the others?"))) == -1)
goto bail;
else if (rc == M_NO)
mime_fwd_any = 0;
}
/* initialize a state structure */
memset (&st, 0, sizeof (st));
if (bit_val(options, OPTFORWQUOTE))
st.prefix = prefix;
st.flags = M_CHARCONV;
if (bit_val(options, OPTWEED))
st.flags |= M_WEED;
st.fpin = fp;
st.fpout = tmpfp;
/* where do we append new MIME parts? */
last = &tmphdr->content;
if (cur)
{
/* single body case */
if (!mime_fwd_all && mutt_can_decode (cur))
{
mutt_body_handler (cur, &st);
state_putc ('\n', &st);
}
else
{
if (mutt_copy_body (fp, last, cur) == -1)
goto bail;
last = &((*last)->next);
}
}
else
{
/* multiple body case */
if (!mime_fwd_all)
{
for (i = 0; i < idxlen; i++)
{
if (idx[i]->content->tagged && mutt_can_decode (idx[i]->content))
{
mutt_body_handler (idx[i]->content, &st);
state_putc ('\n', &st);
}
}
}
if (mime_fwd_any &&
copy_problematic_attachments (fp, last, idx, idxlen, mime_fwd_all) == NULL)
goto bail;
}
mutt_forward_trailer (tmpfp);
safe_fclose (&tmpfp);
tmpfp = NULL;
/* now that we have the template, send it. */
ci_send_message (0, tmphdr, tmpbody, NULL, parent);
return;
bail:
if (tmpfp)
{
safe_fclose (&tmpfp);
mutt_unlink (tmpbody);
}
mutt_free_header (&tmphdr);
}
