/* close a mailbox opened in write-mode */
int mbox_close_mailbox(CONTEXT *ctx)
{
mx_unlock_file(ctx->path, fileno(ctx->fp), 1);
mutt_unblock_signals();
mx_fastclose_mailbox(ctx);
return 0;
}
/* Return the number of postponed messages.
* if force is 0, use a cached value if it is costly to get a fresh
* count (IMAP) - else check.
*/
int mutt_num_postponed(int force)
{
struct stat st;
CONTEXT ctx;
static time_t LastModify = 0;
static char *OldPostponed = NULL;
if (UpdateNumPostponed) {
UpdateNumPostponed = 0;
force = 1;
}
if (mutt_strcmp(Postponed, OldPostponed)) {
safe_free(&OldPostponed);
OldPostponed = safe_strdup(Postponed);
LastModify = 0;
force = 1;
}
if (!Postponed)
return 0;
if (stat(Postponed, &st) == -1) {
PostCount = 0;
LastModify = 0;
return 0;
}
if (S_ISDIR(st.st_mode)) {
/* if we have a maildir mailbox, we need to stat the "new" dir */
char buf[_POSIX_PATH_MAX];
snprintf(buf, sizeof(buf), "%s/new", Postponed);
if ((access(buf, F_OK) == 0)
&& (stat(buf, &st) == -1)) {
PostCount = 0;
LastModify = 0;
return 0;
}
}
if (LastModify < st.st_mtime) {
LastModify = st.st_mtime;
if (access(Postponed, R_OK | F_OK) != 0)
return PostCount = 0;
if (mx_open_mailbox(Postponed, M_NOSORT | M_QUIET, &ctx) == NULL)
PostCount = 0;
else
PostCount = ctx.msgcount;
mx_fastclose_mailbox(&ctx);
}
return PostCount;
}
/* Return the number of postponed messages.
* if force is 0, use a cached value if it is costly to get a fresh
* count (IMAP) - else check.
*/
int mutt_num_postponed (int force)
{
struct stat st;
CONTEXT ctx;
static time_t LastModify = 0;
static char *OldPostponed = NULL;
if (UpdateNumPostponed)
{
UpdateNumPostponed = 0;
force = 1;
}
if (mutt_strcmp (Postponed, OldPostponed))
{
FREE (&OldPostponed);
OldPostponed = safe_strdup (Postponed);
LastModify = 0;
force = 1;
}
if (!Postponed)
return 0;
#ifdef USE_IMAP
/* LastModify is useless for IMAP */
if (mx_is_imap (Postponed))
{
if (force)
{
short newpc;
newpc = imap_status (Postponed, 0);
if (newpc >= 0)
{
PostCount = newpc;
dprint (3, (debugfile, "mutt_num_postponed: %d postponed IMAP messages found.\n", PostCount));
}
else
dprint (3, (debugfile, "mutt_num_postponed: using old IMAP postponed count.\n"));
}
return PostCount;
}
#endif
if (stat (Postponed, &st) == -1)
{
PostCount = 0;
LastModify = 0;
return (0);
}
if (S_ISDIR (st.st_mode))
{
/* if we have a maildir mailbox, we need to stat the "new" dir */
char buf[_POSIX_PATH_MAX];
snprintf (buf, sizeof (buf), "%s/new", Postponed);
if (access (buf, F_OK) == 0 && stat (buf, &st) == -1)
{
PostCount = 0;
LastModify = 0;
return 0;
}
}
if (LastModify < st.st_mtime)
{
LastModify = st.st_mtime;
if (access (Postponed, R_OK | F_OK) != 0)
return (PostCount = 0);
if (mx_open_mailbox (Postponed, M_NOSORT | M_QUIET, &ctx) == NULL)
PostCount = 0;
else
PostCount = ctx.msgcount;
mx_fastclose_mailbox (&ctx);
}
return (PostCount);
}
/* args:
* ctx Context info, used when recalling a message to which
* we reply.
* hdr envelope/attachment info for recalled message
* cur if message was a reply, `cur' is set to the message which
* `hdr' is in reply to
* fcc fcc for the recalled message
* fcclen max length of fcc
*
* return vals:
* -1 error/no messages
* 0 normal exit
* SENDREPLY recalled message is a reply
*/
int mutt_get_postponed (CONTEXT *ctx, HEADER *hdr, HEADER **cur, char *fcc, size_t fcclen)
{
HEADER *h;
int code = SENDPOSTPONED;
LIST *tmp;
LIST *last = NULL;
LIST *next;
const char *p;
int opt_delete;
if (!Postponed)
return (-1);
if ((PostContext = mx_open_mailbox (Postponed, M_NOSORT, NULL)) == NULL)
{
PostCount = 0;
mutt_error _("No postponed messages.");
return (-1);
}
if (! PostContext->msgcount)
{
PostCount = 0;
mx_close_mailbox (PostContext, NULL);
FREE (&PostContext);
mutt_error _("No postponed messages.");
return (-1);
}
if (PostContext->msgcount == 1)
{
/* only one message, so just use that one. */
h = PostContext->hdrs[0];
}
else if ((h = select_msg ()) == NULL)
{
mx_close_mailbox (PostContext, NULL);
FREE (&PostContext);
return (-1);
}
if (mutt_prepare_template (NULL, PostContext, hdr, h, 0) < 0)
{
mx_fastclose_mailbox (PostContext);
FREE (&PostContext);
return (-1);
}
/* finished with this message, so delete it. */
mutt_set_flag (PostContext, h, M_DELETE, 1);
/* update the count for the status display */
PostCount = PostContext->msgcount - PostContext->deleted;
/* avoid the "purge deleted messages" prompt */
opt_delete = quadoption (OPT_DELETE);
set_quadoption (OPT_DELETE, M_YES);
mx_close_mailbox (PostContext, NULL);
set_quadoption (OPT_DELETE, opt_delete);
FREE (&PostContext);
for (tmp = hdr->env->userhdrs; tmp; )
{
if (ascii_strncasecmp ("X-Mutt-References:", tmp->data, 18) == 0)
{
if (ctx)
{
/* if a mailbox is currently open, look to see if the orignal message
the user attempted to reply to is in this mailbox */
p = skip_email_wsp(tmp->data + 18);
if (!ctx->id_hash)
ctx->id_hash = mutt_make_id_hash (ctx);
*cur = hash_find (ctx->id_hash, p);
}
/* Remove the X-Mutt-References: header field. */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
if (*cur)
code |= SENDREPLY;
}
else if (ascii_strncasecmp ("X-Mutt-Fcc:", tmp->data, 11) == 0)
{
p = skip_email_wsp(tmp->data + 11);
strfcpy (fcc, p, fcclen);
mutt_pretty_mailbox (fcc, fcclen);
/* remove the X-Mutt-Fcc: header field */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
/* note that x-mutt-fcc was present. we do this because we want to add a
* default fcc if the header was missing, but preserve the request of the
* user to not make a copy if the header field is present, but empty.
* see http://dev.mutt.org/trac/ticket/3653
*/
code |= SENDPOSTPONEDFCC;
}
else if ((WithCrypto & APPLICATION_PGP)
&& (mutt_strncmp ("Pgp:", tmp->data, 4) == 0 /* this is generated
* by old mutt versions
*/
|| mutt_strncmp ("X-Mutt-PGP:", tmp->data, 11) == 0))
{
hdr->security = mutt_parse_crypt_hdr (strchr (tmp->data, ':') + 1, 1,
APPLICATION_PGP);
hdr->security |= APPLICATION_PGP;
/* remove the pgp field */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
else if ((WithCrypto & APPLICATION_SMIME)
&& mutt_strncmp ("X-Mutt-SMIME:", tmp->data, 13) == 0)
{
hdr->security = mutt_parse_crypt_hdr (strchr (tmp->data, ':') + 1, 1,
APPLICATION_SMIME);
hdr->security |= APPLICATION_SMIME;
/* remove the smime field */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
#ifdef MIXMASTER
else if (mutt_strncmp ("X-Mutt-Mix:", tmp->data, 11) == 0)
{
char *t;
mutt_free_list (&hdr->chain);
t = strtok (tmp->data + 11, " \t\n");
while (t)
{
hdr->chain = mutt_add_list (hdr->chain, t);
t = strtok (NULL, " \t\n");
}
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
#endif
else
{
last = tmp;
tmp = tmp->next;
}
}
if (option (OPTCRYPTOPPORTUNISTICENCRYPT))
crypt_opportunistic_encrypt (hdr);
return (code);
}
/* 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);
}
/* Return the number of postponed messages.
* if force is 0, use a cached value if it is costly to get a fresh
* count (IMAP) - else check.
*/
int mutt_num_postponed (int force)
{
struct stat st;
CONTEXT ctx;
static time_t LastModify = 0;
static char *OldPostponed = NULL;
if (UpdateNumPostponed) {
UpdateNumPostponed = 0;
force = 1;
}
if (Postponed != OldPostponed) {
OldPostponed = Postponed;
LastModify = 0;
force = 1;
}
if (!Postponed)
return 0;
#ifdef USE_IMAP
/* LastModify is useless for IMAP */
if (imap_is_magic (Postponed, NULL) == M_IMAP) {
if (force) {
short newpc;
newpc = imap_mailbox_check (Postponed, 0);
if (newpc >= 0) {
PostCount = newpc;
debug_print (2, ("%d postponed IMAP messages found.\n", PostCount));
}
else
debug_print (2, ("using old IMAP postponed count.\n"));
}
return PostCount;
}
#endif
if (stat (Postponed, &st) == -1) {
PostCount = 0;
LastModify = 0;
return (0);
}
if (S_ISDIR (st.st_mode)) {
/* if we have a maildir mailbox, we need to stat the "new" dir */
char buf[_POSIX_PATH_MAX];
snprintf (buf, sizeof (buf), "%s/new", Postponed);
if (access (buf, F_OK) == 0 && stat (buf, &st) == -1) {
PostCount = 0;
LastModify = 0;
return 0;
}
}
if (LastModify < st.st_mtime) {
#ifdef USE_NNTP
int optnews = option (OPTNEWS);
#endif
LastModify = st.st_mtime;
if (access (Postponed, R_OK | F_OK) != 0)
return (PostCount = 0);
#ifdef USE_NNTP
if (optnews)
unset_option (OPTNEWS);
#endif
if (mx_open_mailbox (Postponed, M_NOSORT | M_QUIET, &ctx) == NULL)
PostCount = 0;
else
PostCount = ctx.msgcount;
mx_fastclose_mailbox (&ctx);
#ifdef USE_NNTP
if (optnews)
set_option (OPTNEWS);
#endif
}
return (PostCount);
}
/* args:
* ctx Context info, used when recalling a message to which
* we reply.
* hdr envelope/attachment info for recalled message
* cur if message was a reply, `cur' is set to the message which
* `hdr' is in reply to
* fcc fcc for the recalled message
* fcclen max length of fcc
*
* return vals:
* -1 error/no messages
* 0 normal exit
* SENDREPLY recalled message is a reply
*/
int mutt_get_postponed (CONTEXT * ctx, HEADER * hdr, HEADER ** cur, char *fcc,
size_t fcclen)
{
HEADER *h;
int code = SENDPOSTPONED;
LIST *tmp;
LIST *last = NULL;
LIST *next;
char *p;
int opt_delete;
if (!Postponed)
return (-1);
if ((PostContext = mx_open_mailbox (Postponed, M_NOSORT, NULL)) == NULL) {
PostCount = 0;
mutt_error _("No postponed messages.");
return (-1);
}
if (!PostContext->msgcount) {
PostCount = 0;
mx_close_mailbox (PostContext, NULL);
mem_free (&PostContext);
mutt_error _("No postponed messages.");
return (-1);
}
if (PostContext->msgcount == 1) {
/* only one message, so just use that one. */
h = PostContext->hdrs[0];
}
else if ((h = select_msg ()) == NULL) {
mx_close_mailbox (PostContext, NULL);
mem_free (&PostContext);
return (-1);
}
if (mutt_prepare_template (NULL, PostContext, hdr, h, 0) < 0) {
mx_fastclose_mailbox (PostContext);
mem_free (&PostContext);
return (-1);
}
/* finished with this message, so delete it. */
mutt_set_flag (PostContext, h, M_DELETE, 1);
/* and consider it saved, so that it won't be moved to the trash folder */
mutt_set_flag (PostContext, h, M_APPENDED, 1);
/* update the count for the status display */
PostCount = PostContext->msgcount - PostContext->deleted;
/* avoid the "purge deleted messages" prompt */
opt_delete = quadoption (OPT_DELETE);
set_quadoption (OPT_DELETE, M_YES);
mx_close_mailbox (PostContext, NULL);
set_quadoption (OPT_DELETE, opt_delete);
mem_free (&PostContext);
for (tmp = hdr->env->userhdrs; tmp;) {
if (ascii_strncasecmp ("X-Mutt-References:", tmp->data, 18) == 0) {
if (ctx) {
/* if a mailbox is currently open, look to see if the orignal message
the user attempted to reply to is in this mailbox */
p = tmp->data + 18;
SKIPWS (p);
if (!ctx->id_hash)
ctx->id_hash = mutt_make_id_hash (ctx);
*cur = hash_find (ctx->id_hash, p);
}
/* Remove the X-Mutt-References: header field. */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
if (*cur)
code |= SENDREPLY;
}
else if (ascii_strncasecmp ("X-Mutt-Fcc:", tmp->data, 11) == 0) {
p = tmp->data + 11;
SKIPWS (p);
strfcpy (fcc, p, fcclen);
mutt_pretty_mailbox (fcc);
/* remove the X-Mutt-Fcc: header field */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
else if ((WithCrypto & APPLICATION_PGP)
&& (str_ncmp ("Pgp:", tmp->data, 4) == 0 /* this is generated
* by old mutt versions
*/
|| str_ncmp ("X-Mutt-PGP:", tmp->data, 11) == 0)) {
hdr->security = mutt_parse_crypt_hdr (strchr (tmp->data, ':') + 1, 1);
hdr->security |= APPLICATION_PGP;
/* remove the pgp field */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
else if ((WithCrypto & APPLICATION_SMIME)
&& str_ncmp ("X-Mutt-SMIME:", tmp->data, 13) == 0) {
hdr->security = mutt_parse_crypt_hdr (strchr (tmp->data, ':') + 1, 1);
hdr->security |= APPLICATION_SMIME;
/* remove the smime field */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
#ifdef MIXMASTER
else if (str_ncmp ("X-Mutt-Mix:", tmp->data, 11) == 0) {
char *t;
mutt_free_list (&hdr->chain);
t = strtok (tmp->data + 11, " \t\n");
while (t) {
hdr->chain = mutt_add_list (hdr->chain, t);
t = strtok (NULL, " \t\n");
}
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
#endif
else {
last = tmp;
tmp = tmp->next;
}
}
return (code);
}
void mutt_fetchPopMail (void)
{
struct sockaddr_in sin;
#if SIZEOF_LONG == 4
long n;
#else
int n;
#endif
struct hostent *he;
char buffer[2048];
char msgbuf[SHORT_STRING];
int s, i, last = 0, msgs, bytes, err = 0;
CONTEXT ctx;
MESSAGE *msg = NULL;
if (!PopHost)
{
mutt_error _("POP host is not defined.");
return;
}
if (!PopUser)
{
mutt_error _("No POP username is defined.");
return;
}
if (!getPass ()) return;
s = socket (AF_INET, SOCK_STREAM, IPPROTO_IP);
memset ((char *) &sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (PopPort);
if ((n = inet_addr (NONULL(PopHost))) == -1)
{
/* Must be a DNS name */
if ((he = gethostbyname (NONULL(PopHost))) == NULL)
{
mutt_error (_("Could not find address for host %s."), PopHost);
return;
}
memcpy ((void *)&sin.sin_addr, *(he->h_addr_list), he->h_length);
}
else
memcpy ((void *)&sin.sin_addr, (void *)&n, sizeof(n));
mutt_message (_("Connecting to %s"), inet_ntoa (sin.sin_addr));
if (connect (s, (struct sockaddr *) &sin, sizeof (struct sockaddr_in)) == -1)
{
mutt_perror ("connect");
return;
}
if (getLine (s, buffer, sizeof (buffer)) == -1)
goto fail;
if (mutt_strncmp (buffer, "+OK", 3) != 0)
{
mutt_remove_trailing_ws (buffer);
mutt_error ("%s", buffer);
goto finish;
}
snprintf (buffer, sizeof(buffer), "user %s\r\n", PopUser);
write (s, buffer, mutt_strlen (buffer));
if (getLine (s, buffer, sizeof (buffer)) == -1)
goto fail;
if (mutt_strncmp (buffer, "+OK", 3) != 0)
{
mutt_remove_trailing_ws (buffer);
mutt_error ("%s", buffer);
goto finish;
}
snprintf (buffer, sizeof(buffer), "pass %s\r\n", NONULL(PopPass));
write (s, buffer, mutt_strlen (buffer));
if (getLine (s, buffer, sizeof (buffer)) == -1)
goto fail;
if (mutt_strncmp (buffer, "+OK", 3) != 0)
{
if(PopPass)
memset(PopPass, 0, mutt_strlen(PopPass));
safe_free((void **) &PopPass); /* void the given password */
mutt_remove_trailing_ws (buffer);
mutt_error ("%s", buffer[0] ? buffer : _("Server closed connection!"));
goto finish;
}
/* find out how many messages are in the mailbox. */
write (s, "stat\r\n", 6);
if (getLine (s, buffer, sizeof (buffer)) == -1)
goto fail;
if (mutt_strncmp (buffer, "+OK", 3) != 0)
{
mutt_remove_trailing_ws (buffer);
mutt_error ("%s", buffer);
goto finish;
}
sscanf (buffer, "+OK %d %d", &msgs, &bytes);
if (msgs == 0)
{
mutt_message _("No new mail in POP mailbox.");
goto finish;
}
if (mx_open_mailbox (NONULL(Spoolfile), M_APPEND, &ctx) == NULL)
goto finish;
/* only get unread messages */
if(option(OPTPOPLAST))
{
write (s, "last\r\n", 6);
if (getLine (s, buffer, sizeof (buffer)) == -1)
goto fail;
if (mutt_strncmp (buffer, "+OK", 3) == 0)
sscanf (buffer, "+OK %d", &last);
else
/* ignore an error here and assume all messages are new */
last = 0;
}
snprintf (msgbuf, sizeof (msgbuf),
msgs > 1 ? _("Reading new messages (%d bytes)...") :
_("Reading new message (%d bytes)..."), bytes);
mutt_message (msgbuf);
for (i = last + 1 ; i <= msgs ; i++)
{
snprintf (buffer, sizeof(buffer), "retr %d\r\n", i);
write (s, buffer, mutt_strlen (buffer));
if (getLine (s, buffer, sizeof (buffer)) == -1)
{
mx_fastclose_mailbox (&ctx);
goto fail;
}
if (mutt_strncmp (buffer, "+OK", 3) != 0)
{
mutt_remove_trailing_ws (buffer);
mutt_error ("%s", buffer);
break;
}
if ((msg = mx_open_new_message (&ctx, NULL, M_ADD_FROM)) == NULL)
{
err = 1;
break;
}
/* Now read the actual message. */
FOREVER
{
char *p;
int chunk;
if ((chunk = getLine (s, buffer, sizeof (buffer))) == -1)
{
mutt_error _("Error reading message!");
err = 1;
break;
}
/* check to see if we got a full line */
if (buffer[chunk-2] == '\r' && buffer[chunk-1] == '\n')
{
if (mutt_strcmp(".\r\n", buffer) == 0)
{
/* end of message */
break;
}
/* change CRLF to just LF */
buffer[chunk-2] = '\n';
buffer[chunk-1] = 0;
chunk--;
/* see if the line was byte-stuffed */
if (buffer[0] == '.')
{
p = buffer + 1;
chunk--;
}
else
p = buffer;
}
else
p = buffer;
fwrite (p, 1, chunk, msg->fp);
}
if (mx_commit_message (msg, &ctx) != 0)
{
mutt_error _("Error while writing mailbox!");
err = 1;
}
mx_close_message (&msg);
if (err)
break;
if (option (OPTPOPDELETE))
{
/* delete the message on the server */
snprintf (buffer, sizeof(buffer), "dele %d\r\n", i);
write (s, buffer, mutt_strlen (buffer));
/* eat the server response */
getLine (s, buffer, sizeof (buffer));
if (mutt_strncmp (buffer, "+OK", 3) != 0)
{
err = 1;
mutt_remove_trailing_ws (buffer);
mutt_error ("%s", buffer);
break;
}
}
if ( msgs > 1)
mutt_message (_("%s [%d of %d messages read]"), msgbuf, i, msgs);
else
mutt_message (_("%s [%d message read]"), msgbuf, msgs);
}
if (msg)
{
if (mx_commit_message (msg, &ctx) != 0)
err = 1;
mx_close_message (&msg);
}
mx_close_mailbox (&ctx, NULL);
if (err)
{
/* make sure no messages get deleted */
write (s, "rset\r\n", 6);
getLine (s, buffer, sizeof (buffer)); /* snarf the response */
}
finish:
/* exit gracefully */
write (s, "quit\r\n", 6);
getLine (s, buffer, sizeof (buffer)); /* snarf the response */
close (s);
return;
/* not reached */
fail:
mutt_error _("Server closed connection!");
close (s);
}
/**
* mbox_mbox_check - Implements MxOps::mbox_check()
* @param[in] m Mailbox
* @param[out] index_hint Keep track of current index selection
* @retval #MUTT_REOPENED Mailbox has been reopened
* @retval #MUTT_NEW_MAIL New mail has arrived
* @retval #MUTT_LOCKED Couldn't lock the file
* @retval 0 No change
* @retval -1 Error
*/
static int mbox_mbox_check(struct Mailbox *m, int *index_hint)
{
if (!m)
return -1;
struct MboxAccountData *adata = mbox_adata_get(m);
if (!adata)
return -1;
if (!adata->fp)
{
if (mbox_mbox_open(m) < 0)
return -1;
mutt_mailbox_changed(m, MBN_INVALID);
}
struct stat st;
bool unlock = false;
bool modified = false;
if (stat(m->path, &st) == 0)
{
if ((mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &m->mtime) == 0) &&
(st.st_size == m->size))
{
return 0;
}
if (st.st_size == m->size)
{
/* the file was touched, but it is still the same length, so just exit */
mutt_file_get_stat_timespec(&m->mtime, &st, MUTT_STAT_MTIME);
return 0;
}
if (st.st_size > m->size)
{
/* lock the file if it isn't already */
if (!adata->locked)
{
mutt_sig_block();
if (mbox_lock_mailbox(m, false, false) == -1)
{
mutt_sig_unblock();
/* we couldn't lock the mailbox, but nothing serious happened:
* probably the new mail arrived: no reason to wait till we can
* parse it: we'll get it on the next pass */
return MUTT_LOCKED;
}
unlock = 1;
}
/* Check to make sure that the only change to the mailbox is that
* message(s) were appended to this file. My heuristic is that we should
* see the message separator at *exactly* what used to be the end of the
* folder. */
char buf[1024];
if (fseeko(adata->fp, m->size, SEEK_SET) != 0)
mutt_debug(LL_DEBUG1, "#1 fseek() failed\n");
if (fgets(buf, sizeof(buf), adata->fp))
{
if (((m->magic == MUTT_MBOX) && mutt_str_startswith(buf, "From ", CASE_MATCH)) ||
((m->magic == MUTT_MMDF) && (mutt_str_strcmp(buf, MMDF_SEP) == 0)))
{
if (fseeko(adata->fp, m->size, SEEK_SET) != 0)
mutt_debug(LL_DEBUG1, "#2 fseek() failed\n");
int old_msg_count = m->msg_count;
if (m->magic == MUTT_MBOX)
mbox_parse_mailbox(m);
else
mmdf_parse_mailbox(m);
if (m->msg_count > old_msg_count)
mutt_mailbox_changed(m, MBN_INVALID);
/* Only unlock the folder if it was locked inside of this routine.
* It may have been locked elsewhere, like in
* mutt_checkpoint_mailbox(). */
if (unlock)
{
mbox_unlock_mailbox(m);
mutt_sig_unblock();
}
return MUTT_NEW_MAIL; /* signal that new mail arrived */
}
else
modified = true;
}
else
{
mutt_debug(LL_DEBUG1, "fgets returned NULL\n");
modified = true;
}
}
else
modified = true;
}
if (modified)
{
if (reopen_mailbox(m, index_hint) != -1)
{
mutt_mailbox_changed(m, MBN_INVALID);
if (unlock)
{
mbox_unlock_mailbox(m);
mutt_sig_unblock();
}
return MUTT_REOPENED;
}
}
/* fatal error */
mbox_unlock_mailbox(m);
mx_fastclose_mailbox(m);
mutt_sig_unblock();
mutt_error(_("Mailbox was corrupted"));
return -1;
}
/**
* mbox_mbox_sync - Implements MxOps::mbox_sync()
*/
static int mbox_mbox_sync(struct Mailbox *m, int *index_hint)
{
if (!m)
return -1;
struct MboxAccountData *adata = mbox_adata_get(m);
if (!adata)
return -1;
char tempfile[PATH_MAX];
char buf[32];
int i, j;
enum SortType save_sort = SORT_ORDER;
int rc = -1;
int need_sort = 0; /* flag to resort mailbox if new mail arrives */
int first = -1; /* first message to be written */
LOFF_T offset; /* location in mailbox to write changed messages */
struct stat statbuf;
struct MUpdate *new_offset = NULL;
struct MUpdate *old_offset = NULL;
FILE *fp = NULL;
struct Progress progress;
char msgbuf[PATH_MAX + 64];
/* sort message by their position in the mailbox on disk */
if (C_Sort != SORT_ORDER)
{
save_sort = C_Sort;
C_Sort = SORT_ORDER;
mutt_mailbox_changed(m, MBN_RESORT);
C_Sort = save_sort;
need_sort = 1;
}
/* need to open the file for writing in such a way that it does not truncate
* the file, so use read-write mode. */
adata->fp = freopen(m->path, "r+", adata->fp);
if (!adata->fp)
{
mx_fastclose_mailbox(m);
mutt_error(_("Fatal error! Could not reopen mailbox!"));
return -1;
}
mutt_sig_block();
if (mbox_lock_mailbox(m, true, true) == -1)
{
mutt_sig_unblock();
mutt_error(_("Unable to lock mailbox"));
goto bail;
}
/* Check to make sure that the file hasn't changed on disk */
i = mbox_mbox_check(m, index_hint);
if ((i == MUTT_NEW_MAIL) || (i == MUTT_REOPENED))
{
/* new mail arrived, or mailbox reopened */
rc = i;
goto bail;
}
else if (i < 0)
{
/* fatal error */
return -1;
}
/* Create a temporary file to write the new version of the mailbox in. */
mutt_mktemp(tempfile, sizeof(tempfile));
int fd = open(tempfile, O_WRONLY | O_EXCL | O_CREAT, 0600);
if ((fd == -1) || !(fp = fdopen(fd, "w")))
{
if (fd != -1)
{
close(fd);
unlink(tempfile);
}
mutt_error(_("Could not create temporary file"));
goto bail;
}
/* find the first deleted/changed message. we save a lot of time by only
* rewriting the mailbox from the point where it has actually changed. */
for (i = 0; (i < m->msg_count) && !m->emails[i]->deleted &&
!m->emails[i]->changed && !m->emails[i]->attach_del;
i++)
{
}
if (i == m->msg_count)
{
/* this means ctx->changed or m->msg_deleted was set, but no
* messages were found to be changed or deleted. This should
* never happen, is we presume it is a bug in neomutt. */
mutt_error(
_("sync: mbox modified, but no modified messages (report this bug)"));
mutt_debug(LL_DEBUG1, "no modified messages\n");
unlink(tempfile);
goto bail;
}
/* save the index of the first changed/deleted message */
first = i;
/* where to start overwriting */
offset = m->emails[i]->offset;
/* the offset stored in the header does not include the MMDF_SEP, so make
* sure we seek to the correct location */
if (m->magic == MUTT_MMDF)
offset -= (sizeof(MMDF_SEP) - 1);
/* allocate space for the new offsets */
new_offset = mutt_mem_calloc(m->msg_count - first, sizeof(struct MUpdate));
old_offset = mutt_mem_calloc(m->msg_count - first, sizeof(struct MUpdate));
if (!m->quiet)
{
snprintf(msgbuf, sizeof(msgbuf), _("Writing %s..."), m->path);
mutt_progress_init(&progress, msgbuf, MUTT_PROGRESS_MSG, C_WriteInc, m->msg_count);
}
for (i = first, j = 0; i < m->msg_count; i++)
{
if (!m->quiet)
mutt_progress_update(&progress, i, (int) (ftello(adata->fp) / (m->size / 100 + 1)));
/* back up some information which is needed to restore offsets when
* something fails. */
old_offset[i - first].valid = true;
old_offset[i - first].hdr = m->emails[i]->offset;
old_offset[i - first].body = m->emails[i]->content->offset;
old_offset[i - first].lines = m->emails[i]->lines;
old_offset[i - first].length = m->emails[i]->content->length;
if (!m->emails[i]->deleted)
{
j++;
if (m->magic == MUTT_MMDF)
{
if (fputs(MMDF_SEP, fp) == EOF)
{
mutt_perror(tempfile);
unlink(tempfile);
goto bail;
}
}
/* save the new offset for this message. we add 'offset' because the
* temporary file only contains saved message which are located after
* 'offset' in the real mailbox */
new_offset[i - first].hdr = ftello(fp) + offset;
if (mutt_copy_message_ctx(fp, m, m->emails[i], MUTT_CM_UPDATE,
CH_FROM | CH_UPDATE | CH_UPDATE_LEN) != 0)
{
mutt_perror(tempfile);
unlink(tempfile);
goto bail;
}
/* Since messages could have been deleted, the offsets stored in memory
* will be wrong, so update what we can, which is the offset of this
* message, and the offset of the body. If this is a multipart message,
* we just flush the in memory cache so that the message will be reparsed
* if the user accesses it later. */
new_offset[i - first].body = ftello(fp) - m->emails[i]->content->length + offset;
mutt_body_free(&m->emails[i]->content->parts);
switch (m->magic)
{
case MUTT_MMDF:
if (fputs(MMDF_SEP, fp) == EOF)
{
mutt_perror(tempfile);
unlink(tempfile);
goto bail;
}
break;
default:
if (fputs("\n", fp) == EOF)
{
mutt_perror(tempfile);
unlink(tempfile);
goto bail;
}
}
}
}
if (fclose(fp) != 0)
{
fp = NULL;
mutt_debug(LL_DEBUG1, "mutt_file_fclose (&) returned non-zero\n");
unlink(tempfile);
mutt_perror(tempfile);
goto bail;
}
fp = NULL;
/* Save the state of this folder. */
if (stat(m->path, &statbuf) == -1)
{
mutt_perror(m->path);
unlink(tempfile);
goto bail;
}
fp = fopen(tempfile, "r");
if (!fp)
{
mutt_sig_unblock();
mx_fastclose_mailbox(m);
mutt_debug(LL_DEBUG1, "unable to reopen temp copy of mailbox!\n");
mutt_perror(tempfile);
FREE(&new_offset);
FREE(&old_offset);
return -1;
}
if ((fseeko(adata->fp, offset, SEEK_SET) != 0) || /* seek the append location */
/* do a sanity check to make sure the mailbox looks ok */
!fgets(buf, sizeof(buf), adata->fp) ||
((m->magic == MUTT_MBOX) && !mutt_str_startswith(buf, "From ", CASE_MATCH)) ||
((m->magic == MUTT_MMDF) && (mutt_str_strcmp(MMDF_SEP, buf) != 0)))
{
mutt_debug(LL_DEBUG1, "message not in expected position\n");
mutt_debug(LL_DEBUG1, "\tLINE: %s\n", buf);
i = -1;
}
else
{
if (fseeko(adata->fp, offset, SEEK_SET) != 0) /* return to proper offset */
{
i = -1;
mutt_debug(LL_DEBUG1, "fseek() failed\n");
}
else
{
/* copy the temp mailbox back into place starting at the first
* change/deleted message */
if (!m->quiet)
mutt_message(_("Committing changes..."));
i = mutt_file_copy_stream(fp, adata->fp);
if (ferror(adata->fp))
i = -1;
}
if (i == 0)
{
m->size = ftello(adata->fp); /* update the mailbox->size of the mailbox */
if ((m->size < 0) || (ftruncate(fileno(adata->fp), m->size) != 0))
{
i = -1;
mutt_debug(LL_DEBUG1, "ftruncate() failed\n");
}
}
}
mutt_file_fclose(&fp);
fp = NULL;
mbox_unlock_mailbox(m);
if ((mutt_file_fclose(&adata->fp) != 0) || (i == -1))
{
/* error occurred while writing the mailbox back, so keep the temp copy around */
char savefile[PATH_MAX];
snprintf(savefile, sizeof(savefile), "%s/neomutt.%s-%s-%u", NONULL(C_Tmpdir),
NONULL(Username), NONULL(ShortHostname), (unsigned int) getpid());
rename(tempfile, savefile);
mutt_sig_unblock();
mx_fastclose_mailbox(m);
mutt_pretty_mailbox(savefile, sizeof(savefile));
mutt_error(_("Write failed! Saved partial mailbox to %s"), savefile);
FREE(&new_offset);
FREE(&old_offset);
return -1;
}
/* Restore the previous access/modification times */
mbox_reset_atime(m, &statbuf);
/* reopen the mailbox in read-only mode */
adata->fp = fopen(m->path, "r");
if (!adata->fp)
{
unlink(tempfile);
mutt_sig_unblock();
mx_fastclose_mailbox(m);
mutt_error(_("Fatal error! Could not reopen mailbox!"));
FREE(&new_offset);
FREE(&old_offset);
return -1;
}
/* update the offsets of the rewritten messages */
for (i = first, j = first; i < m->msg_count; i++)
{
if (!m->emails[i]->deleted)
{
m->emails[i]->offset = new_offset[i - first].hdr;
m->emails[i]->content->hdr_offset = new_offset[i - first].hdr;
m->emails[i]->content->offset = new_offset[i - first].body;
m->emails[i]->index = j++;
}
}
FREE(&new_offset);
FREE(&old_offset);
unlink(tempfile); /* remove partial copy of the mailbox */
mutt_sig_unblock();
if (C_CheckMboxSize)
{
struct Mailbox *tmp = mutt_find_mailbox(m->path);
if (tmp && !tmp->has_new)
mutt_update_mailbox(tmp);
}
return 0; /* signal success */
bail: /* Come here in case of disaster */
mutt_file_fclose(&fp);
/* restore offsets, as far as they are valid */
if ((first >= 0) && old_offset)
{
for (i = first; (i < m->msg_count) && old_offset[i - first].valid; i++)
{
m->emails[i]->offset = old_offset[i - first].hdr;
m->emails[i]->content->hdr_offset = old_offset[i - first].hdr;
m->emails[i]->content->offset = old_offset[i - first].body;
m->emails[i]->lines = old_offset[i - first].lines;
m->emails[i]->content->length = old_offset[i - first].length;
}
}
/* this is ok to call even if we haven't locked anything */
mbox_unlock_mailbox(m);
mutt_sig_unblock();
FREE(&new_offset);
FREE(&old_offset);
adata->fp = freopen(m->path, "r", adata->fp);
if (!adata->fp)
{
mutt_error(_("Could not reopen mailbox"));
mx_fastclose_mailbox(m);
return -1;
}
if (need_sort)
{
/* if the mailbox was reopened, the thread tree will be invalid so make
* sure to start threading from scratch. */
mutt_mailbox_changed(m, MBN_RESORT);
}
return rc;
}
/* return values:
* 0 success
* -1 failure
*/
int mbox_sync_mailbox(CONTEXT *ctx, int *index_hint)
{
char tempfile[_POSIX_PATH_MAX];
char buf[32];
int i, j, save_sort = SORT_ORDER;
int rc = -1;
int need_sort = 0; /* flag to resort mailbox if new mail arrives */
int first = -1; /* first message to be written */
LOFF_T offset; /* location in mailbox to write changed messages */
struct stat statbuf;
struct m_update_t *newOffset = NULL;
struct m_update_t *oldOffset = NULL;
FILE *fp = NULL;
progress_t progress;
char msgbuf[STRING];
/* sort message by their position in the mailbox on disk */
if (Sort != SORT_ORDER) {
save_sort = Sort;
Sort = SORT_ORDER;
mutt_sort_headers(ctx, 0);
Sort = save_sort;
need_sort = 1;
}
/* need to open the file for writing in such a way that it does not truncate
* the file, so use read-write mode.
*/
if ((ctx->fp = freopen(ctx->path, "r+", ctx->fp)) == NULL) {
mx_fastclose_mailbox(ctx);
mutt_error _("Fatal error! Could not reopen mailbox!");
return -1;
}
mutt_block_signals();
if (mbox_lock_mailbox(ctx, 1, 1) == -1) {
mutt_unblock_signals();
mutt_error _("Unable to lock mailbox!");
goto bail;
}
/* Check to make sure that the file hasn't changed on disk */
if (((i = mbox_check_mailbox(ctx, index_hint)) == M_NEW_MAIL)
|| (i == M_REOPENED)) {
/* new mail arrived, or mailbox reopened */
need_sort = i;
rc = i;
goto bail;
} else if (i < 0)
/* fatal error */
return -1;
/* Create a temporary file to write the new version of the mailbox in. */
mutt_mktemp(tempfile, sizeof(tempfile));
if (((i = open(tempfile, O_WRONLY | O_EXCL | O_CREAT, 0600)) == -1)
|| ((fp = fdopen(i, "w")) == NULL)) {
if (-1 != i) {
close(i);
unlink(tempfile);
}
mutt_error _("Could not create temporary file!");
mutt_sleep(5);
goto bail;
}
/* find the first deleted/changed message. we save a lot of time by only
* rewriting the mailbox from the point where it has actually changed.
*/
for (i = 0; i < ctx->msgcount
&& !ctx->hdrs[i]->deleted
&& !ctx->hdrs[i]->changed
&& !ctx->hdrs[i]->attach_del; i++)
;
if (i == ctx->msgcount) {
/* this means ctx->changed or ctx->deleted was set, but no
* messages were found to be changed or deleted. This should
* never happen, is we presume it is a bug in mutt.
*/
mutt_error _(
"sync: mbox modified, but no modified messages! (report this bug)");
mutt_sleep(5); /* the mutt_error /will/ get cleared! */
dprint(1, "mbox_sync_mailbox(): no modified messages.\n");
unlink(tempfile);
goto bail;
}
/* save the index of the first changed/deleted message */
first = i;
/* where to start overwriting */
offset = ctx->hdrs[i]->offset;
/* the offset stored in the header does not include the MMDF_SEP, so make
* sure we seek to the correct location
*/
if (ctx->magic == M_MMDF)
offset -= (sizeof MMDF_SEP - 1);
/* allocate space for the new offsets */
newOffset = (__typeof__(newOffset)) safe_calloc(ctx->msgcount - first, sizeof(struct m_update_t));
oldOffset = (__typeof__(oldOffset)) safe_calloc(ctx->msgcount - first, sizeof(struct m_update_t));
if (!ctx->quiet) {
snprintf(msgbuf, sizeof(msgbuf), _("Writing %s..."), ctx->path);
mutt_progress_init(&progress,
msgbuf,
M_PROGRESS_MSG,
WriteInc,
ctx->msgcount);
}
for (i = first, j = 0; i < ctx->msgcount; i++) {
if (!ctx->quiet)
mutt_progress_update(&progress, i,
(int)(ftello(ctx->fp) /
(ctx->size / 100 + 1)));
/*
* back up some information which is needed to restore offsets when
* something fails.
*/
oldOffset[i - first].valid = 1;
oldOffset[i - first].hdr = ctx->hdrs[i]->offset;
oldOffset[i - first].body = ctx->hdrs[i]->content->offset;
oldOffset[i - first].lines = ctx->hdrs[i]->lines;
oldOffset[i - first].length = ctx->hdrs[i]->content->length;
if (!ctx->hdrs[i]->deleted) {
j++;
if (ctx->magic == M_MMDF) {
if (fputs(MMDF_SEP, fp) == EOF) {
mutt_perror(tempfile);
mutt_sleep(5);
unlink(tempfile);
goto bail;
}
}
/* save the new offset for this message. we add `offset' because
the
* temporary file only contains saved message which are located
*after
* `offset' in the real mailbox
*/
newOffset[i - first].hdr = ftello(fp) + offset;
if (mutt_copy_message(fp, ctx, ctx->hdrs[i], M_CM_UPDATE,
CH_FROM | CH_UPDATE | CH_UPDATE_LEN) != 0) {
mutt_perror(tempfile);
mutt_sleep(5);
unlink(tempfile);
goto bail;
}
/* Since messages could have been deleted, the offsets stored in
memory
* will be wrong, so update what we can, which is the offset of this
* message, and the offset of the body. If this is a multipart
*message,
* we just flush the in memory cache so that the message will be
*reparsed
* if the user accesses it later.
*/
newOffset[i - first].body = ftello(fp) -
ctx->hdrs[i]->content->length + offset;
mutt_free_body(&ctx->hdrs[i]->content->parts);
switch (ctx->magic) {
case M_MMDF:
if (fputs(MMDF_SEP, fp) == EOF) {
mutt_perror(tempfile);
mutt_sleep(5);
unlink(tempfile);
goto bail;
}
break;
default:
if (fputs("\n", fp) == EOF) {
mutt_perror(tempfile);
mutt_sleep(5);
unlink(tempfile);
goto bail;
}
}
}
}
if (fclose(fp) != 0) {
fp = NULL;
dprint(1, "mbox_sync_mailbox: safe_fclose (&) returned non-zero.\n");
unlink(tempfile);
mutt_perror(tempfile);
mutt_sleep(5);
goto bail;
}
fp = NULL;
/* Save the state of this folder. */
if (stat(ctx->path, &statbuf) == -1) {
mutt_perror(ctx->path);
mutt_sleep(5);
unlink(tempfile);
goto bail;
}
if ((fp = fopen(tempfile, "r")) == NULL) {
mutt_unblock_signals();
mx_fastclose_mailbox(ctx);
dprint(1, "mbox_sync_mailbox: unable to reopen temp copy of mailbox!\n");
mutt_perror(tempfile);
mutt_sleep(5);
return -1;
}
if ((fseeko(ctx->fp, offset, SEEK_SET) != 0) /* seek the append location */
||/* do a sanity check to make sure the mailbox looks ok */
(fgets(buf, sizeof(buf), ctx->fp) == NULL)
|| ((ctx->magic == M_MBOX)
&& (mutt_strncmp("From ", buf, 5) != 0))
|| ((ctx->magic == M_MMDF)
&& (mutt_strcmp(MMDF_SEP, buf) != 0))) {
dprint(1, "mbox_sync_mailbox: message not in expected position.");
dprint(1, "\tLINE: %s\n", buf);
i = -1;
} else {
if (fseeko(ctx->fp, offset, SEEK_SET) != 0) { /* return to proper offset
*/
i = -1;
dprint(1, "mbox_sync_mailbox: fseek() failed\n");
} else {
/* copy the temp mailbox back into place starting at the first
* change/deleted message
*/
if (!ctx->quiet)
mutt_message _("Committing changes...");
i = mutt_copy_stream(fp, ctx->fp);
if (ferror(ctx->fp))
i = -1;
}
if (i == 0) {
ctx->size = ftello(ctx->fp); /* update the size of the mailbox */
ftruncate(fileno(ctx->fp), ctx->size);
}
}
safe_fclose(&fp);
fp = NULL;
mbox_unlock_mailbox(ctx);
if ((fclose(ctx->fp) != 0)
|| (i == -1)) {
/* error occurred while writing the mailbox back, so keep the temp copy
* around
*/
char savefile[_POSIX_PATH_MAX];
snprintf(savefile, sizeof(savefile), "%s/mutt.%s-%s-%u",
NONULL(Tempdir), NONULL(Username), NONULL(Hostname),
(unsigned int)getpid());
rename(tempfile, savefile);
mutt_unblock_signals();
mx_fastclose_mailbox(ctx);
mutt_pretty_mailbox(savefile, sizeof(savefile));
mutt_error(_("Write failed! Saved partial mailbox to %s"), savefile);
mutt_sleep(5);
return -1;
}
/* Restore the previous access/modification times */
mbox_reset_atime(ctx, &statbuf);
/* reopen the mailbox in read-only mode */
if ((ctx->fp = fopen(ctx->path, "r")) == NULL) {
unlink(tempfile);
mutt_unblock_signals();
mx_fastclose_mailbox(ctx);
mutt_error _("Fatal error! Could not reopen mailbox!");
return -1;
}
/* update the offsets of the rewritten messages */
for (i = first, j = first; i < ctx->msgcount; i++) {
if (!ctx->hdrs[i]->deleted) {
ctx->hdrs[i]->offset = newOffset[i - first].hdr;
ctx->hdrs[i]->content->hdr_offset = newOffset[i - first].hdr;
ctx->hdrs[i]->content->offset = newOffset[i - first].body;
ctx->hdrs[i]->index = j++;
}
}
safe_free(&newOffset);
safe_free(&oldOffset);
unlink(tempfile); /* remove partial copy of the mailbox */
mutt_unblock_signals();
return 0; /* signal success */
bail: /* Come here in case of disaster */
safe_fclose(&fp);
/* restore offsets, as far as they are valid */
if ((first >= 0)
&& oldOffset) {
for (i = first; i < ctx->msgcount
&& oldOffset[i - first].valid; i++) {
ctx->hdrs[i]->offset = oldOffset[i - first].hdr;
ctx->hdrs[i]->content->hdr_offset = oldOffset[i - first].hdr;
ctx->hdrs[i]->content->offset = oldOffset[i - first].body;
ctx->hdrs[i]->lines = oldOffset[i - first].lines;
ctx->hdrs[i]->content->length = oldOffset[i - first].length;
}
}
/* this is ok to call even if we haven't locked anything */
mbox_unlock_mailbox(ctx);
mutt_unblock_signals();
safe_free(&newOffset);
safe_free(&oldOffset);
if ((ctx->fp = freopen(ctx->path, "r", ctx->fp)) == NULL) {
mutt_error _("Could not reopen mailbox!");
mx_fastclose_mailbox(ctx);
return -1;
}
if (need_sort)
/* if the mailbox was reopened, the thread tree will be invalid so make
* sure to start threading from scratch. */
mutt_sort_headers(ctx, (need_sort == M_REOPENED));
return rc;
}
/* check to see if the mailbox has changed on disk.
*
* return values:
* M_REOPENED mailbox has been reopened
* M_NEW_MAIL new mail has arrived!
* M_LOCKED couldn't lock the file
* 0 no change
* -1 error
*/
int mbox_check_mailbox(CONTEXT *ctx, int *index_hint)
{
struct stat st;
char buffer[LONG_STRING];
int unlock = 0;
int modified = 0;
if (stat(ctx->path, &st) == 0) {
if ((st.st_mtime == ctx->mtime)
&& (st.st_size == ctx->size))
return 0;
if (st.st_size == ctx->size) {
/* the file was touched, but it is still the same length, so just
exit */
ctx->mtime = st.st_mtime;
return 0;
}
if (st.st_size > ctx->size) {
/* lock the file if it isn't already */
if (!ctx->locked) {
mutt_block_signals();
if (mbox_lock_mailbox(ctx, 0, 0) == -1) {
mutt_unblock_signals();
/* we couldn't lock the mailbox, but nothing serious
happened:
* probably the new mail arrived: no reason to wait till we
*can
* parse it: we'll get it on the next pass
*/
return M_LOCKED;
}
unlock = 1;
}
/*
* Check to make sure that the only change to the mailbox is that
* message(s) were appended to this file. My heuristic is that we
*should
* see the message separator at *exactly* what used to be the end of
*the
* folder.
*/
if (fseeko(ctx->fp, ctx->size, SEEK_SET) != 0)
dprint(1, "mbox_check_mailbox: fseek() failed\n");
if (fgets(buffer, sizeof(buffer), ctx->fp) != NULL) {
if (((ctx->magic == M_MBOX)
&& (mutt_strncmp("From ", buffer, 5) == 0))
|| ((ctx->magic == M_MMDF)
&& (mutt_strcmp(MMDF_SEP, buffer) == 0))) {
if (fseeko(ctx->fp, ctx->size, SEEK_SET) != 0)
dprint(1, "mbox_check_mailbox: fseek() failed\n");
if (ctx->magic == M_MBOX)
mbox_parse_mailbox(ctx);
else
mmdf_parse_mailbox(ctx);
/* Only unlock the folder if it was locked inside of this
routine.
* It may have been locked elsewhere, like in
* mutt_checkpoint_mailbox().
*/
if (unlock) {
mbox_unlock_mailbox(ctx);
mutt_unblock_signals();
}
return M_NEW_MAIL; /* signal that new mail arrived */
} else
modified = 1;
} else {
dprint(1, "mbox_check_mailbox: fgets returned NULL.\n");
modified = 1;
}
} else
modified = 1;
}
if (modified) {
if (mutt_reopen_mailbox(ctx, index_hint) != -1) {
if (unlock) {
mbox_unlock_mailbox(ctx);
mutt_unblock_signals();
}
return M_REOPENED;
}
}
/* fatal error */
mbox_unlock_mailbox(ctx);
mx_fastclose_mailbox(ctx);
mutt_unblock_signals();
mutt_error _("Mailbox was corrupted!");
return -1;
}
/* args:
* ctx Context info, used when recalling a message to which
* we reply.
* hdr envelope/attachment info for recalled message
* cur if message was a reply, `cur' is set to the message which
* `hdr' is in reply to
* fcc fcc for the recalled message
* fcclen max length of fcc
*
* return vals:
* -1 error/no messages
* 0 normal exit
* SENDREPLY recalled message is a reply
*/
int mutt_get_postponed (CONTEXT *ctx, HEADER *hdr, HEADER **cur, char *fcc, size_t fcclen)
{
HEADER *h;
int code = SENDPOSTPONED;
LIST *tmp;
LIST *last = NULL;
LIST *next;
char *p;
int opt_delete;
#ifdef USE_IMAP
char curpath[LONG_STRING];
int need_reopen = 0;
#endif
if (!Postponed)
return (-1);
#ifdef USE_IMAP
/* if we're in an IMAP folder and the postponed folder is also IMAP, we may
* need to take steps to avoid opening an additional connection to the same
* server. */
if ((ctx && ctx->magic == M_IMAP) && mx_is_imap (Postponed))
{
strfcpy (curpath, ctx->path, sizeof (curpath));
if (imap_select_mailbox (ctx, Postponed) < 0)
return -1;
need_reopen = 1;
PostContext = ctx;
}
else
#endif
if ((PostContext = mx_open_mailbox (Postponed, M_NOSORT, NULL)) == NULL)
{
PostCount = 0;
mutt_error _("No postponed messages.");
return (-1);
}
if (! PostContext->msgcount)
{
PostCount = 0;
mx_close_mailbox (PostContext, NULL);
#ifdef USE_IMAP
if (need_reopen)
ctx = mx_open_mailbox (curpath, 0, PostContext);
else
#endif
safe_free ((void **) &PostContext);
mutt_error _("No postponed messages.");
return (-1);
}
if (PostContext->msgcount == 1)
{
/* only one message, so just use that one. */
h = PostContext->hdrs[0];
}
else if ((h = select_msg ()) == NULL)
{
mx_close_mailbox (PostContext, NULL);
#ifdef USE_IMAP
if (need_reopen)
ctx = mx_open_mailbox (curpath, 0, PostContext);
else
#endif
safe_free ((void **) &PostContext);
return (-1);
}
if (mutt_prepare_template (NULL, PostContext, hdr, h, 0) < 0)
{
mx_fastclose_mailbox (PostContext);
#ifdef USE_IMAP
if (need_reopen)
ctx = mx_open_mailbox (curpath, 0, NULL);
else
#endif
safe_free ((void **) &PostContext);
return (-1);
}
/* finished with this message, so delete it. */
mutt_set_flag (PostContext, h, M_DELETE, 1);
/* update the count for the status display */
PostCount = PostContext->msgcount - PostContext->deleted;
/* avoid the "purge deleted messages" prompt */
opt_delete = quadoption (OPT_DELETE);
set_quadoption (OPT_DELETE, M_YES);
mx_close_mailbox (PostContext, NULL);
set_quadoption (OPT_DELETE, opt_delete);
#ifdef USE_IMAP
if (need_reopen)
ctx = mx_open_mailbox (curpath, 0, PostContext);
else
#endif
safe_free ((void **) &PostContext);
for (tmp = hdr->env->userhdrs; tmp; )
{
if (mutt_strncasecmp ("X-Mutt-References:", tmp->data, 18) == 0)
{
if (ctx)
{
/* if a mailbox is currently open, look to see if the orignal message
the user attempted to reply to is in this mailbox */
p = tmp->data + 18;
SKIPWS (p);
*cur = hash_find (ctx->id_hash, p);
}
/* Remove the X-Mutt-References: header field. */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
if (*cur)
code |= SENDREPLY;
}
else if (mutt_strncasecmp ("X-Mutt-Fcc:", tmp->data, 11) == 0)
{
p = tmp->data + 11;
SKIPWS (p);
strfcpy (fcc, p, fcclen);
mutt_pretty_mailbox (fcc);
/* remove the X-Mutt-Fcc: header field */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
#ifdef HAVE_PGP
else if (mutt_strncmp ("Pgp:", tmp->data, 4) == 0 /* this is generated
* by old mutt versions
*/
|| mutt_strncmp ("X-Mutt-PGP:", tmp->data, 11) == 0)
{
hdr->pgp = mutt_parse_pgp_hdr (strchr (tmp->data, ':') + 1, 1);
/* remove the pgp field */
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
#endif /* HAVE_PGP */
#ifdef MIXMASTER
else if (mutt_strncmp ("X-Mutt-Mix:", tmp->data, 11) == 0)
{
char *t;
mutt_free_list (&hdr->chain);
t = strtok (tmp->data + 11, " \t\n");
while (t)
{
hdr->chain = mutt_add_list (hdr->chain, t);
t = strtok (NULL, " \t\n");
}
next = tmp->next;
if (last)
last->next = tmp->next;
else
hdr->env->userhdrs = tmp->next;
tmp->next = NULL;
mutt_free_list (&tmp);
tmp = next;
}
#endif
else
{
last = tmp;
tmp = tmp->next;
}
}
return (code);
}
