mutt: add a version with courier-compatible sidebar & sendbar patches.

1 files changed, 433 insertions, 0 deletions

diff --git a/mail-client/mutt/files/1.5.21-write_postponed.patch b/mail-client/mutt/files/1.5.21-write_postponed.patch
new file mode 100644
index 0000000..44dc99e
--- /dev/null
+++ b/mail-client/mutt/files/1.5.21-write_postponed.patch
@@ -0,0 +1,433 @@
+diff -urN mutt-1.5.21.orig//compose.c mutt-1.5.21//compose.c
+--- mutt-1.5.21.orig//compose.c	2011-06-26 20:17:58.671443063 -0500
++++ mutt-1.5.21//compose.c	2011-06-26 20:16:57.061738838 -0500
+@@ -1370,7 +1370,7 @@
+          if (msg->content->next)
+            msg->content = mutt_make_multipart (msg->content);
+ 
+-         if (mutt_write_fcc (fname, msg, NULL, 0, NULL) < 0)
++         if (mutt_write_fcc (fname, msg) < 0)
+            msg->content = mutt_remove_multipart (msg->content);
+          else
+            mutt_message _("Message written.");
+diff -urN mutt-1.5.21.orig//protos.h mutt-1.5.21//protos.h
+--- mutt-1.5.21.orig//protos.h	2011-06-26 20:17:59.051441238 -0500
++++ mutt-1.5.21//protos.h	2011-06-26 20:16:57.071738790 -0500
+@@ -367,7 +367,8 @@
+ void mutt_update_num_postponed (void);
+ int mutt_wait_filter (pid_t);
+ int mutt_which_case (const char *);
+-int mutt_write_fcc (const char *path, HEADER *hdr, const char *msgid, int, char *);
++int mutt_write_fcc (const char *path, HEADER *hdr);
++int mutt_write_postponed (const char *path, HEADER *hdr, const char *msgid, char *fcc);
+ int mutt_write_mime_body (BODY *, FILE *);
+ int mutt_write_mime_header (BODY *, FILE *);
+ int mutt_write_one_header (FILE *fp, const char *tag, const char *value, const char *pfx, int wraplen, int flags);
+diff -urN mutt-1.5.21.orig//send.c mutt-1.5.21//send.c
+--- mutt-1.5.21.orig//send.c	2011-06-26 20:17:59.051441238 -0500
++++ mutt-1.5.21//send.c	2011-06-26 20:16:57.071738790 -0500
+@@ -1684,7 +1684,7 @@
+       mutt_prepare_envelope (msg->env, 0);
+       mutt_env_to_idna (msg->env, NULL, NULL);	/* Handle bad IDNAs the next time. */
+ 
+-      if (!Postponed || mutt_write_fcc (NONULL (Postponed), msg, (cur && (flags & SENDREPLY)) ? cur->env->message_id : NULL, 1, fcc) < 0)
++      if (!Postponed || mutt_write_postponed (NONULL (Postponed), msg, (cur && (flags & SENDREPLY)) ? cur->env->message_id : NULL, fcc) < 0)
+       {
+ 	msg->content = mutt_remove_multipart (msg->content);
+ 	decode_descriptions (msg->content);
+@@ -1882,7 +1882,7 @@
+        * message was first postponed.
+        */
+       msg->received = time (NULL);
+-      if (mutt_write_fcc (fcc, msg, NULL, 0, NULL) == -1)
++      if (mutt_write_fcc (fcc, msg) == -1)
+       {
+ 	/*
+ 	 * Error writing FCC, we should abort sending.
+diff -urN mutt-1.5.21.orig//sendlib.c mutt-1.5.21//sendlib.c
+--- mutt-1.5.21.orig//sendlib.c	2011-06-26 20:17:59.051441238 -0500
++++ mutt-1.5.21//sendlib.c	2011-06-26 20:17:17.151642453 -0500
+@@ -2575,6 +2575,165 @@
+   rfc2047_decode (&env->x_label);
+ }
+ 
++static int count_length_lines (FILE *fp, LOFF_T *content_lengthp, int *linesp)
++{
++  char sasha[LONG_STRING];
++  int lines = 0;
++
++  /* count the number of lines */
++  while (fgets (sasha, sizeof (sasha), fp) != NULL)
++    lines++;
++  if (ferror (fp))
++    return -1;
++
++  *linesp = lines;
++  *content_lengthp = (LOFF_T) ftello (fp);
++
++  return 0;
++}
++
++/* state maintained between mutt_start_message and
++ * mutt_finish_message, opaque to callers.
++ */
++struct mutt_message_handle
++{
++  FILE *tempfp;
++  char tempfile[_POSIX_PATH_MAX];
++  LOFF_T content_length;
++  int lines;
++  struct stat st;
++  int passthru;
++};
++
++static struct mutt_message_handle *
++mutt_start_message (const char *path, HEADER *hdr, 
++                    CONTEXT *ctxp, MESSAGE **msgp, int passthru)
++{
++  struct mutt_message_handle *mh;
++
++  if (mx_open_mailbox (path, M_APPEND | M_QUIET, ctxp) == NULL)
++  {
++    dprint (1, (debugfile, "mutt_start_message: unable to open mailbox %s"
++                "in append-mode, aborting.\n", path));
++    return NULL;
++  }
++
++  mh = safe_calloc (1, sizeof (*mh));
++  mh->passthru = passthru;
++
++  if (ctxp->magic == M_MMDF || ctxp->magic == M_MBOX)
++  {
++    /* remember new mail status before appending message */
++    stat (path, &mh->st);
++
++    if (!passthru) {
++      /* need to add a Content-Length field to avoid problems
++       * where a line in the message body begins with "From "
++       */
++      mutt_mktemp (mh->tempfile, sizeof (mh->tempfile));
++      mh->tempfp = safe_fopen (mh->tempfile, "w+");
++      if (!mh->tempfp)
++      {
++        mutt_perror (mh->tempfile);
++        dprint (1, (debugfile, "mutt_start_message: failed "
++                    "to open tempfile, aborting.\n"));
++        goto error_out;
++      }
++
++      mutt_write_mime_body (hdr->content, mh->tempfp);
++
++      /* make sure the last line ends with a newline.  Emacs doesn't ensure
++       * this will happen, and it can cause problems parsing the mailbox   
++       * later.
++       */
++      fseek (mh->tempfp, -1, 2);
++      if (fgetc (mh->tempfp) != '\n')
++      {
++        fseek (mh->tempfp, 0, 2);
++        fputc ('\n', mh->tempfp);
++      }
++      if (fflush (mh->tempfp) || ferror (mh->tempfp))
++      {
++        dprint (1, (debugfile, "mutt_start_message: failed "
++                    "to write tempfile, aborting.\n"));
++        goto error_out;
++      }
++
++      rewind (mh->tempfp);
++
++      if (count_length_lines (mh->tempfp, &mh->content_length, &mh->lines))
++      {
++        mutt_perror (mh->tempfile);
++        dprint (1, (debugfile, "mutt_start_message: failed "
++                    "to count message length, aborting.\n"));
++        goto error_out;
++      }
++    }
++  }
++
++  if ((*msgp = mx_open_new_message (ctxp, hdr, M_ADD_FROM)) == NULL)
++  {
++    dprint (1, (debugfile, "mutt_start_message: mx_open_new_message "
++                "failed in %s, aborting.\n", path));
++    goto error_out;
++  }
++  return mh;
++
++error_out:
++  /* error message already provided, just clean up */
++  if (mh->tempfp)
++  {
++    safe_fclose (&mh->tempfp);
++    unlink (mh->tempfile);
++  }
++  FREE (&mh);
++  mx_close_mailbox (ctxp, NULL);
++  return NULL;
++}
++
++static int mutt_finish_message (struct mutt_message_handle *mh,
++                                const char *path, HEADER *hdr,
++                                CONTEXT *ctxp, MESSAGE **msgp, int skip_buffy)
++{
++  int ret = 0;
++
++  if (mh->tempfp)
++  {
++    fprintf ((*msgp)->fp, "Content-Length: " OFF_T_FMT "\n", mh->content_length);
++    fprintf ((*msgp)->fp, "Lines: %d\n\n", mh->lines); /* NOTE double newline */
++
++    /* copy the body */
++    rewind (mh->tempfp);
++    ret = mutt_copy_stream (mh->tempfp, (*msgp)->fp);
++    if (safe_fclose (&mh->tempfp))
++      ret = -1;
++
++    /* if there was an error, leave the temp version */
++    if (!ret)
++      unlink (mh->tempfile);
++  }
++  else
++  {
++    if (!mh->passthru)
++    {
++      fputc ('\n', (*msgp)->fp); /* finish off the header */
++      ret = mutt_write_mime_body (hdr->content, (*msgp)->fp);
++    }
++    skip_buffy = 1; /* only needed for file-based mailboxes */
++  }
++
++  ret |= mx_commit_message (*msgp, ctxp);
++  mx_close_message (msgp);
++  mx_close_mailbox (ctxp, NULL);
++
++  if (!skip_buffy)
++    mutt_buffy_cleanup (path, &mh->st);
++
++  FREE (&mh);
++
++  return ret;
++}
++
+ static int _mutt_bounce_message (FILE *fp, HEADER *h, ADDRESS *to, const char *resent_from,
+ 				  ADDRESS *env_from)
+ {
+@@ -2740,81 +2899,60 @@
+   }
+ }
+ 
+-int mutt_write_fcc (const char *path, HEADER *hdr, const char *msgid, int post, char *fcc)
++int mutt_write_fcc (const char *path, HEADER *hdr)
+ {
++  struct mutt_message_handle *mh;
+   CONTEXT f;
+   MESSAGE *msg;
+-  char tempfile[_POSIX_PATH_MAX];
+-  FILE *tempfp = NULL;
+-  int r, need_buffy_cleanup = 0;
+-  struct stat st;
+-  char buf[SHORT_STRING];
+ 
+-  if (post)
+-    set_noconv_flags (hdr->content, 1);
++  hdr->read = 1; /* make sure to put it in the `cur' directory (maildir) */
+ 
+-  if (mx_open_mailbox (path, M_APPEND | M_QUIET, &f) == NULL)
+-  {
+-    dprint (1, (debugfile, "mutt_write_fcc(): unable to open mailbox %s in append-mode, aborting.\n",
+-		path));
+-    return (-1);
+-  }
++  mh = mutt_start_message (path, hdr, &f, &msg, 0);
++  if (!mh)
++    return -1;
+ 
+-  /* We need to add a Content-Length field to avoid problems where a line in
+-   * the message body begins with "From "
+-   */
+-  if (f.magic == M_MMDF || f.magic == M_MBOX)
+-  {
+-    mutt_mktemp (tempfile, sizeof (tempfile));
+-    if ((tempfp = safe_fopen (tempfile, "w+")) == NULL)
+-    {
+-      mutt_perror (tempfile);
+-      mx_close_mailbox (&f, NULL);
+-      return (-1);
+-    }
+-    /* remember new mail status before appending message */
+-    need_buffy_cleanup = 1;
+-    stat (path, &st);
+-  }
++  mutt_write_rfc822_header (msg->fp, hdr->env, hdr->content, 0, 0, 1);
++  fprintf (msg->fp, "Status: RO\n");
++
++  return mutt_finish_message (mh, path, hdr, &f, &msg, 0);
++}
++
++int mutt_write_postponed (const char *path, HEADER *hdr, const char *msgid, char *fcc)
++{
++  struct mutt_message_handle *mh;
++  CONTEXT f;
++  MESSAGE *msg;
++  int ret;
++
++  hdr->read = 0; /* make sure to put it in the `new' directory (maildir) */
++  set_noconv_flags (hdr->content, 1);
+ 
+-  hdr->read = !post; /* make sure to put it in the `cur' directory (maildir) */
+-  if ((msg = mx_open_new_message (&f, hdr, M_ADD_FROM)) == NULL)
++  mh = mutt_start_message (path, hdr, &f, &msg, 0);
++  if (!mh)
+   {
+-    mx_close_mailbox (&f, NULL);
+-    return (-1);
++    set_noconv_flags (hdr->content, 0);
++    return -1;
+   }
+ 
+-  /* post == 1 => postpone message. Set mode = -1 in mutt_write_rfc822_header()
+-   * post == 0 => Normal mode. Set mode = 0 in mutt_write_rfc822_header()
+-   * */
+-  mutt_write_rfc822_header (msg->fp, hdr->env, hdr->content, post ? -post : 0, 0, 1);
++  mutt_write_rfc822_header (msg->fp, hdr->env, hdr->content, -1, 0, 1);
+ 
+-  /* (postponment) if this was a reply of some sort, <msgid> contians the
++  /* if this was a reply of some sort, <msgid> contains the
+    * Message-ID: of message replied to.  Save it using a special X-Mutt-
+    * header so it can be picked up if the message is recalled at a later
+    * point in time.  This will allow the message to be marked as replied if
+    * the same mailbox is still open.
+    */
+-  if (post && msgid)
++  if (msgid)
+     fprintf (msg->fp, "X-Mutt-References: %s\n", msgid);
+ 
+-  /* (postponment) save the Fcc: using a special X-Mutt- header so that
++  /* save the Fcc: using a special X-Mutt- header so that
+    * it can be picked up when the message is recalled
+    */
+-  if (post && fcc)
++  if (fcc)
+     fprintf (msg->fp, "X-Mutt-Fcc: %s\n", fcc);
+ 
+-  if (f.magic == M_MMDF || f.magic == M_MBOX)
+-    fprintf (msg->fp, "Status: RO\n");
+-
+-  /* mutt_write_rfc822_header() only writes out a Date: header with
+-   * mode == 0, i.e. _not_ postponment; so write out one ourself */
+-  if (post)
+-    fprintf (msg->fp, "%s", mutt_make_date (buf, sizeof (buf)));
+-
+-  /* (postponment) if the mail is to be signed or encrypted, save this info */
+-  if ((WithCrypto & APPLICATION_PGP)
+-      && post && (hdr->security & APPLICATION_PGP))
++  /* if the mail is to be signed or encrypted, save this info */
++  if ((WithCrypto & APPLICATION_PGP) && (hdr->security & APPLICATION_PGP))
+   {
+     fputs ("X-Mutt-PGP: ", msg->fp);
+     if (hdr->security & ENCRYPT)
+@@ -2830,9 +2968,8 @@
+     fputc ('\n', msg->fp);
+   }
+ 
+-  /* (postponment) if the mail is to be signed or encrypted, save this info */
+-  if ((WithCrypto & APPLICATION_SMIME)
+-      && post && (hdr->security & APPLICATION_SMIME))
++  /* if the mail is to be signed or encrypted, save this info */
++  if ((WithCrypto & APPLICATION_SMIME) && (hdr->security & APPLICATION_SMIME))
+   {
+     fputs ("X-Mutt-SMIME: ", msg->fp);
+     if (hdr->security & ENCRYPT) {
+@@ -2851,86 +2988,22 @@
+   }
+ 
+ #ifdef MIXMASTER
+-  /* (postponement) if the mail is to be sent through a mixmaster
++  /* if the mail is to be sent through a mixmaster
+    * chain, save that information
+    */
+-
+-  if (post && hdr->chain && hdr->chain)
++  if (hdr->chain)
+   {
+     LIST *p;
+-
+     fputs ("X-Mutt-Mix:", msg->fp);
+     for (p = hdr->chain; p; p = p->next)
+       fprintf (msg->fp, " %s", (char *) p->data);
+-
+     fputc ('\n', msg->fp);
+   }
+ #endif
+ 
+-  if (tempfp)
+-  {
+-    char sasha[LONG_STRING];
+-    int lines = 0;
+-
+-    mutt_write_mime_body (hdr->content, tempfp);
+-
+-    /* make sure the last line ends with a newline.  Emacs doesn't ensure
+-     * this will happen, and it can cause problems parsing the mailbox
+-     * later.
+-     */
+-    fseek (tempfp, -1, 2);
+-    if (fgetc (tempfp) != '\n')
+-    {
+-      fseek (tempfp, 0, 2);
+-      fputc ('\n', tempfp);
+-    }
+-
+-    fflush (tempfp);
+-    if (ferror (tempfp))
+-    {
+-      dprint (1, (debugfile, "mutt_write_fcc(): %s: write failed.\n", tempfile));
+-      safe_fclose (&tempfp);
+-      unlink (tempfile);
+-      mx_commit_message (msg, &f);	/* XXX - really? */
+-      mx_close_message (&msg);
+-      mx_close_mailbox (&f, NULL);
+-      return -1;
+-    }
+-
+-    /* count the number of lines */
+-    rewind (tempfp);
+-    while (fgets (sasha, sizeof (sasha), tempfp) != NULL)
+-      lines++;
+-    fprintf (msg->fp, "Content-Length: " OFF_T_FMT "\n", (LOFF_T) ftello (tempfp));
+-    fprintf (msg->fp, "Lines: %d\n\n", lines);
+-
+-    /* copy the body and clean up */
+-    rewind (tempfp);
+-    r = mutt_copy_stream (tempfp, msg->fp);
+-    if (fclose (tempfp) != 0)
+-      r = -1;
+-    /* if there was an error, leave the temp version */
+-    if (!r)
+-      unlink (tempfile);
+-  }
+-  else
+-  {
+-    fputc ('\n', msg->fp); /* finish off the header */
+-    r = mutt_write_mime_body (hdr->content, msg->fp);
+-  }
+-
+-  if (mx_commit_message (msg, &f) != 0)
+-    r = -1;
+-  mx_close_message (&msg);
+-  mx_close_mailbox (&f, NULL);
+-
+-  if (!post && need_buffy_cleanup)
+-    mutt_buffy_cleanup (path, &st);
+-
+-  if (post)
+-    set_noconv_flags (hdr->content, 0);
+-
+-  return r;
++  ret = mutt_finish_message (mh, path, hdr, &f, &msg, 0);
++  set_noconv_flags (hdr->content, 0);
++  return ret;
+ }
+ 
+ #ifdef USE_SENDBOX