granicus.if.org Git - neomutt/blob - editmsg.c

   1 /**
   2  * @file
   3  * Prepare an email to be edited
   4  *
   5  * @authors
   6  * Copyright (C) 1999-2002 Thomas Roessler <roessler@does-not-exist.org>
   7  *
   8  * @copyright
   9  * This program is free software: you can redistribute it and/or modify it under
  10  * the terms of the GNU General Public License as published by the Free Software
  11  * Foundation, either version 2 of the License, or (at your option) any later
  12  * version.
  13  *
  14  * This program is distributed in the hope that it will be useful, but WITHOUT
  15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  16  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  17  * details.
  18  *
  19  * You should have received a copy of the GNU General Public License along with
  20  * this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 /**
  24  * @page editmsg Prepare an email to be edited
  25  *
  26  * Prepare an email to be edited
  27  */
  28
  29 #include "config.h"
  30 #include <errno.h>
  31 #include <limits.h>
  32 #include <stdbool.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <sys/stat.h>
  36 #include <time.h>
  37 #include <unistd.h>
  38 #include "mutt/mutt.h"
  39 #include "config/lib.h"
  40 #include "email/lib.h"
  41 #include "mutt.h"
  42 #include "context.h"
  43 #include "copy.h"
  44 #include "curs_lib.h"
  45 #include "globals.h"
  46 #include "mailbox.h"
  47 #include "muttlib.h"
  48 #include "mx.h"
  49 #include "protos.h"
  50
  51 /**
  52  * edit_or_view_one_message - Edit an email or view it in an external editor
  53  * @param edit true if the message should be editable. If false, changes
  54  *            to the message (in the editor) will be ignored.
  55  * @param m   Mailbox
  56  * @param cur Email
  57  * @retval 1  Message not modified
  58  * @retval 0  Message edited successfully
  59  * @retval -1 Error
  60  */
  61 static int edit_or_view_one_message(bool edit, struct Mailbox *m, struct Email *cur)
  62 {
  63   char tmp[PATH_MAX];
  64   char buf[STRING];
  65   enum MailboxType omagic;
  66   int oerrno;
  67   int rc;
  68
  69   bool o_read;
  70   bool o_old;
  71
  72   int of, cf;
  73
  74   struct Message *msg = NULL;
  75
  76   FILE *fp = NULL;
  77
  78   struct stat sb;
  79   time_t mtime = 0;
  80
  81   mutt_mktemp(tmp, sizeof(tmp));
  82
  83   omagic = MboxType;
  84   MboxType = MUTT_MBOX;
  85
  86   struct Context *tmpctx = mx_mbox_open(NULL, tmp, MUTT_NEWFOLDER);
  87
  88   MboxType = omagic;
  89
  90   if (!tmpctx)
  91   {
  92     mutt_error(_("could not create temporary folder: %s"), strerror(errno));
  93     return -1;
  94   }
  95
  96   const int chflags =
  97       CH_NOLEN | ((m->magic == MUTT_MBOX || m->magic == MUTT_MMDF) ? 0 : CH_NOSTATUS);
  98   rc = mutt_append_message(tmpctx->mailbox, m, cur, 0, chflags);
  99   oerrno = errno;
 100
 101   mx_mbox_close(&tmpctx);
 102
 103   if (rc == -1)
 104   {
 105     mutt_error(_("could not write temporary mail folder: %s"), strerror(oerrno));
 106     goto bail;
 107   }
 108
 109   rc = stat(tmp, &sb);
 110   if (rc == -1)
 111   {
 112     mutt_error(_("Can't stat %s: %s"), tmp, strerror(errno));
 113     goto bail;
 114   }
 115
 116   /* The file the user is going to edit is not a real mbox, so we need to
 117    * truncate the last newline in the temp file, which is logically part of
 118    * the message separator, and not the body of the message.  If we fail to
 119    * remove it, the message will grow by one line each time the user edits
 120    * the message.
 121    */
 122   if (sb.st_size != 0 && truncate(tmp, sb.st_size - 1) == -1)
 123   {
 124     mutt_error(_("could not truncate temporary mail folder: %s"), strerror(errno));
 125     goto bail;
 126   }
 127
 128   if (!edit)
 129   {
 130     /* remove write permissions */
 131     rc = mutt_file_chmod_rm_stat(tmp, S_IWUSR | S_IWGRP | S_IWOTH, &sb);
 132     if (rc == -1)
 133     {
 134       mutt_debug(1, "Could not remove write permissions of %s: %s", tmp, strerror(errno));
 135       /* Do not bail out here as we are checking afterwards if we should adopt
 136        * changes of the temporary file. */
 137     }
 138   }
 139
 140   /* Do not reuse the stat sb here as it is outdated. */
 141   mtime = mutt_file_decrease_mtime(tmp, NULL);
 142
 143   mutt_edit_file(NONULL(Editor), tmp);
 144
 145   rc = stat(tmp, &sb);
 146   if (rc == -1)
 147   {
 148     mutt_error(_("Can't stat %s: %s"), tmp, strerror(errno));
 149     goto bail;
 150   }
 151
 152   if (sb.st_size == 0)
 153   {
 154     mutt_message(_("Message file is empty"));
 155     rc = 1;
 156     goto bail;
 157   }
 158
 159   if (edit && sb.st_mtime == mtime)
 160   {
 161     mutt_message(_("Message not modified"));
 162     rc = 1;
 163     goto bail;
 164   }
 165
 166   if (!edit && sb.st_mtime != mtime)
 167   {
 168     mutt_message(_("Message of read-only mailbox modified! Ignoring changes."));
 169     rc = 1;
 170     goto bail;
 171   }
 172
 173   if (!edit)
 174   {
 175     /* stop processing here and skip right to the end */
 176     rc = 1;
 177     goto bail;
 178   }
 179
 180   fp = fopen(tmp, "r");
 181   if (!fp)
 182   {
 183     rc = -1;
 184     mutt_error(_("Can't open message file: %s"), strerror(errno));
 185     goto bail;
 186   }
 187
 188   tmpctx = mx_mbox_open(m, NULL, MUTT_APPEND);
 189   if (!tmpctx)
 190   {
 191     rc = -1;
 192     /* L10N: %s is from strerror(errno) */
 193     mutt_error(_("Can't append to folder: %s"), strerror(errno));
 194     goto bail;
 195   }
 196
 197   of = 0;
 198   cf = (((tmpctx->mailbox->magic == MUTT_MBOX) || (tmpctx->mailbox->magic == MUTT_MMDF)) ?
 199             0 :
 200             CH_NOSTATUS);
 201
 202   if (fgets(buf, sizeof(buf), fp) && is_from(buf, NULL, 0, NULL))
 203   {
 204     if ((tmpctx->mailbox->magic == MUTT_MBOX) || (tmpctx->mailbox->magic == MUTT_MMDF))
 205       cf = CH_FROM | CH_FORCE_FROM;
 206   }
 207   else
 208     of = MUTT_ADD_FROM;
 209
 210   /* XXX - we have to play games with the message flags to avoid
 211    * problematic behavior with maildir folders.  */
 212
 213   o_read = cur->read;
 214   o_old = cur->old;
 215   cur->read = false;
 216   cur->old = false;
 217   msg = mx_msg_open_new(tmpctx->mailbox, cur, of);
 218   cur->read = o_read;
 219   cur->old = o_old;
 220
 221   if (!msg)
 222   {
 223     mutt_error(_("Can't append to folder: %s"), strerror(errno));
 224     mx_mbox_close(&tmpctx);
 225     goto bail;
 226   }
 227
 228   rc = mutt_copy_hdr(fp, msg->fp, 0, sb.st_size, CH_NOLEN | cf, NULL);
 229   if (rc == 0)
 230   {
 231     fputc('\n', msg->fp);
 232     mutt_file_copy_stream(fp, msg->fp);
 233   }
 234
 235   rc = mx_msg_commit(tmpctx->mailbox, msg);
 236   mx_msg_close(tmpctx->mailbox, &msg);
 237
 238   mx_mbox_close(&tmpctx);
 239
 240 bail:
 241   mutt_file_fclose(&fp);
 242
 243   if (rc >= 0)
 244     unlink(tmp);
 245
 246   if (rc == 0)
 247   {
 248     mutt_set_flag(Context->mailbox, cur, MUTT_DELETE, 1);
 249     mutt_set_flag(Context->mailbox, cur, MUTT_PURGE, 1);
 250     mutt_set_flag(Context->mailbox, cur, MUTT_READ, 1);
 251
 252     if (DeleteUntag)
 253       mutt_set_flag(Context->mailbox, cur, MUTT_TAG, 0);
 254   }
 255   else if (rc == -1)
 256     mutt_message(_("Error. Preserving temporary file: %s"), tmp);
 257
 258   return rc;
 259 }
 260
 261 /**
 262  * edit_or_view_message - Edit an email or view it in an external editor
 263  * @param edit true: Edit the email; false: view the email
 264  * @param ctx  Mailbox Context
 265  * @param e   Email
 266  * @retval 1  Message not modified
 267  * @retval 0  Message edited successfully
 268  * @retval -1 Error
 269  */
 270 int edit_or_view_message(bool edit, struct Context *ctx, struct Email *e)
 271 {
 272   if (e)
 273     return edit_or_view_one_message(edit, ctx->mailbox, e);
 274
 275   for (int i = 0; i < ctx->mailbox->msg_count; i++)
 276   {
 277     if (!message_is_tagged(ctx, i))
 278       continue;
 279
 280     if (edit_or_view_one_message(edit, ctx->mailbox, ctx->mailbox->emails[i]) == -1)
 281       return -1;
 282   }
 283
 284   return 0;
 285 }
 286
 287 /**
 288  * mutt_edit_message - Edit a message
 289  * @param ctx Mailbox Context
 290  * @param e Email
 291  * @retval 1  Message not modified
 292  * @retval 0  Message edited successfully
 293  * @retval -1 Error
 294  */
 295 int mutt_edit_message(struct Context *ctx, struct Email *e)
 296 {
 297   return edit_or_view_message(true, ctx, e); /* true means edit */
 298 }
 299
 300 /**
 301  * mutt_view_message - Edit a message
 302  * @param ctx Mailbox Context
 303  * @param e Email
 304  * @retval 1  Message not modified
 305  * @retval 0  Message edited successfully
 306  * @retval -1 Error
 307  */
 308 int mutt_view_message(struct Context *ctx, struct Email *e)
 309 {
 310   return edit_or_view_message(false, ctx, e); /* false means only view */
 311 }