Issue #1258 - Part 1: Import mailnews, ldap, and mork from comm-esr52.9.1

1 files changed, 2084 insertions, 0 deletions

diff --git a/mailnews/mime/src/mimedrft.cpp b/mailnews/mime/src/mimedrft.cpp
new file mode 100644
index 000000000..3293d8b96
--- /dev/null
+++ b/mailnews/mime/src/mimedrft.cpp
@@ -0,0 +1,2084 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * This Original Code has been modified by IBM Corporation. Modifications made by IBM
+ * described herein are Copyright (c) International Business Machines Corporation, 2000.
+ * Modifications to Mozilla code or documentation identified per MPL Section 3.3
+ *
+ * Date             Modified by     Description of modification
+ * 04/20/2000       IBM Corp.      OS/2 VisualAge build.
+ */
+#include "nsCOMPtr.h"
+#include "modmimee.h"
+#include "mimeobj.h"
+#include "modlmime.h"
+#include "mimei.h"
+#include "mimebuf.h"
+#include "mimemoz2.h"
+#include "mimemsg.h"
+#include "nsMimeTypes.h"
+#include <ctype.h>
+
+#include "prmem.h"
+#include "plstr.h"
+#include "prprf.h"
+#include "prio.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "msgCore.h"
+#include "nsIMsgSend.h"
+#include "nsMimeStringResources.h"
+#include "nsIIOService.h"
+#include "nsNetUtil.h"
+#include "comi18n.h"
+#include "nsIMsgAttachment.h"
+#include "nsIMsgCompFields.h"
+#include "nsMsgCompCID.h"
+#include "nsIMsgComposeService.h"
+#include "nsMsgAttachmentData.h"
+#include "nsMsgI18N.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsIMsgMessageService.h"
+#include "nsMsgUtils.h"
+#include "nsCExternalHandlerService.h"
+#include "nsIMIMEService.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMimeConverter.h" // for MimeConverterOutputCallback
+#include "mozilla/mailnews/MimeHeaderParser.h"
+
+using namespace mozilla::mailnews;
+
+//
+// Header strings...
+//
+#define HEADER_NNTP_POSTING_HOST      "NNTP-Posting-Host"
+#define MIME_HEADER_TABLE             "<TABLE CELLPADDING=0 CELLSPACING=0 BORDER=0 class=\"moz-email-headers-table\">"
+#define HEADER_START_JUNK             "<TR><TH VALIGN=BASELINE ALIGN=RIGHT NOWRAP>"
+#define HEADER_MIDDLE_JUNK            ": </TH><TD>"
+#define HEADER_END_JUNK               "</TD></TR>"
+
+//
+// Forward declarations...
+//
+extern "C" char     *MIME_StripContinuations(char *original);
+int                 mime_decompose_file_init_fn ( void *stream_closure, MimeHeaders *headers );
+int                 mime_decompose_file_output_fn ( const char *buf, int32_t size, void *stream_closure );
+int                 mime_decompose_file_close_fn ( void *stream_closure );
+extern int          MimeHeaders_build_heads_list(MimeHeaders *hdrs);
+
+// CID's
+static NS_DEFINE_CID(kCMsgComposeServiceCID,  NS_MSGCOMPOSESERVICE_CID);
+
+mime_draft_data::mime_draft_data() : url_name(nullptr), format_out(0),
+  stream(nullptr), obj(nullptr), options(nullptr), headers(nullptr),
+  messageBody(nullptr), curAttachment(nullptr),
+  decoder_data(nullptr), mailcharset(nullptr), forwardInline(false),
+  forwardInlineFilter(false), overrideComposeFormat(false),
+  originalMsgURI(nullptr)
+{
+}
+////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////
+// THIS SHOULD ALL MOVE TO ANOTHER FILE AFTER LANDING!
+////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////
+
+// safe filename for all OSes
+#define SAFE_TMP_FILENAME "nsmime.tmp"
+
+//
+// Create a file for the a unique temp file
+// on the local machine. Caller must free memory
+//
+nsresult
+nsMsgCreateTempFile(const char *tFileName, nsIFile **tFile)
+{
+  if ((!tFileName) || (!*tFileName))
+    tFileName = SAFE_TMP_FILENAME;
+
+  nsresult rv = GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR,
+                                                tFileName,
+                                                tFile);
+
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = (*tFile)->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
+  if (NS_FAILED(rv))
+    NS_RELEASE(*tFile);
+
+  return rv;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////
+// END OF - THIS SHOULD ALL MOVE TO ANOTHER FILE AFTER LANDING!
+////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////
+
+typedef enum {
+  nsMsg_RETURN_RECEIPT_BOOL_HEADER_MASK = 0,
+  nsMsg_ENCRYPTED_BOOL_HEADER_MASK,
+  nsMsg_SIGNED_BOOL_HEADER_MASK,
+  nsMsg_UUENCODE_BINARY_BOOL_HEADER_MASK,
+  nsMsg_ATTACH_VCARD_BOOL_HEADER_MASK,
+  nsMsg_LAST_BOOL_HEADER_MASK     // last boolean header mask; must be the last one
+                                  // DON'T remove.
+} nsMsgBoolHeaderSet;
+
+#ifdef NS_DEBUG
+extern "C" void
+mime_dump_attachments ( nsMsgAttachmentData *attachData )
+{
+  int32_t     i = 0;
+  class nsMsgAttachmentData  *tmp = attachData;
+
+  while ( (tmp) && (tmp->m_url) )
+  {
+    printf("Real Name         : %s\n", tmp->m_realName.get());
+
+    if ( tmp->m_url )
+    {
+      ;
+      printf("URL               : %s\n", tmp->m_url->GetSpecOrDefault().get());
+    }
+
+    printf("Desired Type      : %s\n", tmp->m_desiredType.get());
+    printf("Real Type         : %s\n", tmp->m_realType.get());
+    printf("Real Encoding     : %s\n", tmp->m_realEncoding.get());
+    printf("Description       : %s\n", tmp->m_description.get());
+    printf("Mac Type          : %s\n", tmp->m_xMacType.get());
+    printf("Mac Creator       : %s\n", tmp->m_xMacCreator.get());
+    printf("Size in bytes     : %d\n", tmp->m_size);
+    i++;
+    tmp++;
+  }
+}
+#endif
+
+nsresult CreateComposeParams(nsCOMPtr<nsIMsgComposeParams> &pMsgComposeParams,
+                             nsIMsgCompFields * compFields,
+                             nsMsgAttachmentData *attachmentList,
+                             MSG_ComposeType composeType,
+                             MSG_ComposeFormat composeFormat,
+                             nsIMsgIdentity * identity,
+                             const char *originalMsgURI,
+                             nsIMsgDBHdr *origMsgHdr)
+{
+#ifdef NS_DEBUG
+  mime_dump_attachments ( attachmentList );
+#endif
+
+  nsresult rv;
+  nsMsgAttachmentData *curAttachment = attachmentList;
+  if (curAttachment)
+  {
+    nsAutoCString spec;
+
+    while (curAttachment && curAttachment->m_url)
+    {
+      rv = curAttachment->m_url->GetSpec(spec);
+      if (NS_SUCCEEDED(rv))
+      {
+        nsCOMPtr<nsIMsgAttachment> attachment = do_CreateInstance(NS_MSGATTACHMENT_CONTRACTID, &rv);
+        if (NS_SUCCEEDED(rv) && attachment)
+        {
+          nsAutoString nameStr;
+          rv = ConvertToUnicode("UTF-8", curAttachment->m_realName.get(), nameStr);
+          if (NS_FAILED(rv))
+            CopyASCIItoUTF16(curAttachment->m_realName, nameStr);
+          attachment->SetName(nameStr);
+          attachment->SetUrl(spec);
+          attachment->SetTemporary(true);
+          attachment->SetContentType(curAttachment->m_realType.get());
+          attachment->SetMacType(curAttachment->m_xMacType.get());
+          attachment->SetMacCreator(curAttachment->m_xMacCreator.get());
+          attachment->SetSize(curAttachment->m_size);
+          if (!curAttachment->m_cloudPartInfo.IsEmpty())
+          {
+            nsCString provider;
+            nsCString cloudUrl;
+            attachment->SetSendViaCloud(true);
+            provider.Adopt(
+              MimeHeaders_get_parameter(curAttachment->m_cloudPartInfo.get(),
+                                        "provider", nullptr, nullptr));
+            cloudUrl.Adopt(
+              MimeHeaders_get_parameter(curAttachment->m_cloudPartInfo.get(),
+                                        "url", nullptr, nullptr));
+            attachment->SetCloudProviderKey(provider);
+            attachment->SetContentLocation(cloudUrl);
+          }
+          compFields->AddAttachment(attachment);
+        }
+      }
+      curAttachment++;
+    }
+  }
+
+  MSG_ComposeFormat format = composeFormat; // Format to actually use.
+  if (identity && composeType == nsIMsgCompType::ForwardInline)
+  {
+    bool composeHtml = false;
+    identity->GetComposeHtml(&composeHtml);
+    if (composeHtml)
+      format = (composeFormat == nsIMsgCompFormat::OppositeOfDefault) ?
+                 nsIMsgCompFormat::PlainText : nsIMsgCompFormat::HTML;
+    else
+      format = (composeFormat == nsIMsgCompFormat::OppositeOfDefault) ?
+                 nsIMsgCompFormat::HTML : nsIMsgCompFormat::PlainText;
+  }
+
+  pMsgComposeParams = do_CreateInstance(NS_MSGCOMPOSEPARAMS_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  pMsgComposeParams->SetType(composeType);
+  pMsgComposeParams->SetFormat(format);
+  pMsgComposeParams->SetIdentity(identity);
+  pMsgComposeParams->SetComposeFields(compFields);
+  if (originalMsgURI)
+    pMsgComposeParams->SetOriginalMsgURI(originalMsgURI);
+  if (origMsgHdr)
+    pMsgComposeParams->SetOrigMsgHdr(origMsgHdr);
+  return NS_OK;
+}
+
+nsresult
+CreateTheComposeWindow(nsIMsgCompFields *   compFields,
+                       nsMsgAttachmentData *attachmentList,
+                       MSG_ComposeType      composeType,
+                       MSG_ComposeFormat    composeFormat,
+                       nsIMsgIdentity *     identity,
+                       const char *         originalMsgURI,
+                       nsIMsgDBHdr *        origMsgHdr
+                       )
+{
+  nsCOMPtr<nsIMsgComposeParams> pMsgComposeParams;
+  nsresult rv = CreateComposeParams(pMsgComposeParams, compFields,
+                       attachmentList,
+                       composeType,
+                       composeFormat,
+                       identity,
+                       originalMsgURI,
+                       origMsgHdr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgComposeService> msgComposeService =
+           do_GetService(kCMsgComposeServiceCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return msgComposeService->OpenComposeWindowWithParams(nullptr /* default chrome */, pMsgComposeParams);
+}
+
+nsresult
+ForwardMsgInline(nsIMsgCompFields *compFields,
+                 nsMsgAttachmentData *attachmentList,
+                 MSG_ComposeFormat composeFormat,
+                 nsIMsgIdentity *identity,
+                 const char *originalMsgURI,
+                 nsIMsgDBHdr *origMsgHdr)
+{
+  nsCOMPtr<nsIMsgComposeParams> pMsgComposeParams;
+  nsresult rv = CreateComposeParams(pMsgComposeParams, compFields,
+                                    attachmentList,
+                                    nsIMsgCompType::ForwardInline,
+                                    composeFormat,
+                                    identity,
+                                    originalMsgURI,
+                                    origMsgHdr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgComposeService> msgComposeService =
+           do_GetService(kCMsgComposeServiceCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // create the nsIMsgCompose object to send the object
+  nsCOMPtr<nsIMsgCompose> pMsgCompose (do_CreateInstance(NS_MSGCOMPOSE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  /** initialize nsIMsgCompose, Send the message, wait for send completion response **/
+  rv = pMsgCompose->Initialize(pMsgComposeParams, nullptr, nullptr);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = pMsgCompose->SendMsg(nsIMsgSend::nsMsgDeliverNow, identity, nullptr, nullptr, nullptr);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIMsgFolder> origFolder;
+    origMsgHdr->GetFolder(getter_AddRefs(origFolder));
+    if (origFolder)
+      origFolder->AddMessageDispositionState(
+                  origMsgHdr, nsIMsgFolder::nsMsgDispositionState_Forwarded);
+  }
+  return rv;
+}
+
+nsresult
+CreateCompositionFields(const char        *from,
+                        const char        *reply_to,
+                        const char        *to,
+                        const char        *cc,
+                        const char        *bcc,
+                        const char        *fcc,
+                        const char        *newsgroups,
+                        const char        *followup_to,
+                        const char        *organization,
+                        const char        *subject,
+                        const char        *references,
+                        const char        *priority,
+                        const char        *newspost_url,
+                        char              *charset,
+                        nsIMsgCompFields  **_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  nsresult rv;
+  *_retval = nullptr;
+
+  nsCOMPtr<nsIMsgCompFields> cFields = do_CreateInstance(NS_MSGCOMPFIELDS_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(cFields, NS_ERROR_OUT_OF_MEMORY);
+
+  // Now set all of the passed in stuff...
+  cFields->SetCharacterSet(!PL_strcasecmp("us-ascii", charset) ? "ISO-8859-1" : charset);
+
+  nsAutoCString val;
+  nsAutoString outString;
+
+  if (from) {
+    ConvertRawBytesToUTF16(from, charset, outString);
+    cFields->SetFrom(outString);
+  }
+
+  if (subject) {
+    MIME_DecodeMimeHeader(subject, charset, false, true, val);
+    cFields->SetSubject(NS_ConvertUTF8toUTF16(!val.IsEmpty() ? val.get() : subject));
+  }
+
+  if (reply_to) {
+    ConvertRawBytesToUTF16(reply_to, charset, outString);
+    cFields->SetReplyTo(outString);
+  }
+
+  if (to) {
+    ConvertRawBytesToUTF16(to, charset, outString);
+    cFields->SetTo(outString);
+  }
+
+  if (cc) {
+    ConvertRawBytesToUTF16(cc, charset, outString);
+    cFields->SetCc(outString);
+  }
+
+  if (bcc) {
+    ConvertRawBytesToUTF16(bcc, charset, outString);
+    cFields->SetBcc(outString);
+  }
+
+  if (fcc) {
+    MIME_DecodeMimeHeader(fcc, charset, false, true, val);
+    cFields->SetFcc(NS_ConvertUTF8toUTF16(!val.IsEmpty() ? val.get() : fcc));
+  }
+
+  if (newsgroups) {
+    // fixme: the newsgroups header had better be decoded using the server-side
+    // character encoding,but this |charset| might be different from it.
+    MIME_DecodeMimeHeader(newsgroups, charset, false, true, val);
+    cFields->SetNewsgroups(NS_ConvertUTF8toUTF16(!val.IsEmpty() ? val.get() : newsgroups));
+  }
+
+  if (followup_to) {
+    MIME_DecodeMimeHeader(followup_to, charset, false, true, val);
+    cFields->SetFollowupTo(NS_ConvertUTF8toUTF16(!val.IsEmpty() ? val.get() : followup_to));
+  }
+
+  if (organization) {
+    MIME_DecodeMimeHeader(organization, charset, false, true, val);
+    cFields->SetOrganization(NS_ConvertUTF8toUTF16(!val.IsEmpty() ? val.get() : organization));
+  }
+
+  if (references) {
+    MIME_DecodeMimeHeader(references, charset, false, true, val);
+    cFields->SetReferences(!val.IsEmpty() ? val.get() : references);
+  }
+
+  if (priority) {
+    MIME_DecodeMimeHeader(priority, charset, false, true, val);
+    nsMsgPriorityValue priorityValue;
+    NS_MsgGetPriorityFromString(!val.IsEmpty() ? val.get() : priority, priorityValue);
+    nsAutoCString priorityName;
+    NS_MsgGetUntranslatedPriorityName(priorityValue, priorityName);
+    cFields->SetPriority(priorityName.get());
+  }
+
+  if (newspost_url) {
+    MIME_DecodeMimeHeader(newspost_url, charset, false, true, val);
+    cFields->SetNewspostUrl(!val.IsEmpty() ? val.get() : newspost_url);
+  }
+
+  *_retval = cFields;
+  NS_IF_ADDREF(*_retval);
+
+  return rv;
+}
+
+static int
+dummy_file_write( char *buf, int32_t size, void *fileHandle )
+{
+  if (!fileHandle)
+    return -1;
+
+  nsIOutputStream  *tStream = (nsIOutputStream *) fileHandle;
+  uint32_t bytesWritten;
+  tStream->Write(buf, size, &bytesWritten);
+  return (int) bytesWritten;
+}
+
+static int
+mime_parse_stream_write ( nsMIMESession *stream, const char *buf, int32_t size )
+{
+  mime_draft_data *mdd = (mime_draft_data *) stream->data_object;
+  NS_ASSERTION ( mdd, "null mime draft data!" );
+
+  if ( !mdd || !mdd->obj )
+    return -1;
+
+  return mdd->obj->clazz->parse_buffer ((char *) buf, size, mdd->obj);
+}
+
+static void
+mime_free_attachments(nsTArray<nsMsgAttachedFile *> &attachments)
+{
+  if (attachments.Length() <= 0)
+    return;
+
+  for (uint32_t i = 0; i < attachments.Length(); i++)
+  {
+    if (attachments[i]->m_tmpFile)
+    {
+      attachments[i]->m_tmpFile->Remove(false);
+      attachments[i]->m_tmpFile = nullptr;
+    }
+    delete attachments[i];
+  }
+}
+
+static nsMsgAttachmentData *
+mime_draft_process_attachments(mime_draft_data *mdd)
+{
+  if (!mdd)
+    return nullptr;
+
+  nsMsgAttachmentData         *attachData = NULL, *tmp = NULL;
+  nsMsgAttachedFile           *tmpFile = NULL;
+
+  //It's possible we must treat the message body as attachment!
+  bool bodyAsAttachment = false;
+  if (mdd->messageBody &&
+      !mdd->messageBody->m_type.IsEmpty() &&
+      mdd->messageBody->m_type.Find("text/html", CaseInsensitiveCompare) == -1 &&
+      mdd->messageBody->m_type.Find("text/plain", CaseInsensitiveCompare) == -1 &&
+      !mdd->messageBody->m_type.LowerCaseEqualsLiteral("text"))
+     bodyAsAttachment = true;
+
+  if (!mdd->attachments.Length() && !bodyAsAttachment)
+    return nullptr;
+
+  int32_t totalCount = mdd->attachments.Length();
+  if (bodyAsAttachment)
+    totalCount++;
+  attachData = new nsMsgAttachmentData[totalCount + 1];
+  if ( !attachData )
+    return nullptr;
+
+  tmp = attachData;
+
+  for (int i = 0, attachmentsIndex = 0; i < totalCount; i++, tmp++)
+  {
+    if (bodyAsAttachment && i == 0)
+      tmpFile = mdd->messageBody;
+    else
+      tmpFile = mdd->attachments[attachmentsIndex++];
+
+    if (tmpFile->m_type.LowerCaseEqualsLiteral("text/x-vcard"))
+      tmp->m_realName = tmpFile->m_description;
+
+    if ( tmpFile->m_origUrl )
+    {
+      nsAutoCString tmpSpec;
+      if (NS_FAILED(tmpFile->m_origUrl->GetSpec(tmpSpec)))
+        goto FAIL;
+
+      if (NS_FAILED(nsMimeNewURI(getter_AddRefs(tmp->m_url), tmpSpec.get(), nullptr)))
+        goto FAIL;
+
+      if (tmp->m_realName.IsEmpty())
+      {
+        if (!tmpFile->m_realName.IsEmpty())
+          tmp->m_realName = tmpFile->m_realName;
+        else {
+          if (tmpFile->m_type.Find(MESSAGE_RFC822, CaseInsensitiveCompare) != -1)
+            // we have the odd case of processing an e-mail that had an unnamed
+            // eml message attached
+            tmp->m_realName = "ForwardedMessage.eml";
+
+          else
+            tmp->m_realName = tmpSpec.get();
+        }
+      }
+    }
+
+    tmp->m_desiredType = tmpFile->m_type;
+    tmp->m_realType = tmpFile->m_type;
+    tmp->m_realEncoding = tmpFile->m_encoding;
+    tmp->m_description = tmpFile->m_description;
+    tmp->m_cloudPartInfo = tmpFile->m_cloudPartInfo;
+    tmp->m_xMacType = tmpFile->m_xMacType;
+    tmp->m_xMacCreator = tmpFile->m_xMacCreator;
+    tmp->m_size = tmpFile->m_size;
+  }
+  return attachData;
+
+FAIL:
+  delete [] attachData;
+  return nullptr;
+}
+
+static void
+mime_intl_insert_message_header_1(char        **body,
+                                  const char  *hdr_value,
+                                  const char  *hdr_str,
+                                  const char  *html_hdr_str,
+                                  const char  *mailcharset,
+                                  bool        htmlEdit)
+{
+  if (!body || !hdr_value || !hdr_str)
+    return;
+
+  if (htmlEdit)
+  {
+    NS_MsgSACat(body, HEADER_START_JUNK);
+  }
+  else
+  {
+    NS_MsgSACat(body, MSG_LINEBREAK);
+  }
+  if (!html_hdr_str)
+    html_hdr_str = hdr_str;
+  NS_MsgSACat(body, html_hdr_str);
+  if (htmlEdit)
+  {
+    NS_MsgSACat(body, HEADER_MIDDLE_JUNK);
+  }
+  else
+    NS_MsgSACat(body, ": ");
+
+    // MIME decode header
+    nsAutoCString utf8Value;
+    MIME_DecodeMimeHeader(hdr_value, mailcharset, false, true, utf8Value);
+    if (!utf8Value.IsEmpty()) {
+      char *escaped = nullptr;
+      if (htmlEdit)
+        escaped = MsgEscapeHTML(utf8Value.get());
+      NS_MsgSACat(body, escaped ? escaped : utf8Value.get());
+      NS_Free(escaped);
+    } else {
+        NS_MsgSACat(body, hdr_value); // raw MIME encoded string
+    }
+
+  if (htmlEdit)
+    NS_MsgSACat(body, HEADER_END_JUNK);
+}
+
+char *
+MimeGetNamedString(int32_t id)
+{
+  static char   retString[256];
+
+  retString[0] = '\0';
+  char *tString = MimeGetStringByID(id);
+  if (tString)
+  {
+    PL_strncpy(retString, tString, sizeof(retString));
+    PR_Free(tString);
+  }
+  return retString;
+}
+
+void
+MimeGetForwardHeaderDelimiter(nsACString &retString)
+{
+  nsCString defaultValue;
+  defaultValue.Adopt(MimeGetStringByID(MIME_FORWARDED_MESSAGE_HTML_USER_WROTE));
+
+  nsString tmpRetString;
+  NS_GetLocalizedUnicharPreferenceWithDefault(nullptr,
+    "mailnews.forward_header_originalmessage",
+    NS_ConvertUTF8toUTF16(defaultValue),
+    tmpRetString);
+
+  CopyUTF16toUTF8(tmpRetString, retString);
+}
+
+/* given an address string passed though parameter "address", this one will be converted
+   and returned through the same parameter. The original string will be destroyed
+*/
+static void UnquoteMimeAddress(nsACString &mimeHeader, const char *charset)
+{
+  if (!mimeHeader.IsEmpty())
+  {
+    nsTArray<nsCString> addresses;
+    ExtractDisplayAddresses(EncodedHeader(mimeHeader, charset),
+      UTF16ArrayAdapter<>(addresses));
+    mimeHeader.Truncate();
+
+    uint32_t count = addresses.Length();
+    for (uint32_t i = 0; i < count; i++)
+    {
+      if (i != 0)
+        mimeHeader.AppendASCII(", ");
+      mimeHeader += addresses[i];
+    }
+  }
+}
+
+static void
+mime_insert_all_headers(char            **body,
+                        MimeHeaders     *headers,
+                        MSG_ComposeFormat composeFormat,
+                        char            *mailcharset)
+{
+  bool htmlEdit = (composeFormat == nsIMsgCompFormat::HTML);
+  char *newBody = NULL;
+  char *html_tag = nullptr;
+  if (*body && PL_strncasecmp(*body, "<HTML", 5) == 0)
+    html_tag = PL_strchr(*body, '>') + 1;
+  int i;
+
+  if (!headers->done_p)
+  {
+    MimeHeaders_build_heads_list(headers);
+    headers->done_p = true;
+  }
+
+  nsCString replyHeader;
+  MimeGetForwardHeaderDelimiter(replyHeader);
+  if (htmlEdit)
+  {
+    NS_MsgSACopy(&(newBody), MIME_FORWARD_HTML_PREFIX);
+    NS_MsgSACat(&newBody, replyHeader.get());
+    NS_MsgSACat(&newBody, MIME_HEADER_TABLE);
+  }
+  else
+  {
+    NS_MsgSACopy(&(newBody), MSG_LINEBREAK MSG_LINEBREAK);
+    NS_MsgSACat(&newBody, replyHeader.get());
+  }
+
+  for (i = 0; i < headers->heads_size; i++)
+  {
+    char *head = headers->heads[i];
+    char *end = (i == headers->heads_size-1
+           ? headers->all_headers + headers->all_headers_fp
+           : headers->heads[i+1]);
+    char *colon, *ocolon;
+    char *contents;
+    char *name = 0;
+
+    // Hack for BSD Mailbox delimiter.
+    if (i == 0 && head[0] == 'F' && !strncmp(head, "From ", 5))
+    {
+      colon = head + 4;
+      contents = colon + 1;
+    }
+    else
+    {
+      /* Find the colon. */
+      for (colon = head; colon < end; colon++)
+      if (*colon == ':') break;
+
+      if (colon >= end) continue;   /* junk */
+
+      /* Back up over whitespace before the colon. */
+      ocolon = colon;
+      for (; colon > head && IS_SPACE(colon[-1]); colon--)
+      ;
+
+      contents = ocolon + 1;
+    }
+
+    /* Skip over whitespace after colon. */
+    while (contents <= end && IS_SPACE(*contents))
+    contents++;
+
+    /* Take off trailing whitespace... */
+    while (end > contents && IS_SPACE(end[-1]))
+    end--;
+
+    name = (char *)PR_MALLOC(colon - head + 1);
+    if (!name)
+      return /* MIME_OUT_OF_MEMORY */;
+    memcpy(name, head, colon - head);
+    name[colon - head] = 0;
+
+    nsAutoCString headerValue;
+    headerValue.Assign(contents, end - contents);
+
+    /* Do not reveal bcc recipients when forwarding a message!
+       See http://bugzilla.mozilla.org/show_bug.cgi?id=41150
+    */
+    if (PL_strcasecmp(name, "bcc") != 0)
+    {
+      if (!PL_strcasecmp(name, "resent-from") || !PL_strcasecmp(name, "from") ||
+          !PL_strcasecmp(name, "resent-to") || !PL_strcasecmp(name, "to") ||
+          !PL_strcasecmp(name, "resent-cc") || !PL_strcasecmp(name, "cc") ||
+          !PL_strcasecmp(name, "reply-to"))
+        UnquoteMimeAddress(headerValue, mailcharset);
+
+      mime_intl_insert_message_header_1(&newBody, headerValue.get(), name, name,
+        mailcharset, htmlEdit);
+    }
+    PR_Free(name);
+  }
+
+  if (htmlEdit)
+  {
+    NS_MsgSACat(&newBody, "</TABLE>");
+    NS_MsgSACat(&newBody, MSG_LINEBREAK "<BR><BR>");
+    if (html_tag)
+      NS_MsgSACat(&newBody, html_tag);
+    else if (*body)
+        NS_MsgSACat(&newBody, *body);
+  }
+  else
+  {
+    NS_MsgSACat(&newBody, MSG_LINEBREAK MSG_LINEBREAK);
+    if (*body)
+      NS_MsgSACat(&newBody, *body);
+  }
+
+  if (newBody)
+  {
+    PR_FREEIF(*body);
+    *body = newBody;
+  }
+}
+
+static void
+mime_insert_normal_headers(char             **body,
+                           MimeHeaders      *headers,
+                           MSG_ComposeFormat  composeFormat,
+                           char             *mailcharset)
+{
+  char *newBody = nullptr;
+  char *subject = MimeHeaders_get(headers, HEADER_SUBJECT, false, false);
+  char *resent_comments = MimeHeaders_get(headers, HEADER_RESENT_COMMENTS, false, false);
+  char *resent_date = MimeHeaders_get(headers, HEADER_RESENT_DATE, false, true);
+  nsCString resent_from(MimeHeaders_get(headers, HEADER_RESENT_FROM, false, true));
+  nsCString resent_to(MimeHeaders_get(headers, HEADER_RESENT_TO, false, true));
+  nsCString resent_cc(MimeHeaders_get(headers, HEADER_RESENT_CC, false, true));
+  char *date = MimeHeaders_get(headers, HEADER_DATE, false, true);
+  nsCString from(MimeHeaders_get(headers, HEADER_FROM, false, true));
+  nsCString reply_to(MimeHeaders_get(headers, HEADER_REPLY_TO, false, true));
+  char *organization = MimeHeaders_get(headers, HEADER_ORGANIZATION, false, false);
+  nsCString to(MimeHeaders_get(headers, HEADER_TO, false, true));
+  nsCString cc(MimeHeaders_get(headers, HEADER_CC, false, true));
+  char *newsgroups = MimeHeaders_get(headers, HEADER_NEWSGROUPS, false, true);
+  char *followup_to = MimeHeaders_get(headers, HEADER_FOLLOWUP_TO, false, true);
+  char *references = MimeHeaders_get(headers, HEADER_REFERENCES, false, true);
+  const char *html_tag = nullptr;
+  if (*body && PL_strncasecmp(*body, "<HTML", 5) == 0)
+    html_tag = PL_strchr(*body, '>') + 1;
+  bool htmlEdit = composeFormat == nsIMsgCompFormat::HTML;
+
+  if (from.IsEmpty())
+    from.Adopt(MimeHeaders_get(headers, HEADER_SENDER, false, true));
+  if (resent_from.IsEmpty())
+    resent_from.Adopt(MimeHeaders_get(headers, HEADER_RESENT_SENDER, false,
+      true));
+
+  UnquoteMimeAddress(resent_from, mailcharset);
+  UnquoteMimeAddress(resent_to, mailcharset);
+  UnquoteMimeAddress(resent_cc, mailcharset);
+  UnquoteMimeAddress(reply_to, mailcharset);
+  UnquoteMimeAddress(from, mailcharset);
+  UnquoteMimeAddress(to, mailcharset);
+  UnquoteMimeAddress(cc, mailcharset);
+
+  nsCString replyHeader;
+  MimeGetForwardHeaderDelimiter(replyHeader);
+  if (htmlEdit)
+  {
+    NS_MsgSACopy(&(newBody), MIME_FORWARD_HTML_PREFIX);
+    NS_MsgSACat(&newBody, replyHeader.get());
+    NS_MsgSACat(&newBody, MIME_HEADER_TABLE);
+  }
+  else
+  {
+    NS_MsgSACopy(&(newBody), MSG_LINEBREAK MSG_LINEBREAK);
+    NS_MsgSACat(&newBody, replyHeader.get());
+  }
+  if (subject)
+    mime_intl_insert_message_header_1(&newBody, subject, HEADER_SUBJECT,
+                      MimeGetNamedString(MIME_MHTML_SUBJECT),
+                      mailcharset, htmlEdit);
+  if (resent_comments)
+    mime_intl_insert_message_header_1(&newBody, resent_comments,
+                      HEADER_RESENT_COMMENTS,
+                      MimeGetNamedString(MIME_MHTML_RESENT_COMMENTS),
+                      mailcharset, htmlEdit);
+  if (resent_date)
+    mime_intl_insert_message_header_1(&newBody, resent_date,
+                      HEADER_RESENT_DATE,
+                      MimeGetNamedString(MIME_MHTML_RESENT_DATE),
+                      mailcharset, htmlEdit);
+  if (!resent_from.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, resent_from.get(),
+                      HEADER_RESENT_FROM,
+                      MimeGetNamedString(MIME_MHTML_RESENT_FROM),
+                      mailcharset, htmlEdit);
+  }
+  if (!resent_to.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, resent_to.get(),
+                      HEADER_RESENT_TO,
+                      MimeGetNamedString(MIME_MHTML_RESENT_TO),
+                      mailcharset, htmlEdit);
+  }
+  if (!resent_cc.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, resent_cc.get(),
+                      HEADER_RESENT_CC,
+                      MimeGetNamedString(MIME_MHTML_RESENT_CC),
+                      mailcharset, htmlEdit);
+  }
+  if (date)
+    mime_intl_insert_message_header_1(&newBody, date, HEADER_DATE,
+                      MimeGetNamedString(MIME_MHTML_DATE),
+                      mailcharset, htmlEdit);
+  if (!from.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, from.get(), HEADER_FROM,
+                      MimeGetNamedString(MIME_MHTML_FROM),
+                      mailcharset, htmlEdit);
+  }
+  if (!reply_to.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, reply_to.get(), HEADER_REPLY_TO,
+                      MimeGetNamedString(MIME_MHTML_REPLY_TO),
+                      mailcharset, htmlEdit);
+  }
+  if (organization)
+    mime_intl_insert_message_header_1(&newBody, organization,
+                      HEADER_ORGANIZATION,
+                      MimeGetNamedString(MIME_MHTML_ORGANIZATION),
+                      mailcharset, htmlEdit);
+  if (!to.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, to.get(), HEADER_TO,
+                      MimeGetNamedString(MIME_MHTML_TO),
+                      mailcharset, htmlEdit);
+  }
+  if (!cc.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, cc.get(), HEADER_CC,
+                      MimeGetNamedString(MIME_MHTML_CC),
+                      mailcharset, htmlEdit);
+  }
+    /*
+      Do not reveal bcc recipients when forwarding a message!
+      See http://bugzilla.mozilla.org/show_bug.cgi?id=41150
+    */
+  if (newsgroups)
+    mime_intl_insert_message_header_1(&newBody, newsgroups, HEADER_NEWSGROUPS,
+                      MimeGetNamedString(MIME_MHTML_NEWSGROUPS),
+                      mailcharset, htmlEdit);
+  if (followup_to)
+  {
+    mime_intl_insert_message_header_1(&newBody, followup_to,
+                      HEADER_FOLLOWUP_TO,
+                      MimeGetNamedString(MIME_MHTML_FOLLOWUP_TO),
+                      mailcharset, htmlEdit);
+  }
+  // only show references for newsgroups
+  if (newsgroups && references)
+  {
+    mime_intl_insert_message_header_1(&newBody, references,
+                      HEADER_REFERENCES,
+                      MimeGetNamedString(MIME_MHTML_REFERENCES),
+                      mailcharset, htmlEdit);
+  }
+  if (htmlEdit)
+  {
+    NS_MsgSACat(&newBody, "</TABLE>");
+    NS_MsgSACat(&newBody, MSG_LINEBREAK "<BR><BR>");
+    if (html_tag)
+      NS_MsgSACat(&newBody, html_tag);
+    else if (*body)
+        NS_MsgSACat(&newBody, *body);
+  }
+  else
+  {
+    NS_MsgSACat(&newBody, MSG_LINEBREAK MSG_LINEBREAK);
+    if (*body)
+      NS_MsgSACat(&newBody, *body);
+  }
+  if (newBody)
+  {
+    PR_FREEIF(*body);
+    *body = newBody;
+  }
+  PR_FREEIF(subject);
+  PR_FREEIF(resent_comments);
+  PR_FREEIF(resent_date);
+  PR_FREEIF(date);
+  PR_FREEIF(organization);
+  PR_FREEIF(newsgroups);
+  PR_FREEIF(followup_to);
+  PR_FREEIF(references);
+}
+
+static void
+mime_insert_micro_headers(char            **body,
+                          MimeHeaders     *headers,
+                          MSG_ComposeFormat composeFormat,
+                          char            *mailcharset)
+{
+  char *newBody = NULL;
+  char *subject = MimeHeaders_get(headers, HEADER_SUBJECT, false, false);
+  nsCString from(MimeHeaders_get(headers, HEADER_FROM, false, true));
+  nsCString resent_from(MimeHeaders_get(headers, HEADER_RESENT_FROM, false, true));
+  char *date = MimeHeaders_get(headers, HEADER_DATE, false, true);
+  nsCString to(MimeHeaders_get(headers, HEADER_TO, false, true));
+  nsCString cc(MimeHeaders_get(headers, HEADER_CC, false, true));
+  char *newsgroups = MimeHeaders_get(headers, HEADER_NEWSGROUPS, false,
+                     true);
+  const char *html_tag = nullptr;
+  if (*body && PL_strncasecmp(*body, "<HTML", 5) == 0)
+    html_tag = PL_strchr(*body, '>') + 1;
+  bool htmlEdit = composeFormat == nsIMsgCompFormat::HTML;
+
+  if (from.IsEmpty())
+    from.Adopt(MimeHeaders_get(headers, HEADER_SENDER, false, true));
+  if (resent_from.IsEmpty())
+    resent_from.Adopt(MimeHeaders_get(headers, HEADER_RESENT_SENDER, false, true));
+  if (!date)
+    date = MimeHeaders_get(headers, HEADER_RESENT_DATE, false, true);
+
+  UnquoteMimeAddress(resent_from, mailcharset);
+  UnquoteMimeAddress(from, mailcharset);
+  UnquoteMimeAddress(to, mailcharset);
+  UnquoteMimeAddress(cc, mailcharset);
+
+  nsCString replyHeader;
+  MimeGetForwardHeaderDelimiter(replyHeader);
+  if (htmlEdit)
+  {
+    NS_MsgSACopy(&(newBody), MIME_FORWARD_HTML_PREFIX);
+    NS_MsgSACat(&newBody, replyHeader.get());
+    NS_MsgSACat(&newBody, MIME_HEADER_TABLE);
+  }
+  else
+  {
+    NS_MsgSACopy(&(newBody), MSG_LINEBREAK MSG_LINEBREAK);
+    NS_MsgSACat(&newBody, replyHeader.get());
+  }
+
+  if (!from.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, from.get(), HEADER_FROM,
+                    MimeGetNamedString(MIME_MHTML_FROM),
+                    mailcharset, htmlEdit);
+  }
+  if (subject)
+    mime_intl_insert_message_header_1(&newBody, subject, HEADER_SUBJECT,
+                    MimeGetNamedString(MIME_MHTML_SUBJECT),
+                      mailcharset, htmlEdit);
+/*
+  if (date)
+    mime_intl_insert_message_header_1(&newBody, date, HEADER_DATE,
+                    MimeGetNamedString(MIME_MHTML_DATE),
+                    mailcharset, htmlEdit);
+*/
+  if (!resent_from.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, resent_from.get(),
+                    HEADER_RESENT_FROM,
+                    MimeGetNamedString(MIME_MHTML_RESENT_FROM),
+                    mailcharset, htmlEdit);
+  }
+  if (!to.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, to.get(), HEADER_TO,
+                    MimeGetNamedString(MIME_MHTML_TO),
+                    mailcharset, htmlEdit);
+  }
+  if (!cc.IsEmpty())
+  {
+    mime_intl_insert_message_header_1(&newBody, cc.get(), HEADER_CC,
+                    MimeGetNamedString(MIME_MHTML_CC),
+                    mailcharset, htmlEdit);
+  }
+  /*
+    Do not reveal bcc recipients when forwarding a message!
+    See http://bugzilla.mozilla.org/show_bug.cgi?id=41150
+  */
+  if (newsgroups)
+    mime_intl_insert_message_header_1(&newBody, newsgroups, HEADER_NEWSGROUPS,
+                    MimeGetNamedString(MIME_MHTML_NEWSGROUPS),
+                    mailcharset, htmlEdit);
+  if (htmlEdit)
+  {
+    NS_MsgSACat(&newBody, "</TABLE>");
+    NS_MsgSACat(&newBody, MSG_LINEBREAK "<BR><BR>");
+    if (html_tag)
+      NS_MsgSACat(&newBody, html_tag);
+    else if (*body)
+        NS_MsgSACat(&newBody, *body);
+  }
+  else
+  {
+    NS_MsgSACat(&newBody, MSG_LINEBREAK MSG_LINEBREAK);
+    if (*body)
+      NS_MsgSACat(&newBody, *body);
+  }
+  if (newBody)
+  {
+    PR_FREEIF(*body);
+    *body = newBody;
+  }
+  PR_FREEIF(subject);
+  PR_FREEIF(date);
+  PR_FREEIF(newsgroups);
+
+}
+
+// body has to be encoded in UTF-8
+static void
+mime_insert_forwarded_message_headers(char            **body,
+                                      MimeHeaders     *headers,
+                                      MSG_ComposeFormat composeFormat,
+                                      char            *mailcharset)
+{
+  if (!body || !headers)
+    return;
+
+  int32_t     show_headers = 0;
+  nsresult    res;
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &res));
+  if (NS_SUCCEEDED(res))
+    prefBranch->GetIntPref("mail.show_headers", &show_headers);
+
+  switch (show_headers)
+  {
+  case 0:
+    mime_insert_micro_headers(body, headers, composeFormat, mailcharset);
+    break;
+  default:
+  case 1:
+    mime_insert_normal_headers(body, headers, composeFormat, mailcharset);
+    break;
+  case 2:
+    mime_insert_all_headers(body, headers, composeFormat, mailcharset);
+    break;
+  }
+}
+
+static void
+mime_parse_stream_complete (nsMIMESession *stream)
+{
+  mime_draft_data *mdd = (mime_draft_data *) stream->data_object;
+  nsCOMPtr<nsIMsgCompFields> fields;
+  int htmlAction = 0;
+  int lineWidth = 0;
+
+  char *host = 0;
+  char *news_host = 0;
+  char *to_and_cc = 0;
+  char *re_subject = 0;
+  char *new_refs = 0;
+  char *from = 0;
+  char *repl = 0;
+  char *subj = 0;
+  char *id = 0;
+  char *refs = 0;
+  char *to = 0;
+  char *cc = 0;
+  char *bcc = 0;
+  char *fcc = 0;
+  char *org = 0;
+  char *grps = 0;
+  char *foll = 0;
+  char *priority = 0;
+  char *draftInfo = 0;
+  char *contentLanguage = 0;
+  char *identityKey = 0;
+
+  bool forward_inline = false;
+  bool bodyAsAttachment = false;
+  bool charsetOverride = false;
+
+  NS_ASSERTION (mdd, "null mime draft data");
+
+  if (!mdd) return;
+
+  if (mdd->obj)
+  {
+    int status;
+
+    status = mdd->obj->clazz->parse_eof ( mdd->obj, false );
+    mdd->obj->clazz->parse_end( mdd->obj, status < 0 ? true : false );
+
+    // RICHIE
+    // We need to figure out how to pass the forwarded flag along with this
+    // operation.
+
+    //forward_inline = (mdd->format_out != FO_CMDLINE_ATTACHMENTS);
+    forward_inline = mdd->forwardInline;
+
+    NS_ASSERTION ( mdd->options == mdd->obj->options, "mime draft options not same as obj->options" );
+    mime_free (mdd->obj);
+    mdd->obj = 0;
+    if (mdd->options)
+    {
+      // save the override flag before it's unavailable
+      charsetOverride = mdd->options->override_charset;
+      if ((!mdd->mailcharset || charsetOverride) && mdd->options->default_charset)
+      {
+        PR_Free(mdd->mailcharset);
+        mdd->mailcharset = strdup(mdd->options->default_charset);
+      }
+
+      // mscott: aren't we leaking a bunch of strings here like the charset strings and such?
+      delete mdd->options;
+      mdd->options = 0;
+    }
+    if (mdd->stream)
+    {
+      mdd->stream->complete ((nsMIMESession *)mdd->stream->data_object);
+      PR_Free( mdd->stream );
+      mdd->stream = 0;
+    }
+  }
+
+  //
+  // Now, process the attachments that we have gathered from the message
+  // on disk
+  //
+  nsMsgAttachmentData *newAttachData = mime_draft_process_attachments(mdd);
+
+  //
+  // time to bring up the compose windows with all the info gathered
+  //
+  if ( mdd->headers )
+  {
+    subj = MimeHeaders_get(mdd->headers, HEADER_SUBJECT,  false, false);
+    if (forward_inline)
+    {
+      if (subj)
+      {
+        nsresult rv;
+        nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+        if (NS_SUCCEEDED(rv))
+        {
+          nsAutoCString fwdPrefix;
+          prefBranch->GetCharPref("mail.forward_subject_prefix",
+                                  getter_Copies(fwdPrefix));
+          char *newSubj = PR_smprintf("%s: %s", !fwdPrefix.IsEmpty() ?
+                                                fwdPrefix.get(): "Fwd", subj);
+          if (newSubj)
+          {
+            PR_Free(subj);
+            subj = newSubj;
+          }
+        }
+      }
+    }
+    else
+    {
+      from = MimeHeaders_get(mdd->headers, HEADER_FROM,     false, false);
+      repl = MimeHeaders_get(mdd->headers, HEADER_REPLY_TO, false, false);
+      to   = MimeHeaders_get(mdd->headers, HEADER_TO,       false, true);
+      cc   = MimeHeaders_get(mdd->headers, HEADER_CC,       false, true);
+      bcc   = MimeHeaders_get(mdd->headers, HEADER_BCC,       false, true);
+
+      /* These headers should not be RFC-1522-decoded. */
+      grps = MimeHeaders_get(mdd->headers, HEADER_NEWSGROUPS,  false, true);
+      foll = MimeHeaders_get(mdd->headers, HEADER_FOLLOWUP_TO, false, true);
+
+      host = MimeHeaders_get(mdd->headers, HEADER_X_MOZILLA_NEWSHOST, false, false);
+      if (!host)
+        host = MimeHeaders_get(mdd->headers, HEADER_NNTP_POSTING_HOST, false, false);
+
+      id   = MimeHeaders_get(mdd->headers, HEADER_MESSAGE_ID,  false, false);
+      refs = MimeHeaders_get(mdd->headers, HEADER_REFERENCES,  false, true);
+      priority = MimeHeaders_get(mdd->headers, HEADER_X_PRIORITY, false, false);
+
+
+      if (host)
+      {
+        char *secure = NULL;
+
+        secure = PL_strcasestr(host, "secure");
+        if (secure)
+        {
+          *secure = 0;
+          news_host = PR_smprintf ("snews://%s", host);
+        }
+        else
+        {
+          news_host = PR_smprintf ("news://%s", host);
+        }
+      }
+    }
+
+
+    CreateCompositionFields( from, repl, to, cc, bcc, fcc, grps, foll,
+      org, subj, refs, priority, news_host,
+      mdd->mailcharset,
+      getter_AddRefs(fields));
+
+    contentLanguage = MimeHeaders_get(mdd->headers, HEADER_CONTENT_LANGUAGE, false, false);
+    if (contentLanguage) {
+      fields->SetContentLanguage(contentLanguage);
+    }
+
+    draftInfo = MimeHeaders_get(mdd->headers, HEADER_X_MOZILLA_DRAFT_INFO, false, false);
+
+    // Keep the same message id when editing a draft unless we're
+    // editing a message "as new message" (template) or forwarding inline.
+    if (mdd->format_out != nsMimeOutput::nsMimeMessageEditorTemplate &&
+        fields && !forward_inline) {
+      fields->SetMessageId(id);
+    }
+
+    if (draftInfo && fields && !forward_inline)
+    {
+      char *parm = 0;
+      parm = MimeHeaders_get_parameter(draftInfo, "vcard", NULL, NULL);
+      fields->SetAttachVCard(parm && !strcmp(parm, "1"));
+      PR_FREEIF(parm);
+
+      parm = MimeHeaders_get_parameter(draftInfo, "receipt", NULL, NULL);
+      if (!parm || !strcmp(parm, "0"))
+        fields->SetReturnReceipt(false);
+      else
+      {
+        int receiptType = 0;
+        fields->SetReturnReceipt(true);
+        sscanf(parm, "%d", &receiptType);
+        // slight change compared to 4.x; we used to use receipt= to tell
+        // whether the draft/template has request for either MDN or DNS or both
+        // return receipt; since the DNS is out of the picture we now use the
+        // header type - 1 to tell whether user has requested the return receipt
+        fields->SetReceiptHeaderType(((int32_t)receiptType) - 1);
+      }
+      PR_FREEIF(parm);
+      parm = MimeHeaders_get_parameter(draftInfo, "DSN", NULL, NULL);
+      fields->SetDSN(parm && !strcmp(parm, "1"));
+      PR_Free(parm);
+      parm = MimeHeaders_get_parameter(draftInfo, "html", NULL, NULL);
+      if (parm)
+        sscanf(parm, "%d", &htmlAction);
+      PR_FREEIF(parm);
+      parm = MimeHeaders_get_parameter(draftInfo, "linewidth", NULL, NULL);
+      if (parm)
+        sscanf(parm, "%d", &lineWidth);
+      PR_FREEIF(parm);
+      parm = MimeHeaders_get_parameter(draftInfo, "attachmentreminder", NULL, NULL);
+      if (parm && !strcmp(parm, "1"))
+        fields->SetAttachmentReminder(true);
+      else
+        fields->SetAttachmentReminder(false);
+      PR_FREEIF(parm);
+      parm = MimeHeaders_get_parameter(draftInfo, "deliveryformat", NULL, NULL);
+      if (parm) {
+        int32_t deliveryFormat = nsIMsgCompSendFormat::AskUser;
+        sscanf(parm, "%d", &deliveryFormat);
+        fields->SetDeliveryFormat(deliveryFormat);
+      }
+      PR_FREEIF(parm);
+    }
+
+  // identity to prefer when opening the message in the compose window?
+    identityKey = MimeHeaders_get(mdd->headers, HEADER_X_MOZILLA_IDENTITY_KEY, false, false);
+    if ( identityKey && *identityKey )
+    {
+        nsresult rv = NS_OK;
+        nsCOMPtr< nsIMsgAccountManager > accountManager =
+                do_GetService( NS_MSGACCOUNTMANAGER_CONTRACTID, &rv );
+        if ( NS_SUCCEEDED(rv) && accountManager )
+        {
+            nsCOMPtr< nsIMsgIdentity > overrulingIdentity;
+            rv = accountManager->GetIdentity( nsDependentCString(identityKey), getter_AddRefs( overrulingIdentity ) );
+
+            if (NS_SUCCEEDED(rv) && overrulingIdentity) {
+                mdd->identity = overrulingIdentity;
+                fields->SetCreatorIdentityKey(identityKey);
+            }
+        }
+    }
+
+    if (mdd->messageBody)
+    {
+      MSG_ComposeFormat composeFormat = nsIMsgCompFormat::Default;
+      if (!mdd->messageBody->m_type.IsEmpty())
+      {
+        if(mdd->messageBody->m_type.Find("text/html", CaseInsensitiveCompare) != -1)
+          composeFormat = nsIMsgCompFormat::HTML;
+        else if (mdd->messageBody->m_type.Find("text/plain", CaseInsensitiveCompare) != -1 ||
+                 mdd->messageBody->m_type.LowerCaseEqualsLiteral("text"))
+          composeFormat = nsIMsgCompFormat::PlainText;
+        else
+          //We cannot use this kind of data for the message body! Therefore, move it as attachment
+          bodyAsAttachment = true;
+      }
+      else
+        composeFormat = nsIMsgCompFormat::PlainText;
+
+      char *body = nullptr;
+      uint32_t bodyLen = 0;
+
+      if (!bodyAsAttachment && mdd->messageBody->m_tmpFile)
+      {
+        int64_t fileSize;
+        nsCOMPtr<nsIFile> tempFileCopy;
+        mdd->messageBody->m_tmpFile->Clone(getter_AddRefs(tempFileCopy));
+        mdd->messageBody->m_tmpFile = do_QueryInterface(tempFileCopy);
+        tempFileCopy = nullptr;
+        mdd->messageBody->m_tmpFile->GetFileSize(&fileSize);
+
+        // The stream interface can only read up to 4GB (32bit uint).
+        // It is highly unlikely to encounter a body lager than that limit,
+        // so we just skip it instead of reading it in chunks.
+        if (fileSize < UINT32_MAX)
+        {
+          bodyLen = fileSize;
+          body = (char *)PR_MALLOC(bodyLen + 1);
+        }
+        if (body)
+        {
+          memset (body, 0, bodyLen+1);
+
+          uint32_t bytesRead;
+          nsCOMPtr <nsIInputStream> inputStream;
+
+          nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), mdd->messageBody->m_tmpFile);
+          if (NS_FAILED(rv))
+            return;
+
+          inputStream->Read(body, bodyLen, &bytesRead);
+
+          inputStream->Close();
+
+          // Convert the body to UTF-8
+          char *mimeCharset = nullptr;
+          // Get a charset from the header if no override is set.
+          if (!charsetOverride)
+            mimeCharset = MimeHeaders_get_parameter (mdd->messageBody->m_type.get(), "charset", nullptr, nullptr);
+          // If no charset is specified in the header then use the default.
+          char *bodyCharset = mimeCharset ? mimeCharset : mdd->mailcharset;
+          if (bodyCharset)
+          {
+            nsAutoString tmpUnicodeBody;
+            rv = ConvertToUnicode(bodyCharset, body, tmpUnicodeBody);
+            if (NS_FAILED(rv)) // Tough luck, ASCII/ISO-8859-1 then...
+              CopyASCIItoUTF16(nsDependentCString(body), tmpUnicodeBody);
+
+            char *newBody = ToNewUTF8String(tmpUnicodeBody);
+            if (newBody)
+            {
+              PR_Free(body);
+              body = newBody;
+            }
+          }
+          PR_FREEIF(mimeCharset);
+        }
+      }
+
+      bool convertToPlainText = false;
+      if (forward_inline)
+      {
+        if (mdd->identity)
+        {
+          bool identityComposeHTML;
+          mdd->identity->GetComposeHtml(&identityComposeHTML);
+          if ((identityComposeHTML && !mdd->overrideComposeFormat) ||
+              (!identityComposeHTML && mdd->overrideComposeFormat))
+          {
+            // In the end, we're going to compose in HTML mode...
+
+            if (body && composeFormat == nsIMsgCompFormat::PlainText)
+            {
+              // ... but the message body is currently plain text.
+
+              //We need to convert the plain/text to HTML in order to escape any HTML markup
+              char *escapedBody = MsgEscapeHTML(body);
+              if (escapedBody)
+              {
+                PR_Free(body);
+                body = escapedBody;
+                bodyLen = strlen(body);
+              }
+
+               //+13 chars for <pre> & </pre> tags and CRLF
+              uint32_t newbodylen = bodyLen + 14;
+              char* newbody = (char *)PR_MALLOC (newbodylen);
+              if (newbody)
+              {
+                *newbody = 0;
+                PL_strcatn(newbody, newbodylen, "<PRE>");
+                PL_strcatn(newbody, newbodylen, body);
+                PL_strcatn(newbody, newbodylen, "</PRE>" CRLF);
+                PR_Free(body);
+                body = newbody;
+              }
+            }
+            // Body is now HTML, set the format too (so headers are inserted in
+            // correct format).
+            composeFormat = nsIMsgCompFormat::HTML;
+          }
+          else if ((identityComposeHTML && mdd->overrideComposeFormat) || !identityComposeHTML)
+          {
+            // In the end, we're going to compose in plain text mode...
+
+            if (composeFormat == nsIMsgCompFormat::HTML)
+            {
+              // ... but the message body is currently HTML.
+              // We'll do the conversion later on when headers have been
+              // inserted, body has been set and converted to unicode.
+              convertToPlainText = true;
+            }
+          }
+        }
+
+        mime_insert_forwarded_message_headers(&body, mdd->headers, composeFormat,
+          mdd->mailcharset);
+
+      }
+
+      // convert from UTF-8 to UTF-16
+      if (body)
+      {
+        fields->SetBody(NS_ConvertUTF8toUTF16(body));
+        PR_Free(body);
+      }
+
+      //
+      // At this point, we need to create a message compose window or editor
+      // window via XP-COM with the information that we have retrieved from
+      // the message store.
+      //
+      if (mdd->format_out == nsMimeOutput::nsMimeMessageEditorTemplate)
+      {
+        MSG_ComposeType msgComposeType = PL_strstr(mdd->url_name,
+                                                   "&redirect=true") ?
+                                         nsIMsgCompType::Redirect :
+                                         nsIMsgCompType::Template;
+        CreateTheComposeWindow(fields, newAttachData, msgComposeType,
+                               composeFormat, mdd->identity,
+                               mdd->originalMsgURI, mdd->origMsgHdr);
+      }
+      else
+      {
+        if (mdd->forwardInline)
+        {
+          if (convertToPlainText)
+            fields->ConvertBodyToPlainText();
+          if (mdd->overrideComposeFormat)
+            composeFormat = nsIMsgCompFormat::OppositeOfDefault;
+          if (mdd->forwardInlineFilter)
+          {
+            fields->SetTo(mdd->forwardToAddress);
+            ForwardMsgInline(fields, newAttachData, composeFormat,
+                             mdd->identity, mdd->originalMsgURI,
+                             mdd->origMsgHdr);
+          }
+          else
+            CreateTheComposeWindow(fields, newAttachData,
+                                   nsIMsgCompType::ForwardInline, composeFormat,
+                                   mdd->identity, mdd->originalMsgURI,
+                                   mdd->origMsgHdr);
+        }
+        else
+        {
+          fields->SetDraftId(mdd->url_name);
+          CreateTheComposeWindow(fields, newAttachData, nsIMsgCompType::Draft, composeFormat, mdd->identity, mdd->originalMsgURI, mdd->origMsgHdr);
+        }
+      }
+    }
+    else
+    {
+      //
+      // At this point, we need to create a message compose window via
+      // XP-COM with the information that we have retrieved from the message store.
+      //
+      if (mdd->format_out == nsMimeOutput::nsMimeMessageEditorTemplate)
+      {
+#ifdef NS_DEBUG
+        printf("RICHIE: Time to create the EDITOR with this template - NO body!!!!\n");
+#endif
+        CreateTheComposeWindow(fields, newAttachData, nsIMsgCompType::Template, nsIMsgCompFormat::Default, mdd->identity, nullptr, mdd->origMsgHdr);
+      }
+      else
+      {
+#ifdef NS_DEBUG
+        printf("Time to create the composition window WITHOUT a body!!!!\n");
+#endif
+        if (mdd->forwardInline)
+        {
+          MSG_ComposeFormat composeFormat = (mdd->overrideComposeFormat) ?
+            nsIMsgCompFormat::OppositeOfDefault : nsIMsgCompFormat::Default;
+          CreateTheComposeWindow(fields, newAttachData,
+                                 nsIMsgCompType::ForwardInline, composeFormat,
+                                 mdd->identity, mdd->originalMsgURI,
+                                 mdd->origMsgHdr);
+        }
+        else
+        {
+          fields->SetDraftId(mdd->url_name);
+          CreateTheComposeWindow(fields, newAttachData, nsIMsgCompType::Draft, nsIMsgCompFormat::Default, mdd->identity, nullptr, mdd->origMsgHdr);
+        }
+      }
+    }
+  }
+  else
+  {
+    CreateCompositionFields( from, repl, to, cc, bcc, fcc, grps, foll,
+      org, subj, refs, priority, news_host,
+      mdd->mailcharset,
+      getter_AddRefs(fields));
+    if (fields)
+      CreateTheComposeWindow(fields, newAttachData, nsIMsgCompType::New, nsIMsgCompFormat::Default, mdd->identity, nullptr, mdd->origMsgHdr);
+  }
+
+  if ( mdd->headers )
+    MimeHeaders_free ( mdd->headers );
+
+  //
+  // Free the original attachment structure...
+  // Make sure we only cleanup the local copy of the memory and not kill
+  // files we need on disk
+  //
+  if (bodyAsAttachment)
+    mdd->messageBody->m_tmpFile = nullptr;
+  else if (mdd->messageBody && mdd->messageBody->m_tmpFile)
+    mdd->messageBody->m_tmpFile->Remove(false);
+
+  delete mdd->messageBody;
+
+  for (uint32_t i = 0; i < mdd->attachments.Length(); i++)
+    mdd->attachments[i]->m_tmpFile = nullptr;
+
+  PR_FREEIF(mdd->mailcharset);
+
+  mdd->identity = nullptr;
+  PR_Free(mdd->url_name);
+  PR_Free(mdd->originalMsgURI);
+  mdd->origMsgHdr = nullptr;
+  PR_Free(mdd);
+
+  PR_FREEIF(host);
+  PR_FREEIF(to_and_cc);
+  PR_FREEIF(re_subject);
+  PR_FREEIF(new_refs);
+  PR_FREEIF(from);
+  PR_FREEIF(repl);
+  PR_FREEIF(subj);
+  PR_FREEIF(id);
+  PR_FREEIF(refs);
+  PR_FREEIF(to);
+  PR_FREEIF(cc);
+  PR_FREEIF(grps);
+  PR_FREEIF(foll);
+  PR_FREEIF(priority);
+  PR_FREEIF(draftInfo);
+  PR_Free(identityKey);
+
+  delete [] newAttachData;
+}
+
+static void
+mime_parse_stream_abort (nsMIMESession *stream, int status )
+{
+  mime_draft_data *mdd = (mime_draft_data *) stream->data_object;
+  NS_ASSERTION (mdd, "null mime draft data");
+
+  if (!mdd)
+    return;
+
+  if (mdd->obj)
+  {
+    int status=0;
+
+    if ( !mdd->obj->closed_p )
+      status = mdd->obj->clazz->parse_eof ( mdd->obj, true );
+    if ( !mdd->obj->parsed_p )
+      mdd->obj->clazz->parse_end( mdd->obj, true );
+
+    NS_ASSERTION ( mdd->options == mdd->obj->options, "draft display options not same as mime obj" );
+    mime_free (mdd->obj);
+    mdd->obj = 0;
+    if (mdd->options)
+    {
+      delete mdd->options;
+      mdd->options = 0;
+    }
+
+    if (mdd->stream)
+    {
+      mdd->stream->abort ((nsMIMESession *)mdd->stream->data_object, status);
+      PR_Free( mdd->stream );
+      mdd->stream = 0;
+    }
+  }
+
+  if ( mdd->headers )
+    MimeHeaders_free (mdd->headers);
+
+
+  mime_free_attachments(mdd->attachments);
+
+  PR_FREEIF(mdd->mailcharset);
+
+  PR_Free (mdd);
+}
+
+static int
+make_mime_headers_copy ( void *closure, MimeHeaders *headers )
+{
+  mime_draft_data *mdd = (mime_draft_data *) closure;
+
+  NS_ASSERTION ( mdd && headers, "null mime draft data and/or headers" );
+
+  if ( !mdd || ! headers )
+    return 0;
+
+  NS_ASSERTION ( mdd->headers == NULL , "non null mime draft data headers");
+
+  mdd->headers = MimeHeaders_copy ( headers );
+  mdd->options->done_parsing_outer_headers = true;
+
+  return 0;
+}
+
+int
+mime_decompose_file_init_fn ( void *stream_closure, MimeHeaders *headers )
+{
+  mime_draft_data *mdd = (mime_draft_data *) stream_closure;
+  nsMsgAttachedFile *newAttachment = 0;
+  int nAttachments = 0;
+  //char *hdr_value = NULL;
+  char *parm_value = NULL;
+  bool creatingMsgBody = true;
+
+  NS_ASSERTION (mdd && headers, "null mime draft data and/or headers");
+  if (!mdd || !headers)
+    return -1;
+
+  if (mdd->options->decompose_init_count)
+  {
+    mdd->options->decompose_init_count++;
+    NS_ASSERTION(mdd->curAttachment, "missing attachment in mime_decompose_file_init_fn");
+    if (mdd->curAttachment)
+      mdd->curAttachment->m_type.Adopt(MimeHeaders_get(headers,
+                                                       HEADER_CONTENT_TYPE,
+                                                       false, true));
+    return 0;
+  }
+  else
+    mdd->options->decompose_init_count++;
+
+  nAttachments = mdd->attachments.Length();
+
+  if (!nAttachments && !mdd->messageBody)
+  {
+    // if we've been told to use an override charset then do so....otherwise use the charset
+    // inside the message header...
+    if (mdd->options && mdd->options->override_charset)
+        mdd->mailcharset = strdup(mdd->options->default_charset);
+    else
+    {
+      char *contentType;
+      contentType = MimeHeaders_get(headers, HEADER_CONTENT_TYPE, false, false);
+      if (contentType)
+      {
+        mdd->mailcharset = MimeHeaders_get_parameter(contentType, "charset", NULL, NULL);
+        PR_FREEIF(contentType);
+      }
+    }
+
+    mdd->messageBody = new nsMsgAttachedFile;
+    if (!mdd->messageBody)
+      return MIME_OUT_OF_MEMORY;
+    newAttachment = mdd->messageBody;
+    creatingMsgBody = true;
+  }
+  else
+  {
+    /* always allocate one more extra; don't ask me why */
+    newAttachment = new nsMsgAttachedFile;
+    if (!newAttachment)
+      return MIME_OUT_OF_MEMORY;
+    mdd->attachments.AppendElement(newAttachment);
+  }
+
+  char *workURLSpec = nullptr;
+  char *contLoc = nullptr;
+
+  newAttachment->m_realName.Adopt(MimeHeaders_get_name(headers, mdd->options));
+  contLoc = MimeHeaders_get( headers, HEADER_CONTENT_LOCATION, false, false );
+  if (!contLoc)
+      contLoc = MimeHeaders_get( headers, HEADER_CONTENT_BASE, false, false );
+
+  if (!contLoc && !newAttachment->m_realName.IsEmpty())
+    workURLSpec = ToNewCString(newAttachment->m_realName);
+  if ( (contLoc) && (!workURLSpec) )
+    workURLSpec = strdup(contLoc);
+
+  PR_FREEIF(contLoc);
+
+  mdd->curAttachment = newAttachment;
+  newAttachment->m_type.Adopt(MimeHeaders_get ( headers, HEADER_CONTENT_TYPE, false, false ));
+
+  //
+  // This is to handle the degenerated Apple Double attachment.
+  //
+  parm_value = MimeHeaders_get( headers, HEADER_CONTENT_TYPE, false, false );
+  if (parm_value)
+  {
+    char *boundary = NULL;
+    char *tmp_value = NULL;
+    boundary = MimeHeaders_get_parameter(parm_value, "boundary", NULL, NULL);
+    if (boundary)
+      tmp_value = PR_smprintf("; boundary=\"%s\"", boundary);
+    if (tmp_value)
+      newAttachment->m_type = tmp_value;
+    newAttachment->m_xMacType.Adopt(
+      MimeHeaders_get_parameter(parm_value, "x-mac-type", NULL, NULL));
+    newAttachment->m_xMacCreator.Adopt(
+      MimeHeaders_get_parameter(parm_value, "x-mac-creator", NULL, NULL));
+    PR_FREEIF(parm_value);
+    PR_FREEIF(boundary);
+    PR_FREEIF(tmp_value);
+  }
+
+  newAttachment->m_size = 0;
+  newAttachment->m_encoding.Adopt(MimeHeaders_get (headers, HEADER_CONTENT_TRANSFER_ENCODING,
+                                                   false, false));
+  newAttachment->m_description.Adopt(MimeHeaders_get(headers, HEADER_CONTENT_DESCRIPTION,
+                                                     false, false ));
+  //
+  // If we came up empty for description or the orig URL, we should do something about it.
+  //
+  if (newAttachment->m_description.IsEmpty() && workURLSpec)
+    newAttachment->m_description = workURLSpec;
+
+  PR_FREEIF(workURLSpec);     // resource leak otherwise
+
+  newAttachment->m_cloudPartInfo.Adopt(MimeHeaders_get(headers,
+                                       HEADER_X_MOZILLA_CLOUD_PART,
+                                       false, false));
+
+  // There's no file in the message if it's a cloud part.
+  if (!newAttachment->m_cloudPartInfo.IsEmpty())
+  {
+    nsAutoCString fileURL;
+    fileURL.Adopt(
+      MimeHeaders_get_parameter(newAttachment->m_cloudPartInfo.get(), "file",
+                                nullptr, nullptr));
+    if (!fileURL.IsEmpty())
+      nsMimeNewURI(getter_AddRefs(newAttachment->m_origUrl), fileURL.get(),
+                   nullptr);
+    mdd->tmpFile = nullptr;
+    return 0;
+  }
+
+  nsCOMPtr <nsIFile> tmpFile = nullptr;
+  {
+    // Let's build a temp file with an extension based on the content-type: nsmail.<extension>
+
+    nsAutoCString  newAttachName ("nsmail");
+    bool extensionAdded = false;
+    // the content type may contain a charset. i.e. text/html; ISO-2022-JP...we want to strip off the charset
+    // before we ask the mime service for a mime info for this content type.
+    nsAutoCString contentType (newAttachment->m_type);
+    int32_t pos = contentType.FindChar(';');
+    if (pos > 0)
+      contentType.SetLength(pos);
+    nsresult  rv = NS_OK;
+    nsCOMPtr<nsIMIMEService> mimeFinder (do_GetService(NS_MIMESERVICE_CONTRACTID, &rv));
+    if (NS_SUCCEEDED(rv) && mimeFinder)
+    {
+      nsAutoCString fileExtension;
+      rv = mimeFinder->GetPrimaryExtension(contentType, EmptyCString(), fileExtension);
+
+      if (NS_SUCCEEDED(rv) && !fileExtension.IsEmpty())
+      {
+        newAttachName.Append(".");
+        newAttachName.Append(fileExtension);
+        extensionAdded = true;
+      }
+    }
+
+    if (!extensionAdded)
+    {
+      newAttachName.Append(".tmp");
+    }
+
+    nsMsgCreateTempFile(newAttachName.get(), getter_AddRefs(tmpFile));
+  }
+  nsresult rv;
+
+  // This needs to be done so the attachment structure has a handle
+  // on the temp file for this attachment...
+  if (tmpFile)
+  {
+      nsAutoCString fileURL;
+      rv = NS_GetURLSpecFromFile(tmpFile, fileURL);
+      if (NS_SUCCEEDED(rv))
+        nsMimeNewURI(getter_AddRefs(newAttachment->m_origUrl),
+                     fileURL.get(), nullptr);
+  }
+
+  if (!tmpFile)
+    return MIME_OUT_OF_MEMORY;
+
+  mdd->tmpFile = do_QueryInterface(tmpFile);
+
+  newAttachment->m_tmpFile = mdd->tmpFile;
+
+  rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mdd->tmpFileStream), tmpFile,PR_WRONLY | PR_CREATE_FILE, 00600);
+  if (NS_FAILED(rv))
+    return MIME_UNABLE_TO_OPEN_TMP_FILE;
+
+  // For now, we are always going to decode all of the attachments
+  // for the message. This way, we have native data
+  if (creatingMsgBody)
+  {
+    MimeDecoderData *(*fn) (MimeConverterOutputCallback, void*) = 0;
+
+    //
+    // Initialize a decoder if necessary.
+    //
+    if (newAttachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_BASE64))
+      fn = &MimeB64DecoderInit;
+    else if (newAttachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_QUOTED_PRINTABLE))
+    {
+      mdd->decoder_data = MimeQPDecoderInit (/* The (MimeConverterOutputCallback) cast is to turn the `void' argument into `MimeObject'. */
+                              ((MimeConverterOutputCallback) dummy_file_write),
+                              mdd->tmpFileStream);
+      if (!mdd->decoder_data)
+        return MIME_OUT_OF_MEMORY;
+    }
+    else if (newAttachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE) ||
+             newAttachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE2) ||
+             newAttachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE3) ||
+             newAttachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE4))
+      fn = &MimeUUDecoderInit;
+    else if (newAttachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_YENCODE))
+      fn = &MimeYDecoderInit;
+
+    if (fn)
+    {
+      mdd->decoder_data = fn (/* The (MimeConverterOutputCallback) cast is to
+                                 turn the `void' argument into `MimeObject'. */
+                              ((MimeConverterOutputCallback) dummy_file_write),
+                              mdd->tmpFileStream);
+      if (!mdd->decoder_data)
+        return MIME_OUT_OF_MEMORY;
+    }
+  }
+
+  return 0;
+}
+
+int
+mime_decompose_file_output_fn (const char     *buf,
+                               int32_t  size,
+                               void     *stream_closure )
+{
+  mime_draft_data *mdd = (mime_draft_data *) stream_closure;
+  int ret = 0;
+
+  NS_ASSERTION (mdd && buf, "missing mime draft data and/or buf");
+  if (!mdd || !buf) return -1;
+  if (!size) return 0;
+
+  if ( !mdd->tmpFileStream )
+    return 0;
+
+  if (mdd->decoder_data) {
+    int32_t outsize;
+    ret = MimeDecoderWrite(mdd->decoder_data, buf, size, &outsize);
+    if (ret == -1) return -1;
+    mdd->curAttachment->m_size += outsize;
+  }
+  else
+  {
+    uint32_t bytesWritten;
+    mdd->tmpFileStream->Write(buf, size, &bytesWritten);
+    if ((int32_t)bytesWritten < size)
+      return MIME_ERROR_WRITING_FILE;
+    mdd->curAttachment->m_size += size;
+  }
+
+  return 0;
+}
+
+int
+mime_decompose_file_close_fn ( void *stream_closure )
+{
+  mime_draft_data *mdd = (mime_draft_data *) stream_closure;
+
+  if (!mdd)
+    return -1;
+
+  if ( --mdd->options->decompose_init_count > 0 )
+      return 0;
+
+  if (mdd->decoder_data) {
+    MimeDecoderDestroy(mdd->decoder_data, false);
+    mdd->decoder_data = 0;
+  }
+
+  if (!mdd->tmpFileStream) {
+    // it's ok to have a null tmpFileStream if there's no tmpFile.
+    // This happens for cloud file attachments.
+    NS_ASSERTION(!mdd->tmpFile, "shouldn't have a tmp file bu no stream");
+    return 0;
+  }
+  mdd->tmpFileStream->Close();
+
+  mdd->tmpFileStream = nullptr;
+
+  mdd->tmpFile = nullptr;
+
+  return 0;
+}
+
+extern "C" void  *
+mime_bridge_create_draft_stream(
+                          nsIMimeEmitter      *newEmitter,
+                          nsStreamConverter   *newPluginObj2,
+                          nsIURI              *uri,
+                          nsMimeOutputType    format_out)
+{
+  int                     status = 0;
+  nsMIMESession           *stream = nullptr;
+  mime_draft_data  *mdd = nullptr;
+  MimeObject              *obj = nullptr;
+
+  if ( !uri )
+    return nullptr;
+
+  mdd = new mime_draft_data;
+  if (!mdd)
+    return nullptr;
+
+  nsAutoCString turl;
+  nsCOMPtr <nsIMsgMessageService> msgService;
+  nsCOMPtr<nsIURI> aURL;
+  nsAutoCString urlString;
+  nsresult rv;
+
+  // first, convert the rdf msg uri into a url that represents the message...
+  if (NS_FAILED(uri->GetSpec(turl)))
+    goto FAIL;
+
+  rv = GetMessageServiceFromURI(turl, getter_AddRefs(msgService));
+  if (NS_FAILED(rv))
+    goto FAIL;
+
+  rv = msgService->GetUrlForUri(turl.get(), getter_AddRefs(aURL), nullptr);
+  if (NS_FAILED(rv))
+    goto FAIL;
+
+  if (NS_SUCCEEDED(aURL->GetSpec(urlString)))
+  {
+    int32_t typeIndex = urlString.Find("&type=application/x-message-display");
+    if (typeIndex != -1)
+      urlString.Cut(typeIndex, sizeof("&type=application/x-message-display") - 1);
+
+    mdd->url_name = ToNewCString(urlString);
+    if (!(mdd->url_name))
+      goto FAIL;
+  }
+
+  newPluginObj2->GetForwardInline(&mdd->forwardInline);
+  newPluginObj2->GetForwardInlineFilter(&mdd->forwardInlineFilter);
+  newPluginObj2->GetForwardToAddress(mdd->forwardToAddress);
+  newPluginObj2->GetOverrideComposeFormat(&mdd->overrideComposeFormat);
+  newPluginObj2->GetIdentity(getter_AddRefs(mdd->identity));
+  newPluginObj2->GetOriginalMsgURI(&mdd->originalMsgURI);
+  newPluginObj2->GetOrigMsgHdr(getter_AddRefs(mdd->origMsgHdr));
+  mdd->format_out = format_out;
+  mdd->options = new  MimeDisplayOptions ;
+  if (!mdd->options)
+    goto FAIL;
+
+  mdd->options->url = strdup(mdd->url_name);
+  mdd->options->format_out = format_out;     // output format
+  mdd->options->decompose_file_p = true; /* new field in MimeDisplayOptions */
+  mdd->options->stream_closure = mdd;
+  mdd->options->html_closure = mdd;
+  mdd->options->decompose_headers_info_fn = make_mime_headers_copy;
+  mdd->options->decompose_file_init_fn = mime_decompose_file_init_fn;
+  mdd->options->decompose_file_output_fn = mime_decompose_file_output_fn;
+  mdd->options->decompose_file_close_fn = mime_decompose_file_close_fn;
+
+  mdd->options->m_prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  if (NS_FAILED(rv))
+    goto FAIL;
+
+#ifdef ENABLE_SMIME
+  /* If we're attaching a message (for forwarding) then we must eradicate all
+   traces of xlateion from it, since forwarding someone else a message
+   that wasn't xlated for them doesn't work.  We have to dexlate it
+   before sending it.
+   */
+  mdd->options->decrypt_p = true;
+#endif /* ENABLE_SMIME */
+
+  obj = mime_new ( (MimeObjectClass *) &mimeMessageClass, (MimeHeaders *) NULL, MESSAGE_RFC822 );
+  if ( !obj )
+    goto FAIL;
+
+  obj->options = mdd->options;
+  mdd->obj = obj;
+
+  stream = PR_NEWZAP ( nsMIMESession );
+  if ( !stream )
+    goto FAIL;
+
+  stream->name = "MIME To Draft Converter Stream";
+  stream->complete = mime_parse_stream_complete;
+  stream->abort = mime_parse_stream_abort;
+  stream->put_block = mime_parse_stream_write;
+  stream->data_object = mdd;
+
+  status = obj->clazz->initialize ( obj );
+  if ( status >= 0 )
+    status = obj->clazz->parse_begin ( obj );
+  if ( status < 0 )
+    goto FAIL;
+
+  return stream;
+
+FAIL:
+  if (mdd)
+  {
+    PR_Free(mdd->url_name);
+    PR_Free(mdd->originalMsgURI);
+    if (mdd->options)
+      delete mdd->options;
+    PR_Free ( mdd );
+  }
+  PR_Free ( stream );
+  PR_Free ( obj );
+
+  return nullptr;
+}