path: root/comm/mailnews/mime/src/mimedrft.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * 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 "nsNetUtil.h"
#include "comi18n.h"
#include "nsIMsgAttachment.h"
#include "nsIMsgCompFields.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 "modmimee.h"  // for MimeConverterOutputCallback
#include "mozilla/dom/Promise.h"
#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);

#define NS_MSGCOMPOSESERVICE_CID                    \
  { /* 588595FE-1ADA-11d3-A715-0060B0EB39B5 */      \
    0x588595fe, 0x1ada, 0x11d3, {                   \
      0xa7, 0x15, 0x0, 0x60, 0xb0, 0xeb, 0x39, 0xb5 \
    }                                               \
  }
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),
      autodetectCharset(false) {}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
// 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 nsACString& 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(
            "@mozilla.org/messengercompose/attachment;1", &rv);
        if (NS_SUCCEEDED(rv) && attachment) {
          nsAutoString nameStr;
          rv = nsMsgI18NConvertToUnicode("UTF-8"_ns, curAttachment->m_realName,
                                         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;
            nsCString cloudPartHeaderData;

            provider.Adopt(
                MimeHeaders_get_parameter(curAttachment->m_cloudPartInfo.get(),
                                          "provider", nullptr, nullptr));
            cloudUrl.Adopt(MimeHeaders_get_parameter(
                curAttachment->m_cloudPartInfo.get(), "url", nullptr, nullptr));
            cloudPartHeaderData.Adopt(
                MimeHeaders_get_parameter(curAttachment->m_cloudPartInfo.get(),
                                          "data", nullptr, nullptr));

            attachment->SetSendViaCloud(true);
            attachment->SetCloudFileAccountKey(provider);
            attachment->SetContentLocation(cloudUrl);
            attachment->SetCloudPartHeaderData(cloudPartHeaderData);
          }
          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("@mozilla.org/messengercompose/composeparams;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  pMsgComposeParams->SetType(composeType);
  pMsgComposeParams->SetFormat(format);
  pMsgComposeParams->SetIdentity(identity);
  pMsgComposeParams->SetComposeFields(compFields);
  if (!originalMsgURI.IsEmpty())
    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 nsACString& 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 nsACString& 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("@mozilla.org/messengercompose/compose;1", &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);

  RefPtr<mozilla::dom::Promise> promise;
  rv = pMsgCompose->SendMsg(nsIMsgSend::nsMsgDeliverNow, identity, nullptr,
                            nullptr, nullptr, getter_AddRefs(promise));
  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,
    const nsTArray<nsString>& otherHeaders, char* charset,
    nsIMsgCompFields** _retval) {
  NS_ENSURE_ARG_POINTER(_retval);

  nsresult rv;
  *_retval = nullptr;

  nsCOMPtr<nsIMsgCompFields> cFields =
      do_CreateInstance("@mozilla.org/messengercompose/composefields;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  NS_ENSURE_TRUE(cFields, NS_ERROR_OUT_OF_MEMORY);

  nsAutoCString val;
  nsAutoString outString;

  if (from) {
    nsMsgI18NConvertRawBytesToUTF16(
        nsDependentCString(from),
        charset ? nsDependentCString(charset) : EmptyCString(), 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) {
    nsMsgI18NConvertRawBytesToUTF16(
        nsDependentCString(reply_to),
        charset ? nsDependentCString(charset) : EmptyCString(), outString);
    cFields->SetReplyTo(outString);
  }

  if (to) {
    nsMsgI18NConvertRawBytesToUTF16(
        nsDependentCString(to),
        charset ? nsDependentCString(charset) : EmptyCString(), outString);
    cFields->SetTo(outString);
  }

  if (cc) {
    nsMsgI18NConvertRawBytesToUTF16(
        nsDependentCString(cc),
        charset ? nsDependentCString(charset) : EmptyCString(), outString);
    cFields->SetCc(outString);
  }

  if (bcc) {
    nsMsgI18NConvertRawBytesToUTF16(
        nsDependentCString(bcc),
        charset ? nsDependentCString(charset) : EmptyCString(), 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);
  }

  nsTArray<nsString> cFieldsOtherHeaders;
  cFields->GetOtherHeaders(cFieldsOtherHeaders);
  for (auto otherHeader : otherHeaders) {
    if (!otherHeader.IsEmpty()) {
      MIME_DecodeMimeHeader(NS_ConvertUTF16toUTF8(otherHeader).get(), charset,
                            false, true, val);
      cFieldsOtherHeaders.AppendElement(NS_ConvertUTF8toUTF16(val));
    } else {
      cFieldsOtherHeaders.AppendElement(u""_ns);
    }
  }
  cFields->SetOtherHeaders(cFieldsOtherHeaders);
  cFields.forget(_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.LowerCaseFindASCII("text/html") == kNotFound &&
      mdd->messageBody->m_type.LowerCaseFindASCII("text/plain") == kNotFound &&
      !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/vcard") ||
        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.LowerCaseFindASCII(MESSAGE_RFC822) != kNotFound)
            // 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()) {
    if (htmlEdit) {
      nsCString escaped;
      nsAppendEscapedHTML(utf8Value, escaped);
      NS_MsgSACat(body, escaped.get());
    } else {
      NS_MsgSACat(body, utf8Value.get());
    }
  } 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 convert_plaintext_body_to_html(char** body) {
  // We need to convert the plain/text to HTML in order to escape any HTML
  // markup.
  nsCString escapedBody;
  nsAppendEscapedHTML(nsDependentCString(*body), escapedBody);

  nsCString newBody;
  char* q = escapedBody.BeginWriting();
  char* p;
  int prevQuoteLevel = 0;
  bool isFlowed = false;
  bool haveSig = false;

  // First detect whether this appears to be flowed or not.
  p = q;
  while (*p) {
    // At worst we read the null byte terminator.
    if (*p == ' ' && (*(p + 1) == '\r' || *(p + 1) == '\n')) {
      // This looks flowed, but don't get fooled by a signature separator:
      // --space
      if (p - 3 >= q && (*(p - 3) == '\r' || *(p - 3) == '\n') &&
          *(p - 2) == '-' && *(p - 1) == '-') {
        p++;
        continue;
      }
      if (p - 2 == q && *(p - 2) == '-' && *(p - 1) == '-') {
        p++;
        continue;
      }
      isFlowed = true;
      break;
    }
    p++;
  }

  while (*q) {
    p = q;
    // Detect quotes. A quote character is a ">" which was escaped to &gt;.
    // In non-flowed messages the quote character can be optionally followed by
    // a space. Examples: Level 0
    //  > Level 0 (with leading space)
    // > Level 1
    // >  > Level 1 (with leading space, note the two spaces between the quote
    // characters)
    // >> Level 2
    // > > Level 2 (only when non-flowed, otherwise Level 1 with leading space)
    // >>> Level 3
    // > > >  Level 3 (with leading space, only when non-flowed, otherwise Level
    // 1)
    int quoteLevel = 0;
    while (strncmp(p, "&gt;", 4) == 0) {
      p += 4;
      if (!isFlowed && *p == ' ') p++;
      quoteLevel++;
    }

    // Eat space following quote character, for non-flowed already eaten above.
    if (quoteLevel > 0 && isFlowed && *p == ' ') p++;

    // Close any open signatures if we find a quote. Strange, that shouldn't
    // happen.
    if (quoteLevel > 0 && haveSig) {
      newBody.AppendLiteral("</pre>");
      haveSig = false;
    }
    if (quoteLevel > prevQuoteLevel) {
      while (prevQuoteLevel < quoteLevel) {
        if (isFlowed)
          newBody.AppendLiteral("<blockquote type=\"cite\">");
        else
          newBody.AppendLiteral(
              "<blockquote type=\"cite\"><pre wrap class=\"moz-quote-pre\">");
        prevQuoteLevel++;
      }
    } else if (quoteLevel < prevQuoteLevel) {
      while (prevQuoteLevel > quoteLevel) {
        if (isFlowed)
          newBody.AppendLiteral("</blockquote>");
        else
          newBody.AppendLiteral("</pre></blockquote>");
        prevQuoteLevel--;
      }
    }
    // Position after the quote.
    q = p;

    // Detect signature.
    bool forceBR = false;
    if (quoteLevel == 0) {
      if (strncmp(q, "-- \r", 4) == 0 || strncmp(q, "-- \n", 4) == 0) {
        haveSig = true;
        forceBR = true;
        newBody.AppendLiteral("<pre class=\"moz-signature\">");
      }
    }

    bool seenSpace = false;
    while (*p && *p != '\r' && *p != '\n') {
      seenSpace = (*p == ' ');
      p++;
      continue;
    }
    if (!*p) {
      // We're at the end of the string.
      if (p > q) {
        // Copy last bit over.
        newBody.Append(q);
      }
      break;
    }
    if (*p == '\r' &&
        *(p + 1) == '\n') {  // At worst we read the null byte terminator.
      // Skip the CR in CRLF.
      *p = 0;  // don't copy skipped \r.
      p++;
    }
    *p = 0;
    newBody.Append(q);
    if (!isFlowed || !seenSpace || forceBR) newBody.AppendLiteral("<br>");
    q = p + 1;
  }

  // Close all open quotes.
  while (prevQuoteLevel > 0) {
    if (isFlowed)
      newBody.AppendLiteral("</blockquote>");
    else
      newBody.AppendLiteral("</pre></blockquote>");
    prevQuoteLevel--;
  }

  // Close any open signatures.
  if (haveSig) {
    newBody.AppendLiteral("</pre>");
    haveSig = false;
  }

  PR_Free(*body);
  *body = ToNewCString(newBody);
}

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;
  nsTArray<nsString> readOtherHeaders;

  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;
      // Override the charset only if requested. If the message doesn't have
      // one and we're not overriding, we'll detect it later.
      if (charsetOverride && mdd->options->default_charset) {
        PR_FREEIF(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", 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);
        }
      }

      // Other headers via pref.
      nsCString otherHeaders;
      nsTArray<nsCString> otherHeadersArray;
      nsresult rv;
      nsCOMPtr<nsIPrefBranch> pPrefBranch(
          do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
      pPrefBranch->GetCharPref("mail.compose.other.header", otherHeaders);
      if (!otherHeaders.IsEmpty()) {
        ToLowerCase(otherHeaders);
        ParseString(otherHeaders, ',', otherHeadersArray);
        for (auto otherHeader : otherHeadersArray) {
          otherHeader.Trim(" ");
          nsAutoCString result;
          result.Assign(
              MimeHeaders_get(mdd->headers, otherHeader.get(), false, false));
          readOtherHeaders.AppendElement(NS_ConvertUTF8toUTF16(result));
        }
      }
    }

    CreateCompositionFields(from, repl, to, cc, bcc, fcc, grps, foll, org, subj,
                            refs, priority, news_host, readOtherHeaders,
                            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);

    // We always preserve an existing message ID, if present, apart from some
    // exceptions.
    bool keepID = fields != nullptr;

    // Don't keep ID when forwarding inline.
    if (forward_inline) keepID = false;

    // nsMimeOutput::nsMimeMessageEditorTemplate is used for editing a message
    // "as new", creating a message from a template or editing a template.
    // Only in the latter case we want to preserve the ID.
    if (mdd->format_out == nsMimeOutput::nsMimeMessageEditorTemplate &&
        !PL_strstr(mdd->url_name, "&edittempl=true"))
      keepID = false;

    if (keepID) 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::Unset;
        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("@mozilla.org/messenger/account-manager;1", &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.LowerCaseFindASCII("text/html") !=
            kNotFound)
          composeFormat = nsIMsgCompFormat::HTML;
        else if (mdd->messageBody->m_type.LowerCaseFindASCII("text/plain") !=
                     kNotFound ||
                 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;

      if (!bodyAsAttachment && mdd->messageBody->m_tmpFile) {
        int64_t fileSize;
        nsCOMPtr<nsIFile> tempFileCopy;
        mdd->messageBody->m_tmpFile->Clone(getter_AddRefs(tempFileCopy));
        mdd->messageBody->m_tmpFile = tempFileCopy;
        tempFileCopy = nullptr;
        mdd->messageBody->m_tmpFile->GetFileSize(&fileSize);
        uint32_t bodyLen = 0;

        // 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.
          nsAutoCString bodyCharset;
          if (mimeCharset) {
            bodyCharset.Adopt(mimeCharset);
          } else if (mdd->mailcharset) {
            bodyCharset.Assign(mdd->mailcharset);
          }
          if (bodyCharset.IsEmpty()) {
            nsAutoCString detectedCharset;
            // We need to detect it.
            rv = MIME_detect_charset(body, bodyLen, detectedCharset);
            if (NS_SUCCEEDED(rv) && !detectedCharset.IsEmpty()) {
              bodyCharset = detectedCharset;
            }
          }
          if (!bodyCharset.IsEmpty()) {
            nsAutoString tmpUnicodeBody;
            rv = nsMsgI18NConvertToUnicode(
                bodyCharset, nsDependentCString(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;
            }
          }
        }
      }

      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.
              convert_plaintext_body_to_html(&body);
            }
            // 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);
      }

      MSG_ComposeType msgComposeType = 0;  // Keep compilers happy.
      if (mdd->format_out == nsMimeOutput::nsMimeMessageEditorTemplate) {
        if (PL_strstr(mdd->url_name, "?redirect=true") ||
            PL_strstr(mdd->url_name, "&redirect=true"))
          msgComposeType = nsIMsgCompType::Redirect;
        else if (PL_strstr(mdd->url_name, "?editasnew=true") ||
                 PL_strstr(mdd->url_name, "&editasnew=true"))
          msgComposeType = nsIMsgCompType::EditAsNew;
        else if (PL_strstr(mdd->url_name, "?edittempl=true") ||
                 PL_strstr(mdd->url_name, "&edittempl=true"))
          msgComposeType = nsIMsgCompType::EditTemplate;
        else
          msgComposeType = nsIMsgCompType::Template;
      }

      if (body && msgComposeType == nsIMsgCompType::EditAsNew) {
        // When editing as new, we respect the identities preferred format
        // which can be overridden.
        if (mdd->identity) {
          bool identityComposeHTML;
          mdd->identity->GetComposeHtml(&identityComposeHTML);

          if (composeFormat == nsIMsgCompFormat::HTML &&
              identityComposeHTML == mdd->overrideComposeFormat) {
            // We we have HTML:
            // If they want HTML and they want to override it (true == true)
            // or they don't want HTML and they don't want to override it
            // (false == false), then convert. Conversion happens below.
            convertToPlainText = true;
            composeFormat = nsIMsgCompFormat::PlainText;
          } else if (composeFormat == nsIMsgCompFormat::PlainText &&
                     identityComposeHTML != mdd->overrideComposeFormat) {
            // We have plain text:
            // If they want HTML and they don't want to override it (true !=
            // false) or they don't want HTML and they want to override it
            // (false != true), then convert.
            convert_plaintext_body_to_html(&body);
            composeFormat = nsIMsgCompFormat::HTML;
          }
        }
      } else if (body && mdd->overrideComposeFormat &&
                 (msgComposeType == nsIMsgCompType::Template ||
                  msgComposeType == nsIMsgCompType::EditTemplate ||
                  !mdd->forwardInline))  // Draft processing.
      {
        // When using a template and overriding, the user gets the
        // "other" format.
        if (composeFormat == nsIMsgCompFormat::PlainText) {
          convert_plaintext_body_to_html(&body);
          composeFormat = nsIMsgCompFormat::HTML;
        } else {
          // Conversion happens below.
          convertToPlainText = true;
          composeFormat = nsIMsgCompFormat::PlainText;
        }
      }

      // 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) {
        // Set the draft ID when editing a template so the original is
        // overwritten when saving the template again.
        // Note that always setting the draft ID here would cause drafts to be
        // overwritten when edited "as new", which is undesired.
        if (msgComposeType == nsIMsgCompType::EditTemplate) {
          fields->SetDraftId(nsDependentCString(mdd->url_name));
          fields->SetTemplateId(nsDependentCString(
              mdd->url_name));  // Remember original template ID.
        }

        if (convertToPlainText) fields->ConvertBodyToPlainText();

        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 {
          if (convertToPlainText) fields->ConvertBodyToPlainText();
          fields->SetDraftId(nsDependentCString(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,
                               EmptyCString(), 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(nsDependentCString(mdd->url_name));
          CreateTheComposeWindow(fields, newAttachData, nsIMsgCompType::Draft,
                                 nsIMsgCompFormat::Default, mdd->identity,
                                 EmptyCString(), mdd->origMsgHdr);
        }
      }
    }
  } else {
    CreateCompositionFields(from, repl, to, cc, bcc, fcc, grps, foll, org, subj,
                            refs, priority, news_host, readOtherHeaders,
                            mdd->mailcharset, getter_AddRefs(fields));
    if (fields)
      CreateTheComposeWindow(fields, newAttachData, nsIMsgCompType::New,
                             nsIMsgCompFormat::Default, mdd->identity,
                             EmptyCString(), 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);
  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) {
      if (mdd->options->default_charset)
        mdd->mailcharset = strdup(mdd->options->default_charset);
      else {
        mdd->mailcharset = strdup("");
        mdd->autodetectCharset = true;
      }
    } 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));

  nsCOMPtr<nsIFile> tmpFile = nullptr;
  {
    // Let's build a temp file with an extension based on the content-type:
    // nsmail.<extension>

    nsAutoCString newAttachName("nsmail");
    nsAutoCString fileExtension;
    // 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);
    int32_t extLoc = newAttachment->m_realName.RFindChar('.');
    int32_t specLength = newAttachment->m_realName.Length();
    // @see nsExternalHelperAppService::GetTypeFromURI()
    if (extLoc != -1 && extLoc != specLength - 1 &&
        // nothing over 20 chars long can be sanely considered an
        // extension.... Dat dere would be just data.
        specLength - extLoc < 20) {
      fileExtension = Substring(newAttachment->m_realName, extLoc + 1);
    } else {
      nsCOMPtr<nsIMIMEService> mimeFinder(
          do_GetService(NS_MIMESERVICE_CONTRACTID));
      if (mimeFinder) {
        mimeFinder->GetPrimaryExtension(contentType, ""_ns, fileExtension);
      }
    }

    if (fileExtension.IsEmpty()) {
      newAttachName.AppendLiteral(".tmp");
    } else {
      newAttachName.Append('.');
      newAttachName.Append(fileExtension);
    }

    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 = 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->autodetectCharset) {
    nsAutoCString detectedCharset;
    nsresult res = NS_OK;
    res = MIME_detect_charset(buf, size, detectedCharset);
    if (NS_SUCCEEDED(res) && !detectedCharset.IsEmpty()) {
      mdd->mailcharset = ToNewCString(detectedCharset);
      mdd->autodetectCharset = false;
    }
  }

  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, nullptr, getter_AddRefs(aURL));
  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);
    if (mdd->options) delete mdd->options;
    PR_Free(mdd);
  }
  PR_Free(stream);
  PR_Free(obj);

  return nullptr;
}