/* returns 1 if OK to proceed, 0 to abort */
int mutt_save_confirm (const char *s, struct stat *st)
{
char tmp[_POSIX_PATH_MAX];
int ret = 1;
int magic = 0;
magic = mx_get_magic (s);
if (stat (s, st) != -1)
{
if (magic == -1)
{
mutt_error (_("%s is not a mailbox!"), s);
return 0;
}
if (option (OPTCONFIRMAPPEND))
{
snprintf (tmp, sizeof (tmp), _("Append messages to %s?"), s);
if (mutt_yesorno (tmp, 1) < 1)
ret = 0;
}
}
else
{
#ifdef USE_IMAP
if (magic != M_IMAP)
#endif /* execute the block unconditionally if we don't use imap */
{
st->st_mtime = 0;
st->st_atime = 0;
if (errno == ENOENT)
{
if (option (OPTCONFIRMCREATE))
{
snprintf (tmp, sizeof (tmp), _("Create %s?"), s);
if (mutt_yesorno (tmp, 1) < 1)
ret = 0;
}
}
else
{
mutt_perror (s);
return 0;
}
}
}
CLEARLINE (LINES-1);
return (ret);
}
static int
check_attachments(ATTACHPTR **idx, short idxlen)
{
int i, r;
struct stat st;
char pretty[_POSIX_PATH_MAX], msg[_POSIX_PATH_MAX + SHORT_STRING];
for (i = 0; i < idxlen; i++)
{
strfcpy(pretty, idx[i]->content->filename, sizeof(pretty));
if(stat(idx[i]->content->filename, &st) != 0)
{
mutt_pretty_mailbox(pretty, sizeof (pretty));
mutt_error(_("%s [#%d] no longer exists!"),
pretty, i+1);
return -1;
}
if(idx[i]->content->stamp < st.st_mtime)
{
mutt_pretty_mailbox(pretty, sizeof (pretty));
snprintf(msg, sizeof(msg), _("%s [#%d] modified. Update encoding?"),
pretty, i+1);
if((r = mutt_yesorno(msg, M_YES)) == M_YES)
mutt_update_encoding(idx[i]->content);
else if(r == -1)
return -1;
}
}
return 0;
}
/**
* mutt_query_exit - Ask the user if they want to leave NeoMutt
*
* This function is called when the user presses the abort key.
*/
void mutt_query_exit(void)
{
mutt_flushinp();
curs_set(1);
if (C_Timeout)
mutt_getch_timeout(-1); /* restore blocking operation */
if (mutt_yesorno(_("Exit NeoMutt?"), MUTT_YES) == MUTT_YES)
{
mutt_exit(1);
}
mutt_clear_error();
mutt_curs_set(-1);
SigInt = 0;
}
/* this function is called when the user presses the abort key */
void mutt_query_exit (void)
{
mutt_flushinp ();
curs_set (1);
if (Timeout)
timeout (-1); /* restore blocking operation */
if (mutt_yesorno (_("Exit Mutt?"), 1) == 1)
{
endwin ();
exit (0);
}
mutt_clear_error();
mutt_curs_set (-1);
SigInt = 0;
}
/* return 0 on success, -1 on error */
int mutt_check_overwrite (const char *attname, const char *path,
char *fname, size_t flen, int *append)
{
char tmp[_POSIX_PATH_MAX];
struct stat st;
strfcpy (fname, path, flen);
if (access (fname, F_OK) != 0)
return 0;
if (stat (fname, &st) != 0)
return -1;
if (S_ISDIR (st.st_mode))
{
if (mutt_yesorno (_("File is a directory, save under it?"), 1) != M_YES)
return (-1);
if (!attname || !attname[0])
{
tmp[0] = 0;
if (mutt_get_field (_("File under directory: "), tmp, sizeof (tmp),
M_FILE | M_CLEAR) != 0 || !tmp[0])
return (-1);
snprintf (fname, flen, "%s/%s", path, tmp);
}
else
snprintf (fname, flen, "%s/%s", path, attname);
}
if (*append == 0 && access (fname, F_OK) == 0)
{
switch (mutt_multi_choice
(_("File exists, (o)verwrite, (a)ppend, or (c)ancel?"), _("oac")))
{
case -1: /* abort */
case 3: /* cancel */
return -1;
case 2: /* append */
*append = M_SAVE_APPEND;
break;
case 1: /* overwrite */
*append = M_SAVE_OVERWRITE;
break;
}
}
return 0;
}
int query_quadoption (int opt, const char *prompt)
{
int v = quadoption (opt);
switch (v)
{
case M_YES:
case M_NO:
return (v);
default:
v = mutt_yesorno (prompt, (v == M_ASKYES));
#ifndef LIBMUTT
CLEARLINE (LINES - 1);
#endif
return (v);
}
/* not reached */
}
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;
}
/*
* Currently, this only works for send mode, as it assumes that the
* BODY->filename actually contains the information. I'm not sure
* we want to deal with editing attachments we've already received,
* so this should be ok.
*
* Returns 1 if editor found, 0 if not (useful to tell calling menu to
* redraw)
*/
int mutt_edit_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_EDIT))
{
if (entry->editcommand)
{
strfcpy (command, entry->editcommand, 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 Edit entry requires %%s");
goto bailout;
}
else
{
mutt_endwin (NULL);
if (mutt_system (command) == -1)
{
mutt_error (_("Error running \"%s\"!"), command);
goto bailout;
}
}
}
}
else if (a->type == TYPETEXT)
{
/* On text, default to editor */
mutt_edit_file (NONULL (Editor), a->filename);
}
else
{
rfc1524_free_entry (&entry);
mutt_error (_("No mailcap edit entry for %s"),type);
return 0;
}
rc = 1;
bailout:
if(unlink_newfile)
unlink(newfile);
rfc1524_free_entry (&entry);
return rc;
}
/* return 0 on success, -1 on abort, 1 on error */
int mutt_check_overwrite (const char *attname, const char *path,
char *fname, size_t flen, int *append,
char **directory)
{
int rc = 0;
char tmp[_POSIX_PATH_MAX];
struct stat st;
strfcpy (fname, path, flen);
if (access (fname, F_OK) != 0)
return 0;
if (stat (fname, &st) != 0)
return -1;
if (S_ISDIR (st.st_mode)) {
if (directory) {
switch (mutt_multi_choice
(_("File is a directory, save under it? [(y)es, (n)o, (a)ll]"),
_("yna"))) {
case 3: /* all */
str_replace (directory, fname);
break;
case 1: /* yes */
mem_free (directory);
break;
case -1: /* abort */
mem_free (directory);
return -1;
case 2: /* no */
mem_free (directory);
return 1;
}
}
else
if ((rc =
mutt_yesorno (_("File is a directory, save under it?"),
M_YES)) != M_YES)
return (rc == M_NO) ? 1 : -1;
if (!attname || !attname[0]) {
tmp[0] = 0;
if (mutt_get_field (_("File under directory: "), tmp, sizeof (tmp),
M_FILE | M_CLEAR) != 0 || !tmp[0])
return (-1);
mutt_concat_path (fname, path, tmp, flen);
}
else
mutt_concat_path (fname, path, mutt_basename (attname), flen);
}
if (*append == 0 && access (fname, F_OK) == 0) {
switch (mutt_multi_choice
(_("File exists, (o)verwrite, (a)ppend, or (c)ancel?"), _("oac")))
{
case -1: /* abort */
return -1;
case 3: /* cancel */
return 1;
case 2: /* append */
*append = M_SAVE_APPEND;
break;
case 1: /* overwrite */
*append = M_SAVE_OVERWRITE;
break;
}
}
return 0;
}
static smime_key_t *smime_select_key(smime_key_t *keys, char *query)
{
smime_key_t **table = NULL;
int table_size = 0;
int table_index = 0;
smime_key_t *key = NULL;
smime_key_t *selected_key = NULL;
char helpstr[LONG_STRING];
char buf[LONG_STRING];
char title[256];
MUTTMENU* menu;
char *s = "";
int done = 0;
for (table_index = 0, key = keys; key; key = key->next)
{
if (table_index == table_size)
{
table_size += 5;
safe_realloc(&table, sizeof(smime_key_t *) * table_size);
}
table[table_index++] = key;
}
snprintf(title, sizeof(title),("S/MIME certificates matching \"%s\"."),
query);
/* Make Helpstring */
helpstr[0] = 0;
mutt_make_help(buf, sizeof(buf),("Exit "), MENU_SMIME, OP_EXIT);
strcat(helpstr, buf); /* __STRCAT_CHECKED__ */
mutt_make_help(buf, sizeof(buf),("Select "), MENU_SMIME,
OP_GENERIC_SELECT_ENTRY);
strcat(helpstr, buf); /* __STRCAT_CHECKED__ */
mutt_make_help(buf, sizeof(buf),("Help"), MENU_SMIME, OP_HELP);
strcat(helpstr, buf); /* __STRCAT_CHECKED__ */
/* Create the menu */
menu = mutt_new_menu(MENU_SMIME);
menu->max = table_index;
menu->make_entry = smime_entry;
menu->help = helpstr;
menu->data = table;
menu->title = title;
/* sorting keys might be done later - TODO */
mutt_clear_error ();
done = 0;
while (!done)
{
switch(mutt_menuLoop(menu))
{
case OP_GENERIC_SELECT_ENTRY:
if (table[menu->current]->trust != 't')
{
switch(table[menu->current]->trust)
{
case 'i':
case 'r':
case 'e':
s =("ID is expired/disabled/revoked.");
break;
case 'u':
s =("ID has undefined validity.");
break;
case 'v':
s =("ID is not trusted.");
break;
}
snprintf(buf, sizeof(buf),("%s Do you really want to use the key?"),
(s));
if (mutt_yesorno(buf, M_NO) != M_YES)
{
mutt_clear_error ();
break;
}
}
selected_key = table[menu->current];
done = 1;
break;
case OP_EXIT:
done = 1;
break;
}
}
mutt_menuDestroy(&menu);
safe_free(&table);
set_bit(options, OPTNEEDREDRAW);
return selected_key;
}
int main(int argc, char **argv)
{
char folder[_POSIX_PATH_MAX] = "";
int flags = 0;
/* set default locale */
setlocale(LC_ALL, "");
/* initialization of main output routines with default values */
mutt_error = mutt_message = mutt_nocurses_error;
/* parse command line options */
parse_argv(argc, argv);
if (arg_version == 1)
{
show_version();
exit(RETURN_SUCCESS);
} else if (arg_version == 2)
{
show_version_verbose();
exit(RETURN_SUCCESS);
}
if (arg_execute)
{
init(commands);
is_mutt_init = true;
}
if (arg_expand_alias)
{
struct list_t *alias;
if (!is_mutt_init)
init(commands);
for(alias = aliases; alias; alias = alias->next)
{
struct address *a = mutt_lookup_alias(alias->data);
if (a)
{
printf("alias->data %s\n", alias->data);
mutt_write_address_list(a, stdout, 0, 0);
}
}
exit(RETURN_SUCCESS);
}
if (arg_query_conf)
{
if (!is_mutt_init)
init(commands);
if (queries)
return mutt_query_variables(queries);
exit(RETURN_SUCCESS);
}
if (arg_emulate_mailx) {
sendflags |= SENDMAILX;
}
if (arg_mailbox)
strfcpy(folder, arg_mailbox, sizeof(folder));
if (arg_mailbox_type)
mx_set_magic(arg_mailbox_type);
if (arg_resume_postponed)
sendflags |= SENDPOSTPONED;
/* no-curses for non-terminal session */
if (!isatty(STDIN_FILENO))
{
set_bit(options, OPTNOCURSES);
sendflags = SENDBATCH;
}
else
{
/*
* This must come before mutt_init() because curses needs to be started
* before calling the init_pair() function to set the color scheme.
*/
start_curses();
/* check whether terminal status is supported */
term_status = mutt_ts_capability();
}
/* Initialize crypto backends. */
crypt_init();
if (!is_mutt_init)
init(commands);
if (!bit_val(options, OPTNOCURSES))
{
SETCOLOR(MT_COLOR_NORMAL);
clear();
mutt_error = mutt_curses_error;
mutt_message = mutt_curses_message;
}
/* Create the Maildir directory if it doesn't exist */
if (!bit_val(options, OPTNOCURSES) && Maildir)
{
struct stat sb;
char fpath[_POSIX_PATH_MAX];
char msg[STRING];
strfcpy(fpath, Maildir, sizeof(fpath));
mutt_expand_path(fpath, sizeof(fpath));
#if USE_IMAP
/* we're not connected yet - skip mail folder creation */
if (!mx_is_imap(fpath))
#endif
if (stat(fpath, &sb) == -1 && errno == ENOENT)
{
snprintf(msg, sizeof(msg), ("%s does not exist. Create it?"), Maildir);
if (mutt_yesorno(msg, M_YES) == M_YES)
if (mkdir(fpath, 0700) == -1 && errno != EEXIST)
mutt_error( ("Can't create %s: %s."), Maildir, strerror(errno));
}
}
if (sendflags & SENDPOSTPONED)
{
if (!bit_val(options, OPTNOCURSES))
mutt_flushinp();
ci_send_message(SENDPOSTPONED, NULL, NULL, NULL, NULL);
mutt_endwin(NULL);
}
else if (arg_subject || msg || sendflags || arg_include || attach)
{
FILE *fin = NULL;
char buf[LONG_STRING];
char *tempfile = NULL, *infile = NULL;
char *bodytext = NULL;
int rv = 0;
if (!bit_val(options, OPTNOCURSES))
mutt_flushinp();
if (!msg)
msg = mutt_new_header();
if (!msg->env)
msg->env = mutt_new_envelope();
for(; addr_to; addr_to = addr_to->next)
{
if (url_check_scheme(addr_to->data) == U_MAILTO)
{
if (url_parse_mailto(msg->env, &bodytext, addr_to->data) < 0)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
fputs(("Failed to parse mailto: link\n"), stderr);
exit(RETURN_WRONG_ADDR);
}
}
else
msg->env->to = rfc822_parse_adrlist(msg->env->to, addr_to->data);
}
if (bit_val(options, OPTAUTOEDIT) && !msg->env->to && !msg->env->cc)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
fputs(("No recipients specified.\n"), stderr);
exit(RETURN_ERR_ARG);
}
if (arg_subject)
msg->env->subject = safe_strdup(arg_subject);
if (arg_include)
infile = arg_include;
if (infile || bodytext)
{
if (infile)
{
if (mutt_strcmp("-", infile) == 0)
fin = stdin;
else
{
char path[_POSIX_PATH_MAX];
strfcpy(path, infile, sizeof(path));
mutt_expand_path(path, sizeof(path));
if ((fin = fopen(path, "r")) == NULL)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
perror(path);
exit(RETURN_ERR_ARG);
}
}
}
mutt_mktemp(buf, sizeof(buf));
tempfile = safe_strdup(buf);
/* TODO: is the following if still needed? */
if (tempfile)
{
FILE *fout;
if ((fout = safe_fopen(tempfile, "w")) == NULL)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
perror(tempfile);
safe_fclose(&fin);
safe_free(&tempfile);
exit(RETURN_ERR_ARG);
}
if (fin)
mutt_copy_stream(fin, fout);
else if (bodytext)
fputs(bodytext, fout);
safe_fclose(&fout);
}
if (fin && fin != stdin)
safe_fclose(&fin);
}
safe_free(&bodytext);
if (attach)
{
struct list_t *t = attach;
struct body *a = NULL;
while(t)
{
if (a)
{
a->next = mutt_make_file_attach(t->data);
a = a->next;
}
else
msg->content = a = mutt_make_file_attach(t->data);
if (!a)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
fprintf(stderr, ("%s: unable to attach file.\n"), t->data);
mutt_free_list(&attach);
exit(RETURN_ERR_ARG);
}
t = t->next;
}
mutt_free_list(&attach);
}
rv = ci_send_message(sendflags, msg, tempfile, NULL, NULL);
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
if (rv)
exit(RETURN_ERR_ARG);
}
else
{
if (!folder[0])
strfcpy(folder, NONULL(Spoolfile), sizeof(folder));
mutt_expand_path(folder, sizeof(folder));
mutt_str_replace(&CurrentFolder, folder);
mutt_str_replace(&LastFolder, folder);
mutt_folder_hook(folder);
if ((Context = mx_open_mailbox(folder, flags, NULL)) || !arg_mailbox)
{
mutt_index_menu();
if (Context)
safe_free(&Context);
}
#if USE_IMAP
imap_logout_all();
#endif
#if USE_SASL
mutt_sasl_done();
#endif
mutt_free_opts();
mutt_endwin(Errorbuf);
}
exit(RETURN_SUCCESS);
}
/* imap_continue: display a message and ask the user if she wants to
* go on. */
int imap_continue (const char *msg, const char *resp)
{
imap_error (msg, resp);
return mutt_yesorno (_("Continue?"), 0);
}
/* return values:
*
* 1 message should be postponed
* 0 normal exit
* -1 abort message
*/
int mutt_compose_menu (HEADER *msg, /* structure for new message */
char *fcc, /* where to save a copy of the message */
size_t fcclen,
HEADER *cur, /* current message */
int flags)
{
char helpstr[LONG_STRING];
char buf[LONG_STRING];
char fname[_POSIX_PATH_MAX];
MUTTMENU *menu;
ATTACHPTR **idx = NULL;
short idxlen = 0;
short idxmax = 0;
int i, close = 0;
int r = -1; /* return value */
int op = 0;
int loop = 1;
int fccSet = 0; /* has the user edited the Fcc: field ? */
CONTEXT *ctx = NULL, *this = NULL;
/* Sort, SortAux could be changed in mutt_index_menu() */
int oldSort, oldSortAux;
struct stat st;
mutt_attach_init (msg->content);
idx = mutt_gen_attach_list (msg->content, -1, idx, &idxlen, &idxmax, 0, 1);
menu = mutt_new_menu (MENU_COMPOSE);
menu->offset = HDR_ATTACH;
menu->max = idxlen;
menu->make_entry = snd_entry;
menu->tag = mutt_tag_attach;
menu->data = idx;
menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_COMPOSE, ComposeHelp);
while (loop)
{
switch (op = mutt_menuLoop (menu))
{
case OP_REDRAW:
draw_envelope (msg, fcc);
menu->offset = HDR_ATTACH;
menu->pagelen = LINES - HDR_ATTACH - 2;
break;
case OP_COMPOSE_EDIT_FROM:
menu->redraw = edit_address_list (HDR_FROM, &msg->env->from);
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_EDIT_TO:
menu->redraw = edit_address_list (HDR_TO, &msg->env->to);
if (option (OPTCRYPTOPPORTUNISTICENCRYPT))
{
crypt_opportunistic_encrypt (msg);
redraw_crypt_lines (msg);
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_EDIT_BCC:
menu->redraw = edit_address_list (HDR_BCC, &msg->env->bcc);
if (option (OPTCRYPTOPPORTUNISTICENCRYPT))
{
crypt_opportunistic_encrypt (msg);
redraw_crypt_lines (msg);
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_EDIT_CC:
menu->redraw = edit_address_list (HDR_CC, &msg->env->cc);
if (option (OPTCRYPTOPPORTUNISTICENCRYPT))
{
crypt_opportunistic_encrypt (msg);
redraw_crypt_lines (msg);
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_EDIT_SUBJECT:
if (msg->env->subject)
strfcpy (buf, msg->env->subject, sizeof (buf));
else
buf[0] = 0;
if (mutt_get_field ("Subject: ", buf, sizeof (buf), 0) == 0)
{
mutt_str_replace (&msg->env->subject, buf);
move (HDR_SUBJECT, HDR_XOFFSET);
if (msg->env->subject)
mutt_paddstr (W, msg->env->subject);
else
clrtoeol();
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_EDIT_REPLY_TO:
menu->redraw = edit_address_list (HDR_REPLYTO, &msg->env->reply_to);
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_EDIT_FCC:
strfcpy (buf, fcc, sizeof (buf));
if (mutt_get_field ("Fcc: ", buf, sizeof (buf), M_FILE | M_CLEAR) == 0)
{
strfcpy (fcc, buf, fcclen);
mutt_pretty_mailbox (fcc, fcclen);
move (HDR_FCC, HDR_XOFFSET);
mutt_paddstr (W, fcc);
fccSet = 1;
}
MAYBE_REDRAW (menu->redraw);
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_EDIT_MESSAGE:
if (Editor && (mutt_strcmp ("builtin", Editor) != 0) && !option (OPTEDITHDRS))
{
mutt_edit_file (Editor, msg->content->filename);
mutt_update_encoding (msg->content);
menu->redraw = REDRAW_FULL;
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
}
/* fall through */
case OP_COMPOSE_EDIT_HEADERS:
if (mutt_strcmp ("builtin", Editor) != 0 &&
(op == OP_COMPOSE_EDIT_HEADERS ||
(op == OP_COMPOSE_EDIT_MESSAGE && option (OPTEDITHDRS))))
{
char *tag = NULL, *err = NULL;
mutt_env_to_local (msg->env);
mutt_edit_headers (NONULL (Editor), msg->content->filename, msg,
fcc, fcclen);
if (mutt_env_to_intl (msg->env, &tag, &err))
{
mutt_error (_("Bad IDN in \"%s\": '%s'"), tag, err);
FREE (&err);
}
if (option (OPTCRYPTOPPORTUNISTICENCRYPT))
crypt_opportunistic_encrypt (msg);
}
else
{
/* this is grouped with OP_COMPOSE_EDIT_HEADERS because the
attachment list could change if the user invokes ~v to edit
the message with headers, in which we need to execute the
code below to regenerate the index array */
mutt_builtin_editor (msg->content->filename, msg, cur);
}
mutt_update_encoding (msg->content);
/* attachments may have been added */
if (idxlen && idx[idxlen - 1]->content->next)
{
for (i = 0; i < idxlen; i++)
{
FREE (&idx[i]->tree);
FREE (&idx[i]);
}
idxlen = 0;
idx = mutt_gen_attach_list (msg->content, -1, idx, &idxlen, &idxmax, 0, 1);
menu->data = idx;
menu->max = idxlen;
}
menu->redraw = REDRAW_FULL;
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_ATTACH_KEY:
if (!(WithCrypto & APPLICATION_PGP))
break;
if (idxlen == idxmax)
{
safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5));
menu->data = idx;
}
idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
if ((idx[idxlen]->content = crypt_pgp_make_key_attachment(NULL)) != NULL)
{
update_idx (menu, idx, idxlen++);
menu->redraw |= REDRAW_INDEX;
}
else
FREE (&idx[idxlen]);
menu->redraw |= REDRAW_STATUS;
if (option(OPTNEEDREDRAW))
{
menu->redraw = REDRAW_FULL;
unset_option(OPTNEEDREDRAW);
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_ATTACH_FILE:
{
char *prompt, **files;
int error, numfiles;
fname[0] = 0;
prompt = _("Attach file");
numfiles = 0;
files = NULL;
if (_mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 0, 1, &files, &numfiles) == -1 ||
*fname == '\0')
break;
if (idxlen + numfiles >= idxmax)
{
safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5 + numfiles));
menu->data = idx;
}
error = 0;
if (numfiles > 1)
mutt_message _("Attaching selected files...");
for (i = 0; i < numfiles; i++)
{
char *att = files[i];
idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
idx[idxlen]->unowned = 1;
idx[idxlen]->content = mutt_make_file_attach (att);
if (idx[idxlen]->content != NULL)
update_idx (menu, idx, idxlen++);
else
{
error = 1;
mutt_error (_("Unable to attach %s!"), att);
FREE (&idx[idxlen]);
}
}
FREE (&files);
if (!error) mutt_clear_error ();
menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_ATTACH_MESSAGE:
{
char *prompt;
HEADER *h;
fname[0] = 0;
prompt = _("Open mailbox to attach message from");
if (Context)
{
strfcpy (fname, NONULL (Context->path), sizeof (fname));
mutt_pretty_mailbox (fname, sizeof (fname));
}
if (mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 1) == -1 || !fname[0])
break;
mutt_expand_path (fname, sizeof (fname));
#ifdef USE_IMAP
if (!mx_is_imap (fname))
#endif
#ifdef USE_POP
if (!mx_is_pop (fname))
#endif
/* check to make sure the file exists and is readable */
if (access (fname, R_OK) == -1)
{
mutt_perror (fname);
break;
}
menu->redraw = REDRAW_FULL;
ctx = mx_open_mailbox (fname, M_READONLY, NULL);
if (ctx == NULL)
{
mutt_error (_("Unable to open mailbox %s"), fname);
break;
}
if (!ctx->msgcount)
{
mx_close_mailbox (ctx, NULL);
FREE (&ctx);
mutt_error _("No messages in that folder.");
break;
}
this = Context; /* remember current folder and sort methods*/
oldSort = Sort; oldSortAux = SortAux;
Context = ctx;
set_option(OPTATTACHMSG);
mutt_message _("Tag the messages you want to attach!");
close = mutt_index_menu ();
unset_option(OPTATTACHMSG);
if (!Context)
{
/* go back to the folder we started from */
Context = this;
/* Restore old $sort and $sort_aux */
Sort = oldSort;
SortAux = oldSortAux;
menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
break;
}
if (idxlen + Context->tagged >= idxmax)
{
safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5 + Context->tagged));
menu->data = idx;
}
for (i = 0; i < Context->msgcount; i++)
{
h = Context->hdrs[i];
if (h->tagged)
{
idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
idx[idxlen]->content = mutt_make_message_attach (Context, h, 1);
if (idx[idxlen]->content != NULL)
update_idx (menu, idx, idxlen++);
else
{
mutt_error _("Unable to attach!");
FREE (&idx[idxlen]);
}
}
}
menu->redraw |= REDRAW_FULL;
if (close == OP_QUIT)
mx_close_mailbox (Context, NULL);
else
mx_fastclose_mailbox (Context);
FREE (&Context);
/* go back to the folder we started from */
Context = this;
/* Restore old $sort and $sort_aux */
Sort = oldSort;
SortAux = oldSortAux;
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_DELETE:
CHECK_COUNT;
if (idx[menu->current]->unowned)
idx[menu->current]->content->unlink = 0;
if (delete_attachment (menu, &idxlen, menu->current) == -1)
break;
mutt_update_tree (idx, idxlen);
if (idxlen)
{
if (menu->current > idxlen - 1)
menu->current = idxlen - 1;
}
else
menu->current = 0;
if (menu->current == 0)
msg->content = idx[0]->content;
menu->redraw |= REDRAW_STATUS;
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
#define CURRENT idx[menu->current]->content
case OP_COMPOSE_TOGGLE_RECODE:
{
CHECK_COUNT;
if (!mutt_is_text_part (CURRENT))
{
mutt_error (_("Recoding only affects text attachments."));
break;
}
CURRENT->noconv = !CURRENT->noconv;
if (CURRENT->noconv)
mutt_message (_("The current attachment won't be converted."));
else
mutt_message (_("The current attachment will be converted."));
menu->redraw = REDRAW_CURRENT;
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
}
#undef CURRENT
case OP_COMPOSE_EDIT_DESCRIPTION:
CHECK_COUNT;
strfcpy (buf,
idx[menu->current]->content->description ?
idx[menu->current]->content->description : "",
sizeof (buf));
/* header names should not be translated */
if (mutt_get_field ("Description: ", buf, sizeof (buf), 0) == 0)
{
mutt_str_replace (&idx[menu->current]->content->description, buf);
menu->redraw = REDRAW_CURRENT;
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_UPDATE_ENCODING:
CHECK_COUNT;
if (menu->tagprefix)
{
BODY *top;
for (top = msg->content; top; top = top->next)
{
if (top->tagged)
mutt_update_encoding (top);
}
menu->redraw = REDRAW_FULL;
}
else
{
mutt_update_encoding(idx[menu->current]->content);
menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_TOGGLE_DISPOSITION:
/* toggle the content-disposition between inline/attachment */
idx[menu->current]->content->disposition = (idx[menu->current]->content->disposition == DISPINLINE) ? DISPATTACH : DISPINLINE;
menu->redraw = REDRAW_CURRENT;
break;
case OP_EDIT_TYPE:
CHECK_COUNT;
{
mutt_edit_content_type (NULL, idx[menu->current]->content, NULL);
/* this may have been a change to text/something */
mutt_update_encoding (idx[menu->current]->content);
menu->redraw = REDRAW_CURRENT;
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_EDIT_ENCODING:
CHECK_COUNT;
strfcpy (buf, ENCODING (idx[menu->current]->content->encoding),
sizeof (buf));
if (mutt_get_field ("Content-Transfer-Encoding: ", buf,
sizeof (buf), 0) == 0 && buf[0])
{
if ((i = mutt_check_encoding (buf)) != ENCOTHER && i != ENCUUENCODED)
{
idx[menu->current]->content->encoding = i;
menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
mutt_clear_error();
}
else
mutt_error _("Invalid encoding.");
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_SEND_MESSAGE:
/* Note: We don't invoke send2-hook here, since we want to leave
* users an opportunity to change settings from the ":" prompt.
*/
if(check_attachments(idx, idxlen) != 0)
{
menu->redraw = REDRAW_FULL;
break;
}
#ifdef MIXMASTER
if (msg->chain && mix_check_message (msg) != 0)
break;
#endif
if (!fccSet && *fcc)
{
if ((i = query_quadoption (OPT_COPY,
_("Save a copy of this message?"))) == -1)
break;
else if (i == M_NO)
*fcc = 0;
}
loop = 0;
r = 0;
break;
case OP_COMPOSE_EDIT_FILE:
CHECK_COUNT;
mutt_edit_file (NONULL(Editor), idx[menu->current]->content->filename);
mutt_update_encoding (idx[menu->current]->content);
menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_TOGGLE_UNLINK:
CHECK_COUNT;
idx[menu->current]->content->unlink = !idx[menu->current]->content->unlink;
#if 0
/* OPTRESOLVE is otherwise ignored on this menu.
* Where's the bug?
*/
if (option (OPTRESOLVE) && menu->current + 1 < menu->max)
menu->current++;
# endif
menu->redraw = REDRAW_INDEX;
/* No send2hook since this doesn't change the message. */
break;
case OP_COMPOSE_GET_ATTACHMENT:
CHECK_COUNT;
if(menu->tagprefix)
{
BODY *top;
for(top = msg->content; top; top = top->next)
{
if(top->tagged)
mutt_get_tmp_attachment(top);
}
menu->redraw = REDRAW_FULL;
}
else if (mutt_get_tmp_attachment(idx[menu->current]->content) == 0)
menu->redraw = REDRAW_CURRENT;
/* No send2hook since this doesn't change the message. */
break;
case OP_COMPOSE_RENAME_FILE:
CHECK_COUNT;
strfcpy (fname, idx[menu->current]->content->filename, sizeof (fname));
mutt_pretty_mailbox (fname, sizeof (fname));
if (mutt_get_field (_("Rename to: "), fname, sizeof (fname), M_FILE)
== 0 && fname[0])
{
if (stat(idx[menu->current]->content->filename, &st) == -1)
{
/* L10N:
"stat" is a system call. Do "man 2 stat" for more information. */
mutt_error (_("Can't stat %s: %s"), fname, strerror (errno));
break;
}
mutt_expand_path (fname, sizeof (fname));
if(mutt_rename_file (idx[menu->current]->content->filename, fname))
break;
mutt_str_replace (&idx[menu->current]->content->filename, fname);
menu->redraw = REDRAW_CURRENT;
if(idx[menu->current]->content->stamp >= st.st_mtime)
mutt_stamp_attachment(idx[menu->current]->content);
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_NEW_MIME:
{
char type[STRING];
char *p;
int itype;
FILE *fp;
CLEARLINE (LINES-1);
fname[0] = 0;
if (mutt_get_field (_("New file: "), fname, sizeof (fname), M_FILE)
!= 0 || !fname[0])
continue;
mutt_expand_path (fname, sizeof (fname));
/* Call to lookup_mime_type () ? maybe later */
type[0] = 0;
if (mutt_get_field ("Content-Type: ", type, sizeof (type), 0) != 0
|| !type[0])
continue;
if (!(p = strchr (type, '/')))
{
mutt_error _("Content-Type is of the form base/sub");
continue;
}
*p++ = 0;
if ((itype = mutt_check_mime_type (type)) == TYPEOTHER)
{
mutt_error (_("Unknown Content-Type %s"), type);
continue;
}
if (idxlen == idxmax)
{
safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5));
menu->data = idx;
}
idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
/* Touch the file */
if (!(fp = safe_fopen (fname, "w")))
{
mutt_error (_("Can't create file %s"), fname);
FREE (&idx[idxlen]);
continue;
}
safe_fclose (&fp);
if ((idx[idxlen]->content = mutt_make_file_attach (fname)) == NULL)
{
mutt_error _("What we have here is a failure to make an attachment");
continue;
}
update_idx (menu, idx, idxlen++);
idx[menu->current]->content->type = itype;
mutt_str_replace (&idx[menu->current]->content->subtype, p);
idx[menu->current]->content->unlink = 1;
menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
if (mutt_compose_attachment (idx[menu->current]->content))
{
mutt_update_encoding (idx[menu->current]->content);
menu->redraw = REDRAW_FULL;
}
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_COMPOSE_EDIT_MIME:
CHECK_COUNT;
if (mutt_edit_attachment (idx[menu->current]->content))
{
mutt_update_encoding (idx[menu->current]->content);
menu->redraw = REDRAW_FULL;
}
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_VIEW_ATTACH:
case OP_DISPLAY_HEADERS:
CHECK_COUNT;
mutt_attach_display_loop (menu, op, NULL, NULL, NULL, &idx, &idxlen, NULL, 0);
menu->redraw = REDRAW_FULL;
/* no send2hook, since this doesn't modify the message */
break;
case OP_SAVE:
CHECK_COUNT;
mutt_save_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content, NULL, menu);
MAYBE_REDRAW (menu->redraw);
/* no send2hook, since this doesn't modify the message */
break;
case OP_PRINT:
CHECK_COUNT;
mutt_print_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content);
/* no send2hook, since this doesn't modify the message */
break;
case OP_PIPE:
case OP_FILTER:
CHECK_COUNT;
mutt_pipe_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content, op == OP_FILTER);
if (op == OP_FILTER) /* cte might have changed */
menu->redraw = menu->tagprefix ? REDRAW_FULL : REDRAW_CURRENT;
menu->redraw |= REDRAW_STATUS;
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_EXIT:
if ((i = query_quadoption (OPT_POSTPONE, _("Postpone this message?"))) == M_NO)
{
for (i = 0; i < idxlen; i++)
if (idx[i]->unowned)
idx[i]->content->unlink = 0;
if (!(flags & M_COMPOSE_NOFREEHEADER))
{
while (idxlen-- > 0)
{
/* avoid freeing other attachments */
idx[idxlen]->content->next = NULL;
idx[idxlen]->content->parts = NULL;
mutt_free_body (&idx[idxlen]->content);
FREE (&idx[idxlen]->tree);
FREE (&idx[idxlen]);
}
FREE (&idx);
idxlen = 0;
idxmax = 0;
}
r = -1;
loop = 0;
break;
}
else if (i == -1)
break; /* abort */
/* fall through to postpone! */
case OP_COMPOSE_POSTPONE_MESSAGE:
if(check_attachments(idx, idxlen) != 0)
{
menu->redraw = REDRAW_FULL;
break;
}
loop = 0;
r = 1;
break;
case OP_COMPOSE_ISPELL:
endwin ();
snprintf (buf, sizeof (buf), "%s -x %s", NONULL(Ispell), msg->content->filename);
if (mutt_system (buf) == -1)
mutt_error (_("Error running \"%s\"!"), buf);
else
{
mutt_update_encoding (msg->content);
menu->redraw |= REDRAW_STATUS;
}
break;
case OP_COMPOSE_WRITE_MESSAGE:
fname[0] = '\0';
if (Context)
{
strfcpy (fname, NONULL (Context->path), sizeof (fname));
mutt_pretty_mailbox (fname, sizeof (fname));
}
if (idxlen)
msg->content = idx[0]->content;
if (mutt_enter_fname (_("Write message to mailbox"), fname, sizeof (fname),
&menu->redraw, 1) != -1 && fname[0])
{
mutt_message (_("Writing message to %s ..."), fname);
mutt_expand_path (fname, sizeof (fname));
if (msg->content->next)
msg->content = mutt_make_multipart (msg->content);
if (mutt_write_fcc (fname, msg, NULL, 0, NULL) < 0)
msg->content = mutt_remove_multipart (msg->content);
else
mutt_message _("Message written.");
}
break;
case OP_COMPOSE_PGP_MENU:
if (!(WithCrypto & APPLICATION_PGP))
break;
if ((WithCrypto & APPLICATION_SMIME)
&& (msg->security & APPLICATION_SMIME))
{
if (msg->security & (ENCRYPT | SIGN))
{
if (mutt_yesorno (_("S/MIME already selected. Clear & continue ? "),
M_YES) != M_YES)
{
mutt_clear_error ();
break;
}
msg->security &= ~(ENCRYPT | SIGN);
}
msg->security &= ~APPLICATION_SMIME;
msg->security |= APPLICATION_PGP;
crypt_opportunistic_encrypt (msg);
redraw_crypt_lines (msg);
}
msg->security = crypt_pgp_send_menu (msg, &menu->redraw);
redraw_crypt_lines (msg);
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
case OP_FORGET_PASSPHRASE:
crypt_forget_passphrase ();
break;
case OP_COMPOSE_SMIME_MENU:
if (!(WithCrypto & APPLICATION_SMIME))
break;
if ((WithCrypto & APPLICATION_PGP)
&& (msg->security & APPLICATION_PGP))
{
if (msg->security & (ENCRYPT | SIGN))
{
if (mutt_yesorno (_("PGP already selected. Clear & continue ? "),
M_YES) != M_YES)
{
mutt_clear_error ();
break;
}
msg->security &= ~(ENCRYPT | SIGN);
}
msg->security &= ~APPLICATION_PGP;
msg->security |= APPLICATION_SMIME;
crypt_opportunistic_encrypt (msg);
redraw_crypt_lines (msg);
}
msg->security = crypt_smime_send_menu(msg, &menu->redraw);
redraw_crypt_lines (msg);
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
#ifdef MIXMASTER
case OP_COMPOSE_MIX:
mix_make_chain (&msg->chain, &menu->redraw);
mutt_message_hook (NULL, msg, M_SEND2HOOK);
break;
#endif
}
/* Draw formatted compose status line */
if (menu->redraw & REDRAW_STATUS)
{
compose_status_line (buf, sizeof (buf), 0, menu, NONULL(ComposeFormat));
move(option (OPTSTATUSONTOP) ? 0 : LINES-2, 0);
SETCOLOR (MT_COLOR_STATUS);
mutt_paddstr (COLS, buf);
NORMAL_COLOR;
menu->redraw &= ~REDRAW_STATUS;
}
}
mutt_menuDestroy (&menu);
if (idxlen)
{
msg->content = idx[0]->content;
for (i = 0; i < idxlen; i++)
{
idx[i]->content->aptr = NULL;
FREE (&idx[i]->tree);
FREE (&idx[i]);
}
}
else
msg->content = NULL;
FREE (&idx);
return (r);
}
static pgp_key_t pgp_select_key (pgp_key_t keys,
ADDRESS * p, const char *s)
{
int keymax;
pgp_uid_t **KeyTable;
MUTTMENU *menu;
int i, done = 0;
char helpstr[LONG_STRING], buf[LONG_STRING], tmpbuf[STRING];
char cmd[LONG_STRING], tempfile[_POSIX_PATH_MAX];
FILE *fp, *devnull;
pid_t thepid;
pgp_key_t kp;
pgp_uid_t *a;
int (*f) (const void *, const void *);
int unusable = 0;
keymax = 0;
KeyTable = NULL;
for (i = 0, kp = keys; kp; kp = kp->next)
{
if (!option (OPTPGPSHOWUNUSABLE) && (kp->flags & KEYFLAG_CANTUSE))
{
unusable = 1;
continue;
}
for (a = kp->address; a; a = a->next)
{
if (!option (OPTPGPSHOWUNUSABLE) && (a->flags & KEYFLAG_CANTUSE))
{
unusable = 1;
continue;
}
if (i == keymax)
{
keymax += 5;
safe_realloc (&KeyTable, sizeof (pgp_uid_t *) * keymax);
}
KeyTable[i++] = a;
}
}
if (!i && unusable)
{
mutt_error _("All matching keys are expired, revoked, or disabled.");
mutt_sleep (1);
return NULL;
}
switch (PgpSortKeys & SORT_MASK)
{
case SORT_DATE:
f = pgp_compare_date;
break;
case SORT_KEYID:
f = pgp_compare_keyid;
break;
case SORT_ADDRESS:
f = pgp_compare_address;
break;
case SORT_TRUST:
default:
f = pgp_compare_trust;
break;
}
qsort (KeyTable, i, sizeof (pgp_uid_t *), f);
helpstr[0] = 0;
mutt_make_help (buf, sizeof (buf), _("Exit "), MENU_PGP, OP_EXIT);
strcat (helpstr, buf); /* __STRCAT_CHECKED__ */
mutt_make_help (buf, sizeof (buf), _("Select "), MENU_PGP,
OP_GENERIC_SELECT_ENTRY);
strcat (helpstr, buf); /* __STRCAT_CHECKED__ */
mutt_make_help (buf, sizeof (buf), _("Check key "), MENU_PGP, OP_VERIFY_KEY);
strcat (helpstr, buf); /* __STRCAT_CHECKED__ */
mutt_make_help (buf, sizeof (buf), _("Help"), MENU_PGP, OP_HELP);
strcat (helpstr, buf); /* __STRCAT_CHECKED__ */
menu = mutt_new_menu (MENU_PGP);
menu->max = i;
menu->make_entry = pgp_entry;
menu->help = helpstr;
menu->data = KeyTable;
if (p)
snprintf (buf, sizeof (buf), _("PGP keys matching <%s>."), p->mailbox);
else
snprintf (buf, sizeof (buf), _("PGP keys matching \"%s\"."), s);
menu->title = buf;
kp = NULL;
mutt_clear_error ();
while (!done)
{
switch (mutt_menuLoop (menu))
{
case OP_VERIFY_KEY:
mutt_mktemp (tempfile, sizeof (tempfile));
if ((devnull = fopen ("/dev/null", "w")) == NULL) /* __FOPEN_CHECKED__ */
{
mutt_perror _("Can't open /dev/null");
break;
}
if ((fp = safe_fopen (tempfile, "w")) == NULL)
{
safe_fclose (&devnull);
mutt_perror _("Can't create temporary file");
break;
}
mutt_message _("Invoking PGP...");
snprintf (tmpbuf, sizeof (tmpbuf), "0x%s",
pgp_fpr_or_lkeyid (pgp_principal_key (KeyTable[menu->current]->parent)));
if ((thepid = pgp_invoke_verify_key (NULL, NULL, NULL, -1,
fileno (fp), fileno (devnull), tmpbuf)) == -1)
{
mutt_perror _("Can't create filter");
unlink (tempfile);
safe_fclose (&fp);
safe_fclose (&devnull);
}
mutt_wait_filter (thepid);
safe_fclose (&fp);
safe_fclose (&devnull);
mutt_clear_error ();
snprintf (cmd, sizeof (cmd), _("Key ID: 0x%s"),
pgp_keyid (pgp_principal_key (KeyTable[menu->current]->parent)));
mutt_do_pager (cmd, tempfile, 0, NULL);
menu->redraw = REDRAW_FULL;
break;
case OP_VIEW_ID:
mutt_message ("%s", NONULL (KeyTable[menu->current]->addr));
break;
case OP_GENERIC_SELECT_ENTRY:
/* XXX make error reporting more verbose */
if (option (OPTPGPCHECKTRUST))
if (!pgp_key_is_valid (KeyTable[menu->current]->parent))
{
mutt_error _("This key can't be used: expired/disabled/revoked.");
break;
}
if (option (OPTPGPCHECKTRUST) &&
(!pgp_id_is_valid (KeyTable[menu->current])
|| !pgp_id_is_strong (KeyTable[menu->current])))
{
char *s = "";
char buff[LONG_STRING];
if (KeyTable[menu->current]->flags & KEYFLAG_CANTUSE)
s = N_("ID is expired/disabled/revoked.");
else switch (KeyTable[menu->current]->trust & 0x03)
{
case 0:
s = N_("ID has undefined validity.");
break;
case 1:
s = N_("ID is not valid.");
break;
case 2:
s = N_("ID is only marginally valid.");
break;
}
snprintf (buff, sizeof (buff), _("%s Do you really want to use the key?"),
_(s));
if (mutt_yesorno (buff, M_NO) != M_YES)
{
mutt_clear_error ();
break;
}
}
# if 0
kp = pgp_principal_key (KeyTable[menu->current]->parent);
# else
kp = KeyTable[menu->current]->parent;
# endif
done = 1;
break;
case OP_EXIT:
kp = NULL;
done = 1;
break;
}
}
mutt_menuDestroy (&menu);
FREE (&KeyTable);
set_option (OPTNEEDREDRAW);
return (kp);
}
/* returns 0 if OK to proceed, -1 to abort, 1 to retry */
int mutt_save_confirm (const char *s, struct stat *st)
{
char tmp[_POSIX_PATH_MAX];
int ret = 0;
int rc;
int magic = 0;
magic = mx_get_magic (s);
#ifdef USE_POP
if (magic == M_POP) {
mutt_error _("Can't save message to POP mailbox.");
return 1;
}
#endif
#ifdef USE_NNTP
if (magic == M_NNTP) {
mutt_error _("Can't save message to newsserver.");
return 0;
}
#endif
if (magic > 0 && !mx_access (s, W_OK)) {
if (option (OPTCONFIRMAPPEND) &&
(!TrashPath || (str_cmp (s, TrashPath) != 0))) {
/* if we're appending to the trash, there's no point in asking */
snprintf (tmp, sizeof (tmp), _("Append messages to %s?"), s);
if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
ret = 1;
else if (rc == -1)
ret = -1;
}
}
if (stat (s, st) != -1) {
if (magic == -1) {
mutt_error (_("%s is not a mailbox!"), s);
return 1;
}
}
else {
#ifdef USE_IMAP
if (magic != M_IMAP)
#endif /* execute the block unconditionally if we don't use imap */
{
st->st_mtime = 0;
st->st_atime = 0;
if (errno == ENOENT) {
if (option (OPTCONFIRMCREATE)) {
snprintf (tmp, sizeof (tmp), _("Create %s?"), s);
if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
ret = 1;
else if (rc == -1)
ret = -1;
}
}
else {
mutt_perror (s);
return 1;
}
}
}
CLEARLINE (LINES - 1);
return (ret);
}
