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

1 files changed, 1920 insertions, 0 deletions

diff --git a/mailnews/mime/src/mimei.cpp b/mailnews/mime/src/mimei.cpp
new file mode 100644
index 000000000..c0a134a62
--- /dev/null
+++ b/mailnews/mime/src/mimei.cpp
@@ -0,0 +1,1920 @@
+/* -*- Mode: C; tab-width: 4; 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 "mimeobj.h"  /*  MimeObject (abstract)              */
+#include "mimecont.h"  /*   |--- MimeContainer (abstract)          */
+#include "mimemult.h"  /*   |     |--- MimeMultipart (abstract)      */
+#include "mimemmix.h"  /*   |     |     |--- MimeMultipartMixed      */
+#include "mimemdig.h"  /*   |     |     |--- MimeMultipartDigest      */
+#include "mimempar.h"  /*   |     |     |--- MimeMultipartParallel      */
+#include "mimemalt.h"  /*   |     |     |--- MimeMultipartAlternative    */
+#include "mimemrel.h"  /*   |     |     |--- MimeMultipartRelated      */
+#include "mimemapl.h"  /*   |     |     |--- MimeMultipartAppleDouble    */
+#include "mimesun.h"  /*   |     |     |--- MimeSunAttachment        */
+#include "mimemsig.h"  /*   |     |     |--- MimeMultipartSigned (abstract)*/
+#ifdef ENABLE_SMIME
+#include "mimemcms.h"   /*   |     |           |---MimeMultipartSignedCMS   */
+#endif
+#include "mimecryp.h"  /*   |     |--- MimeEncrypted (abstract)      */
+#ifdef ENABLE_SMIME
+#include "mimecms.h"  /*   |     |     |--- MimeEncryptedPKCS7      */
+#endif
+#include "mimemsg.h"  /*   |     |--- MimeMessage              */
+#include "mimeunty.h"  /*   |     |--- MimeUntypedText            */
+#include "mimeleaf.h"  /*   |--- MimeLeaf (abstract)            */
+#include "mimetext.h"  /*   |     |--- MimeInlineText (abstract)      */
+#include "mimetpla.h"  /*   |     |     |--- MimeInlineTextPlain      */
+#include "mimethpl.h"  /*   |     |     |     |--- M.I.TextHTMLAsPlaintext */
+#include "mimetpfl.h"   /*   |     |     |--- MimeInlineTextPlainFlowed     */
+#include "mimethtm.h"  /*   |     |     |--- MimeInlineTextHTML      */
+#include "mimethsa.h"  /*   |     |     |     |--- M.I.TextHTMLSanitized   */
+#include "mimeTextHTMLParsed.h" /*|     |     |--- M.I.TextHTMLParsed   */
+#include "mimetric.h"  /*   |     |     |--- MimeInlineTextRichtext    */
+#include "mimetenr.h"  /*   |     |     |     |--- MimeInlineTextEnriched  */
+/* SUPPORTED VIA PLUGIN      |     |     |--- MimeInlineTextVCard           */
+#include "mimeiimg.h"  /*   |     |--- MimeInlineImage            */
+#include "mimeeobj.h"  /*   |     |--- MimeExternalObject          */
+#include "mimeebod.h"  /*   |--- MimeExternalBody              */
+                        /* If you add classes here,also add them to mimei.h */
+#include "prlog.h"
+#include "prmem.h"
+#include "prenv.h"
+#include "plstr.h"
+#include "prlink.h"
+#include "prprf.h"
+#include "mimecth.h"
+#include "mimebuf.h"
+#include "nsIServiceManager.h"
+#include "mimemoz2.h"
+#include "nsIMimeContentTypeHandler.h"
+#include "nsIComponentManager.h"
+#include "nsCategoryManagerUtils.h"
+#include "nsXPCOMCID.h"
+#include "nsISimpleMimeConverter.h"
+#include "nsSimpleMimeConverterStub.h"
+#include "nsTArray.h"
+#include "nsMimeStringResources.h"
+#include "nsMimeTypes.h"
+#include "nsMsgUtils.h"
+#include "nsIPrefBranch.h"
+#include "mozilla/Preferences.h"
+#include "imgLoader.h"
+
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMsgHdr.h"
+
+using namespace mozilla;
+
+// forward declaration
+void getMsgHdrForCurrentURL(MimeDisplayOptions *opts, nsIMsgDBHdr ** aMsgHdr);
+
+#define  IMAP_EXTERNAL_CONTENT_HEADER "X-Mozilla-IMAP-Part"
+#define  EXTERNAL_ATTACHMENT_URL_HEADER "X-Mozilla-External-Attachment-URL"
+
+/* ==========================================================================
+   Allocation and destruction
+   ==========================================================================
+ */
+static int mime_classinit(MimeObjectClass *clazz);
+
+/*
+ * These are the necessary defines/variables for doing
+ * content type handlers in external plugins.
+ */
+typedef struct {
+  char        content_type[128];
+  bool        force_inline_display;
+} cthandler_struct;
+
+nsTArray<cthandler_struct*> *ctHandlerList = NULL;
+
+/*
+ * This will return TRUE if the content_type is found in the
+ * list, FALSE if it is not found.
+ */
+bool
+find_content_type_attribs(const char *content_type,
+                          bool       *force_inline_display)
+{
+  *force_inline_display = false;
+  if (!ctHandlerList)
+    return false;
+
+  for (size_t i = 0; i < ctHandlerList->Length(); i++) 
+  {
+    cthandler_struct *ptr = ctHandlerList->ElementAt(i);
+    if (PL_strcasecmp(content_type, ptr->content_type) == 0)
+    {
+      *force_inline_display = ptr->force_inline_display;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void
+add_content_type_attribs(const char *content_type,
+                         contentTypeHandlerInitStruct  *ctHandlerInfo)
+{
+  cthandler_struct    *ptr = NULL;
+  bool                force_inline_display;
+
+  if (find_content_type_attribs(content_type, &force_inline_display))
+    return;
+
+  if ( (!content_type) || (!ctHandlerInfo) )
+    return;
+
+  if (!ctHandlerList)
+    ctHandlerList = new nsTArray<cthandler_struct*>();
+
+  if (!ctHandlerList)
+    return;
+
+  ptr = (cthandler_struct *) PR_MALLOC(sizeof(cthandler_struct));
+  if (!ptr)
+    return;
+
+  PL_strncpy(ptr->content_type, content_type, sizeof(ptr->content_type));
+  ptr->force_inline_display = ctHandlerInfo->force_inline_display;
+  ctHandlerList->AppendElement(ptr);
+}
+
+/*
+ * This routine will find all content type handler for a specifc content
+ * type (if it exists)
+ */
+bool
+force_inline_display(const char *content_type)
+{
+  bool       force_inline_disp;
+
+  find_content_type_attribs(content_type, &force_inline_disp);
+  return (force_inline_disp);
+}
+
+/*
+ * This routine will find all content type handler for a specifc content
+ * type (if it exists) and is defined to the nsRegistry
+ */
+MimeObjectClass *
+mime_locate_external_content_handler(const char *content_type,
+                                     contentTypeHandlerInitStruct  *ctHandlerInfo)
+{
+  if (!content_type || !*(content_type)) // null or empty content type
+    return nullptr;
+
+  MimeObjectClass               *newObj = NULL;
+  nsresult rv;
+
+  nsAutoCString lookupID("@mozilla.org/mimecth;1?type=");
+  nsAutoCString contentType;
+  ToLowerCase(nsDependentCString(content_type), contentType);
+  lookupID += contentType;
+
+  nsCOMPtr<nsIMimeContentTypeHandler> ctHandler = do_CreateInstance(lookupID.get(), &rv);
+  if (NS_FAILED(rv) || !ctHandler) {
+    nsCOMPtr<nsICategoryManager> catman =
+      do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
+    if (NS_FAILED(rv))
+      return nullptr;
+
+    nsCString value;
+    rv = catman->GetCategoryEntry(NS_SIMPLEMIMECONVERTERS_CATEGORY,
+                                  contentType.get(), getter_Copies(value));
+    if (NS_FAILED(rv) || value.IsEmpty())
+      return nullptr;
+    rv = MIME_NewSimpleMimeConverterStub(contentType.get(),
+                                         getter_AddRefs(ctHandler));
+    if (NS_FAILED(rv) || !ctHandler)
+      return nullptr;
+  }
+
+  rv = ctHandler->CreateContentTypeHandlerClass(contentType.get(), ctHandlerInfo, &newObj);
+  if (NS_FAILED(rv))
+    return nullptr;
+
+  add_content_type_attribs(contentType.get(), ctHandlerInfo);
+  return newObj;
+}
+
+/* This is necessary to expose the MimeObject method outside of this DLL */
+int
+MIME_MimeObject_write(MimeObject *obj, const char *output, int32_t length, bool user_visible_p)
+{
+  return MimeObject_write(obj, output, length, user_visible_p);
+}
+
+MimeObject *
+mime_new (MimeObjectClass *clazz, MimeHeaders *hdrs,
+      const char *override_content_type)
+{
+  int size = clazz->instance_size;
+  MimeObject *object;
+  int status;
+
+  /* Some assertions to verify that this isn't random junk memory... */
+  NS_ASSERTION(clazz->class_name && strlen(clazz->class_name) > 0, "1.1 <rhp@netscape.com> 19 Mar 1999 12:00");
+  NS_ASSERTION(size > 0 && size < 1000, "1.1 <rhp@netscape.com> 19 Mar 1999 12:00");
+
+  if (!clazz->class_initialized)
+  {
+    status = mime_classinit(clazz);
+    if (status < 0) return 0;
+  }
+
+  NS_ASSERTION(clazz->initialize && clazz->finalize, "1.1 <rhp@netscape.com> 19 Mar 1999 12:00");
+
+  if (hdrs)
+  {
+    hdrs = MimeHeaders_copy (hdrs);
+    if (!hdrs) return 0;
+  }
+
+  object = (MimeObject *) PR_MALLOC(size);
+  if (!object) return 0;
+
+  memset(object, 0, size);
+  object->clazz = clazz;
+  object->headers = hdrs;
+  object->dontShowAsAttachment = false;
+
+  if (override_content_type && *override_content_type)
+    object->content_type = strdup(override_content_type);
+
+  status = clazz->initialize(object);
+  if (status < 0)
+  {
+    clazz->finalize(object);
+    PR_Free(object);
+    return 0;
+  }
+
+  return object;
+}
+
+void
+mime_free (MimeObject *object)
+{
+# ifdef DEBUG__
+  int i, size = object->clazz->instance_size;
+  uint32_t *array = (uint32_t*) object;
+# endif /* DEBUG */
+
+  object->clazz->finalize(object);
+
+# ifdef DEBUG__
+  for (i = 0; i < (size / sizeof(*array)); i++)
+  array[i] = (uint32_t) 0xDEADBEEF;
+# endif /* DEBUG */
+
+  PR_Free(object);
+}
+
+
+bool mime_is_allowed_class(const MimeObjectClass *clazz,
+                             int32_t types_of_classes_to_disallow)
+{
+  if (types_of_classes_to_disallow == 0)
+    return true;
+  bool avoid_html = (types_of_classes_to_disallow >= 1);
+  bool avoid_images = (types_of_classes_to_disallow >= 2);
+  bool avoid_strange_content = (types_of_classes_to_disallow >= 3);
+  bool allow_only_vanilla_classes = (types_of_classes_to_disallow == 100);
+
+  if (allow_only_vanilla_classes)
+    /* A "safe" class is one that is unlikely to have security bugs or to
+       allow security exploits or one that is essential for the usefulness
+       of the application, even for paranoid users.
+       What's included here is more personal judgement than following
+       strict rules, though, unfortunately.
+       The function returns true only for known good classes, i.e. is a
+       "whitelist" in this case.
+       This idea comes from Georgi Guninski.
+    */
+    return
+      (
+        clazz == (MimeObjectClass *)&mimeInlineTextPlainClass ||
+        clazz == (MimeObjectClass *)&mimeInlineTextPlainFlowedClass ||
+        clazz == (MimeObjectClass *)&mimeInlineTextHTMLSanitizedClass ||
+        clazz == (MimeObjectClass *)&mimeInlineTextHTMLAsPlaintextClass ||
+           /* The latter 2 classes bear some risk, because they use the Gecko
+              HTML parser, but the user has the option to make an explicit
+              choice in this case, via html_as. */
+        clazz == (MimeObjectClass *)&mimeMultipartMixedClass ||
+        clazz == (MimeObjectClass *)&mimeMultipartAlternativeClass ||
+        clazz == (MimeObjectClass *)&mimeMultipartDigestClass ||
+        clazz == (MimeObjectClass *)&mimeMultipartAppleDoubleClass ||
+        clazz == (MimeObjectClass *)&mimeMessageClass ||
+        clazz == (MimeObjectClass *)&mimeExternalObjectClass ||
+                               /*    mimeUntypedTextClass? -- does uuencode */
+#ifdef ENABLE_SMIME
+        clazz == (MimeObjectClass *)&mimeMultipartSignedCMSClass ||
+        clazz == (MimeObjectClass *)&mimeEncryptedCMSClass ||
+#endif
+        clazz == 0
+      );
+
+  /* Contrairy to above, the below code is a "blacklist", i.e. it
+     *excludes* some "bad" classes. */
+  return
+     !(
+        (avoid_html
+         && (
+              clazz == (MimeObjectClass *)&mimeInlineTextHTMLParsedClass
+                         /* Should not happen - we protect against that in
+                            mime_find_class(). Still for safety... */
+            )) ||
+        (avoid_images
+         && (
+              clazz == (MimeObjectClass *)&mimeInlineImageClass
+            )) ||
+        (avoid_strange_content
+         && (
+              clazz == (MimeObjectClass *)&mimeInlineTextEnrichedClass ||
+              clazz == (MimeObjectClass *)&mimeInlineTextRichtextClass ||
+              clazz == (MimeObjectClass *)&mimeSunAttachmentClass ||
+              clazz == (MimeObjectClass *)&mimeExternalBodyClass
+            ))
+      );
+}
+
+void getMsgHdrForCurrentURL(MimeDisplayOptions *opts, nsIMsgDBHdr ** aMsgHdr)
+{
+  *aMsgHdr = nullptr;
+
+  if (!opts)
+    return;
+
+  mime_stream_data *msd = (mime_stream_data *) (opts->stream_closure);
+  if (!msd)
+    return;
+
+  nsCOMPtr<nsIChannel> channel = msd->channel;  // note the lack of ref counting...
+  if (channel)
+  {
+    nsCOMPtr<nsIURI> uri;
+    nsCOMPtr<nsIMsgMessageUrl> msgURI;
+    channel->GetURI(getter_AddRefs(uri));
+    if (uri)
+    {
+      msgURI = do_QueryInterface(uri);
+      if (msgURI)
+      {
+        msgURI->GetMessageHeader(aMsgHdr);
+        if (*aMsgHdr)
+          return;
+        nsCString rdfURI;
+        msgURI->GetUri(getter_Copies(rdfURI));
+        if (!rdfURI.IsEmpty())
+        {
+          nsCOMPtr<nsIMsgDBHdr> msgHdr;
+          GetMsgDBHdrFromURI(rdfURI.get(), getter_AddRefs(msgHdr));
+          NS_IF_ADDREF(*aMsgHdr = msgHdr);
+        }
+      }
+    }
+  }
+
+  return;
+}
+
+MimeObjectClass *
+mime_find_class (const char *content_type, MimeHeaders *hdrs,
+         MimeDisplayOptions *opts, bool exact_match_p)
+{
+  MimeObjectClass *clazz = 0;
+  MimeObjectClass *tempClass = 0;
+  contentTypeHandlerInitStruct  ctHandlerInfo;
+
+  // Read some prefs
+  nsIPrefBranch *prefBranch = GetPrefBranch(opts);
+  int32_t html_as = 0;  // def. see below
+  int32_t types_of_classes_to_disallow = 0;  /* Let only a few libmime classes
+       process incoming data. This protects from bugs (e.g. buffer overflows)
+       and from security loopholes (e.g. allowing unchecked HTML in some
+       obscure classes, although the user has html_as > 0).
+       This option is mainly for the UI of html_as.
+       0 = allow all available classes
+       1 = Use hardcoded blacklist to avoid rendering (incoming) HTML
+       2 = ... and images
+       3 = ... and some other uncommon content types
+       4 = show all body parts
+       100 = Use hardcoded whitelist to avoid even more bugs(buffer overflows).
+           This mode will limit the features available (e.g. uncommon
+           attachment types and inline images) and is for paranoid users.
+       */
+  if (opts && opts->format_out != nsMimeOutput::nsMimeMessageFilterSniffer &&
+               opts->format_out != nsMimeOutput::nsMimeMessageDecrypt
+               && opts->format_out != nsMimeOutput::nsMimeMessageAttach)
+    if (prefBranch)
+    {
+      prefBranch->GetIntPref("mailnews.display.html_as", &html_as);
+      prefBranch->GetIntPref("mailnews.display.disallow_mime_handlers",
+                            &types_of_classes_to_disallow);
+      if (types_of_classes_to_disallow > 0 && html_as == 0)
+           // We have non-sensical prefs. Do some fixup.
+        html_as = 1;
+    }
+
+  // First, check to see if the message has been marked as JUNK. If it has,
+  // then force the message to be rendered as simple, unless this has been
+  // called by a filtering routine.
+  bool sanitizeJunkMail = false;
+
+  // it is faster to read the pref first then figure out the msg hdr for the current url only if we have to
+  // XXX instead of reading this pref every time, part of mime should be an observer listening to this pref change
+  // and updating internal state accordingly. But none of the other prefs in this file seem to be doing that...=(
+  if (prefBranch)
+    prefBranch->GetBoolPref("mail.spam.display.sanitize", &sanitizeJunkMail);
+
+  if (sanitizeJunkMail &&
+      !(opts && opts->format_out == nsMimeOutput::nsMimeMessageFilterSniffer))
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    getMsgHdrForCurrentURL(opts, getter_AddRefs(msgHdr));
+    if (msgHdr)
+    {
+      nsCString junkScoreStr;
+      (void) msgHdr->GetStringProperty("junkscore", getter_Copies(junkScoreStr));
+      if (html_as == 0 && junkScoreStr.get() && atoi(junkScoreStr.get()) > 50)
+        html_as = 3; // 3 == Simple HTML
+    } // if msgHdr
+  } // if we are supposed to sanitize junk mail
+
+  /*
+  * What we do first is check for an external content handler plugin.
+  * This will actually extend the mime handling by calling a routine
+  * which will allow us to load an external content type handler
+  * for specific content types. If one is not found, we will drop back
+  * to the default handler.
+  */
+  if ((tempClass = mime_locate_external_content_handler(content_type, &ctHandlerInfo)) != NULL)
+  {
+#ifdef MOZ_THUNDERBIRD
+      // This is a case where we only want to add this property if we are a thunderbird build AND
+      // we have found an external mime content handler for text/calendar
+      // This will enable iMIP support in Lightning
+      if ( hdrs && (!PL_strncasecmp(content_type, "text/calendar", 13)))
+      {
+          char *full_content_type = MimeHeaders_get(hdrs, HEADER_CONTENT_TYPE, false, false);
+          if (full_content_type)
+          {
+              char *imip_method = MimeHeaders_get_parameter(full_content_type, "method", NULL, NULL);
+              nsCOMPtr<nsIMsgDBHdr> msgHdr;
+              getMsgHdrForCurrentURL(opts, getter_AddRefs(msgHdr));
+              if (msgHdr)
+                msgHdr->SetStringProperty("imip_method", (imip_method) ? imip_method : "nomethod");
+              // PR_Free checks for null
+              PR_Free(imip_method);
+              PR_Free(full_content_type);
+          }
+      }
+#endif
+
+    if (types_of_classes_to_disallow > 0
+        && (!PL_strncasecmp(content_type, "text/x-vcard", 12))
+       )
+      /* Use a little hack to prevent some dangerous plugins, which ship
+         with Mozilla, to run.
+         For the truely user-installed plugins, we rely on the judgement
+         of the user. */
+    {
+      if (!exact_match_p)
+        clazz = (MimeObjectClass *)&mimeExternalObjectClass; // As attachment
+    }
+    else
+      clazz = (MimeObjectClass *)tempClass;
+  }
+  else
+  {
+    if (!content_type || !*content_type ||
+        !PL_strcasecmp(content_type, "text"))  /* with no / in the type */
+      clazz = (MimeObjectClass *)&mimeUntypedTextClass;
+
+    /* Subtypes of text...
+    */
+    else if (!PL_strncasecmp(content_type,      "text/", 5))
+    {
+      if      (!PL_strcasecmp(content_type+5,    "html"))
+      {
+        if (opts &&
+            (opts->format_out == nsMimeOutput::nsMimeMessageSaveAs ||
+             opts->format_out == nsMimeOutput::nsMimeMessageFilterSniffer ||
+             opts->format_out == nsMimeOutput::nsMimeMessageDecrypt ||
+             opts->format_out == nsMimeOutput::nsMimeMessageAttach))
+          // SaveAs in new modes doesn't work yet.
+        {
+          // Don't use the parsed HTML class if we're ...
+          // - saving the HTML of a message
+          // - getting message content for filtering
+          // - snarfing attachments (nsMimeMessageDecrypt used in SnarfMsgAttachment)
+          // - processing attachments (like deleting attachments).
+          clazz = (MimeObjectClass *)&mimeInlineTextHTMLClass;
+          types_of_classes_to_disallow = 0;
+        }
+        else if (html_as == 0 || html_as == 4) // Render sender's HTML
+          clazz = (MimeObjectClass *)&mimeInlineTextHTMLParsedClass;
+        else if (html_as == 1) // convert HTML to plaintext
+          // Do a HTML->TXT->HTML conversion, see mimethpl.h.
+          clazz = (MimeObjectClass *)&mimeInlineTextHTMLAsPlaintextClass;
+        else if (html_as == 2) // display HTML source
+          /* This is for the freaks. Treat HTML as plaintext,
+             which will cause the HTML source to be displayed.
+             Not very user-friendly, but some seem to want this. */
+          clazz = (MimeObjectClass *)&mimeInlineTextPlainClass;
+        else if (html_as == 3) // Sanitize
+          // Strip all but allowed HTML
+          clazz = (MimeObjectClass *)&mimeInlineTextHTMLSanitizedClass;
+        else // Goofy pref
+          /* User has an unknown pref value. Maybe he used a newer Mozilla
+             with a new alternative to avoid HTML. Defaulting to option 1,
+             which is less dangerous than defaulting to the raw HTML. */
+          clazz = (MimeObjectClass *)&mimeInlineTextHTMLAsPlaintextClass;
+      }
+      else if (!PL_strcasecmp(content_type+5,    "enriched"))
+        clazz = (MimeObjectClass *)&mimeInlineTextEnrichedClass;
+      else if (!PL_strcasecmp(content_type+5,    "richtext"))
+        clazz = (MimeObjectClass *)&mimeInlineTextRichtextClass;
+      else if (!PL_strcasecmp(content_type+5,    "rtf"))
+        clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+      else if (!PL_strcasecmp(content_type+5,    "plain"))
+      {
+        // Preliminary use the normal plain text
+        clazz = (MimeObjectClass *)&mimeInlineTextPlainClass;
+
+        if (opts && opts->format_out != nsMimeOutput::nsMimeMessageFilterSniffer
+          && opts->format_out != nsMimeOutput::nsMimeMessageAttach
+          && opts->format_out != nsMimeOutput::nsMimeMessageRaw)
+        {
+          bool disable_format_flowed = false;
+          if (prefBranch)
+            prefBranch->GetBoolPref("mailnews.display.disable_format_flowed_support",
+                                    &disable_format_flowed);
+
+          if(!disable_format_flowed)
+          {
+            // Check for format=flowed, damn, it is already stripped away from
+            // the contenttype!
+            // Look in headers instead even though it's expensive and clumsy
+            // First find Content-Type:
+            char *content_type_row =
+              (hdrs
+               ? MimeHeaders_get(hdrs, HEADER_CONTENT_TYPE,
+                                 false, false)
+               : 0);
+            // Then the format parameter if there is one.
+            // I would rather use a PARAM_FORMAT but I can't find the right
+            // place to put the define. The others seems to be in net.h
+            // but is that really really the right place? There is also
+            // a nsMimeTypes.h but that one isn't included. Bug?
+            char *content_type_format =
+              (content_type_row
+               ? MimeHeaders_get_parameter(content_type_row, "format", NULL,NULL)
+               : 0);
+
+            if (content_type_format && !PL_strcasecmp(content_type_format,
+                                                          "flowed"))
+              clazz = (MimeObjectClass *)&mimeInlineTextPlainFlowedClass;
+            PR_FREEIF(content_type_format);
+            PR_FREEIF(content_type_row);
+          }
+        }
+      }
+      else if (!exact_match_p)
+        clazz = (MimeObjectClass *)&mimeInlineTextPlainClass;
+    }
+
+    /* Subtypes of multipart...
+    */
+    else if (!PL_strncasecmp(content_type,      "multipart/", 10))
+    {
+      // When html_as is 4, we want all MIME parts of the message to
+      // show up in the displayed message body, if they are MIME types
+      // that we know how to display, and also in the attachment pane
+      // if it's appropriate to put them there. Both
+      // multipart/alternative and multipart/related play games with
+      // hiding various MIME parts, and we don't want that to happen,
+      // so we prevent that by parsing those MIME types as
+      // multipart/mixed, which won't mess with anything.
+      //
+      // When our output format is nsMimeOutput::nsMimeMessageAttach,
+      // i.e., we are reformatting the message to remove attachments,
+      // we are in a similar boat. The code for deleting
+      // attachments properly in that mode is in mimemult.cpp
+      // functions which are inherited by mimeMultipartMixedClass but
+      // not by mimeMultipartAlternativeClass or
+      // mimeMultipartRelatedClass. Therefore, to ensure that
+      // everything is handled properly, in this context too we parse
+      // those MIME types as multipart/mixed.
+      bool basic_formatting = (html_as == 4) ||
+        (opts && opts->format_out == nsMimeOutput::nsMimeMessageAttach);
+      if      (!PL_strcasecmp(content_type+10,  "alternative"))
+        clazz = basic_formatting ? (MimeObjectClass *)&mimeMultipartMixedClass :
+          (MimeObjectClass *)&mimeMultipartAlternativeClass;
+      else if (!PL_strcasecmp(content_type+10,  "related"))
+        clazz = basic_formatting ? (MimeObjectClass *)&mimeMultipartMixedClass :
+          (MimeObjectClass *)&mimeMultipartRelatedClass;
+      else if (!PL_strcasecmp(content_type+10,  "digest"))
+        clazz = (MimeObjectClass *)&mimeMultipartDigestClass;
+      else if (!PL_strcasecmp(content_type+10,  "appledouble") ||
+               !PL_strcasecmp(content_type+10,  "header-set"))
+        clazz = (MimeObjectClass *)&mimeMultipartAppleDoubleClass;
+      else if (!PL_strcasecmp(content_type+10,  "parallel"))
+        clazz = (MimeObjectClass *)&mimeMultipartParallelClass;
+      else if (!PL_strcasecmp(content_type+10,  "mixed"))
+        clazz = (MimeObjectClass *)&mimeMultipartMixedClass;
+#ifdef ENABLE_SMIME
+      else if (!PL_strcasecmp(content_type+10,  "signed"))
+      {
+      /* Check that the "protocol" and "micalg" parameters are ones we
+        know about. */
+        char *ct = (hdrs
+          ? MimeHeaders_get(hdrs, HEADER_CONTENT_TYPE,
+                            false, false)
+                    : 0);
+        char *proto = (ct
+          ? MimeHeaders_get_parameter(ct, PARAM_PROTOCOL, NULL, NULL)
+          : 0);
+        char *micalg = (ct
+          ? MimeHeaders_get_parameter(ct, PARAM_MICALG, NULL, NULL)
+          : 0);
+
+          if (proto
+              && (
+                  (/* is a signature */
+                   !PL_strcasecmp(proto, APPLICATION_XPKCS7_SIGNATURE)
+                   ||
+                   !PL_strcasecmp(proto, APPLICATION_PKCS7_SIGNATURE))
+                  && micalg
+                  && (!PL_strcasecmp(micalg, PARAM_MICALG_MD5) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_MD5_2) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA1) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA1_2) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA1_3) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA1_4) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA1_5) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA256) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA256_2) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA256_3) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA384) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA384_2) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA384_3) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA512) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA512_2) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_SHA512_3) ||
+                      !PL_strcasecmp(micalg, PARAM_MICALG_MD2))))
+            clazz = (MimeObjectClass *)&mimeMultipartSignedCMSClass;
+          else
+            clazz = 0;
+        PR_FREEIF(proto);
+        PR_FREEIF(micalg);
+        PR_FREEIF(ct);
+      }
+#endif
+
+      if (!clazz && !exact_match_p)
+        /* Treat all unknown multipart subtypes as "multipart/mixed" */
+        clazz = (MimeObjectClass *)&mimeMultipartMixedClass;
+
+      /* If we are sniffing a message, let's treat alternative parts as mixed */
+      if (opts && opts->format_out == nsMimeOutput::nsMimeMessageFilterSniffer)
+        if (clazz == (MimeObjectClass *)&mimeMultipartAlternativeClass)
+          clazz = (MimeObjectClass *)&mimeMultipartMixedClass;
+    }
+
+    /* Subtypes of message...
+    */
+    else if (!PL_strncasecmp(content_type,      "message/", 8))
+    {
+      if      (!PL_strcasecmp(content_type+8,    "rfc822") ||
+        !PL_strcasecmp(content_type+8,    "news"))
+        clazz = (MimeObjectClass *)&mimeMessageClass;
+      else if (!PL_strcasecmp(content_type+8,    "external-body"))
+        clazz = (MimeObjectClass *)&mimeExternalBodyClass;
+      else if (!PL_strcasecmp(content_type+8,    "partial"))
+        /* I guess these are most useful as externals, for now... */
+        clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+      else if (!exact_match_p)
+        /* Treat all unknown message subtypes as "text/plain" */
+        clazz = (MimeObjectClass *)&mimeInlineTextPlainClass;
+    }
+
+    /* The magic image types which we are able to display internally...
+    */
+    else if (!PL_strncasecmp(content_type,    "image/", 6)) {
+        if (imgLoader::SupportImageWithMimeType(content_type, AcceptedMimeTypes::IMAGES_AND_DOCUMENTS))
+          clazz = (MimeObjectClass *)&mimeInlineImageClass;
+        else
+          clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+    }
+
+#ifdef ENABLE_SMIME
+    else if (!PL_strcasecmp(content_type, APPLICATION_XPKCS7_MIME)
+             || !PL_strcasecmp(content_type, APPLICATION_PKCS7_MIME)) {
+
+        if (Preferences::GetBool("mailnews.p7m_subparts_external", false) &&
+            opts->is_child) {
+          // We do not allow encrypted parts except as top level.
+          // Allowing them would leak the plain text in case the part is
+          // cleverly hidden and the decrypted content gets included in
+          // replies and forwards.
+          clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+          return clazz;
+        }
+
+        char *ct = (hdrs ? MimeHeaders_get(hdrs, HEADER_CONTENT_TYPE,
+                                           false, false)
+                           : nullptr);
+        char *st = (ct ? MimeHeaders_get_parameter(ct, "smime-type", NULL, NULL)
+                         : nullptr);
+
+        /* by default, assume that it is an encrypted message */
+        clazz = (MimeObjectClass *)&mimeEncryptedCMSClass;
+
+        /* if the smime-type parameter says that it's a certs-only or
+           compressed file, then show it as an attachment, however
+           (MimeEncryptedCMS doesn't handle these correctly) */
+        if (st &&
+            (!PL_strcasecmp(st, "certs-only") ||
+             !PL_strcasecmp(st, "compressed-data")))
+          clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+        else {
+          /* look at the file extension... less reliable, but still covered
+             by the S/MIME specification (RFC 3851, section 3.2.1)  */
+          char *name = (hdrs ? MimeHeaders_get_name(hdrs, opts) : nullptr);
+          if (name) {
+            char *suf = PL_strrchr(name, '.');
+            bool p7mExternal = false;
+
+            if (prefBranch)
+              prefBranch->GetBoolPref("mailnews.p7m_external", &p7mExternal);
+            if (suf &&
+                ((!PL_strcasecmp(suf, ".p7m") && p7mExternal) ||
+                 !PL_strcasecmp(suf, ".p7c") ||
+                 !PL_strcasecmp(suf, ".p7z")))
+              clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+          }
+          PR_Free(name);
+        }
+        PR_Free(st);
+        PR_Free(ct);
+    }
+#endif
+    /* A few types which occur in the real world and which we would otherwise
+    treat as non-text types (which would be bad) without this special-case...
+    */
+    else if (!PL_strcasecmp(content_type,      APPLICATION_PGP) ||
+             !PL_strcasecmp(content_type,      APPLICATION_PGP2))
+      clazz = (MimeObjectClass *)&mimeInlineTextPlainClass;
+
+    else if (!PL_strcasecmp(content_type,      SUN_ATTACHMENT))
+      clazz = (MimeObjectClass *)&mimeSunAttachmentClass;
+
+    /* Everything else gets represented as a clickable link.
+    */
+    else if (!exact_match_p)
+      clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+
+    if (!mime_is_allowed_class(clazz, types_of_classes_to_disallow))
+    {
+      /* Do that check here (not after the if block), because we want to allow
+         user-installed plugins. */
+      if(!exact_match_p)
+        clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+      else
+        clazz = 0;
+    }
+  }
+
+#ifdef ENABLE_SMIME
+  // see bug #189988
+  if (opts && opts->format_out == nsMimeOutput::nsMimeMessageDecrypt &&
+       (clazz != (MimeObjectClass *)&mimeEncryptedCMSClass)) {
+    clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+  }
+#endif
+
+  if (!exact_match_p)
+    NS_ASSERTION(clazz, "1.1 <rhp@netscape.com> 19 Mar 1999 12:00");
+  if (!clazz) return 0;
+
+  NS_ASSERTION(clazz, "1.1 <rhp@netscape.com> 19 Mar 1999 12:00");
+
+  if (clazz && !clazz->class_initialized)
+  {
+    int status = mime_classinit(clazz);
+    if (status < 0) return 0;
+  }
+
+  return clazz;
+}
+
+
+MimeObject *
+mime_create (const char *content_type, MimeHeaders *hdrs,
+       MimeDisplayOptions *opts, bool forceInline /* = false */)
+{
+  /* If there is no Content-Disposition header, or if the Content-Disposition
+   is ``inline'', then we display the part inline (and let mime_find_class()
+   decide how.)
+
+   If there is any other Content-Disposition (either ``attachment'' or some
+   disposition that we don't recognise) then we always display the part as
+   an external link, by using MimeExternalObject to display it.
+
+   But Content-Disposition is ignored for all containers except `message'.
+   (including multipart/mixed, and multipart/digest.)  It's not clear if
+   this is to spec, but from a usability standpoint, I think it's necessary.
+   */
+
+  MimeObjectClass *clazz = 0;
+  char *content_disposition = 0;
+  MimeObject *obj = 0;
+  char *override_content_type = 0;
+
+  /* We've had issues where the incoming content_type is invalid, of a format:
+     content_type="=?windows-1252?q?application/pdf" (bug 659355)
+     We decided to fix that by simply trimming the stuff before the ?
+  */
+  if (content_type)
+  {
+    const char *lastQuestion = strrchr(content_type, '?');
+    if (lastQuestion)
+      content_type = lastQuestion + 1;  // the substring after the last '?'
+  }
+
+  /* There are some clients send out all attachments with a content-type
+   of application/octet-stream.  So, if we have an octet-stream attachment,
+   try to guess what type it really is based on the file extension.  I HATE
+   that we have to do this...
+  */
+  if (hdrs && opts && opts->file_type_fn &&
+
+    /* ### mwelch - don't override AppleSingle */
+    (content_type ? PL_strcasecmp(content_type, APPLICATION_APPLEFILE) : true) &&
+    /* ## davidm Apple double shouldn't use this #$%& either. */
+    (content_type ? PL_strcasecmp(content_type, MULTIPART_APPLEDOUBLE) : true) &&
+    (!content_type ||
+     !PL_strcasecmp(content_type, APPLICATION_OCTET_STREAM) ||
+     !PL_strcasecmp(content_type, UNKNOWN_CONTENT_TYPE)))
+  {
+    char *name = MimeHeaders_get_name(hdrs, opts);
+    if (name)
+    {
+      override_content_type = opts->file_type_fn (name, opts->stream_closure);
+      // appledouble isn't a valid override content type, and makes
+      // attachments invisible.
+      if (!PL_strcasecmp(override_content_type, MULTIPART_APPLEDOUBLE))
+        override_content_type = nullptr;
+      PR_FREEIF(name);
+
+      // Workaroung for saving '.eml" file encoded with base64.
+      // Do not override with message/rfc822 whenever Transfer-Encoding is
+      // base64 since base64 encoding of message/rfc822 is invalid.
+      // Our MimeMessageClass has no capability to decode it.
+      if (!PL_strcasecmp(override_content_type, MESSAGE_RFC822)) {
+        nsCString encoding;
+        encoding.Adopt(MimeHeaders_get(hdrs,
+                                       HEADER_CONTENT_TRANSFER_ENCODING,
+                                       true, false));
+        if (encoding.LowerCaseEqualsLiteral(ENCODING_BASE64))
+          override_content_type = nullptr;
+      }
+
+      // If we get here and it is not the unknown content type from the
+      // file name, let's do some better checking not to inline something bad
+      if (override_content_type &&
+          *override_content_type &&
+          (PL_strcasecmp(override_content_type, UNKNOWN_CONTENT_TYPE)))
+        content_type = override_content_type;
+    }
+  }
+
+  clazz = mime_find_class(content_type, hdrs, opts, false);
+
+  NS_ASSERTION(clazz, "1.1 <rhp@netscape.com> 19 Mar 1999 12:00");
+  if (!clazz) goto FAIL;
+
+  if (opts && opts->part_to_load)
+  /* Always ignore Content-Disposition when we're loading some specific
+     sub-part (which may be within some container that we wouldn't otherwise
+     descend into, if the container itself had a Content-Disposition of
+     `attachment'. */
+  content_disposition = 0;
+
+  else if (mime_subclass_p(clazz,(MimeObjectClass *)&mimeContainerClass) &&
+       !mime_subclass_p(clazz,(MimeObjectClass *)&mimeMessageClass))
+  /* Ignore Content-Disposition on all containers except `message'.
+     That is, Content-Disposition is ignored for multipart/mixed objects,
+     but is obeyed for message/rfc822 objects. */
+  content_disposition = 0;
+
+  else
+  {
+    /* Check to see if the plugin should override the content disposition
+       to make it appear inline. One example is a vcard which has a content
+       disposition of an "attachment;" */
+    if (force_inline_display(content_type))
+      NS_MsgSACopy(&content_disposition, "inline");
+    else
+      content_disposition = (hdrs
+                 ? MimeHeaders_get(hdrs, HEADER_CONTENT_DISPOSITION, true, false)
+                 : 0);
+  }
+
+  if (!content_disposition || !PL_strcasecmp(content_disposition, "inline"))
+    ;  /* Use the class we've got. */
+  else
+  {
+    // override messages that have content disposition set to "attachment"
+    // even though we probably should show them inline.
+    if (  (clazz != (MimeObjectClass *)&mimeInlineTextClass) &&
+          (clazz != (MimeObjectClass *)&mimeInlineTextPlainClass) &&
+          (clazz != (MimeObjectClass *)&mimeInlineTextPlainFlowedClass) &&
+          (clazz != (MimeObjectClass *)&mimeInlineTextHTMLClass) &&
+          (clazz != (MimeObjectClass *)&mimeInlineTextHTMLParsedClass) &&
+          (clazz != (MimeObjectClass *)&mimeInlineTextHTMLSanitizedClass) &&
+          (clazz != (MimeObjectClass *)&mimeInlineTextHTMLAsPlaintextClass) &&
+          (clazz != (MimeObjectClass *)&mimeInlineTextRichtextClass) &&
+          (clazz != (MimeObjectClass *)&mimeInlineTextEnrichedClass) &&
+          (clazz != (MimeObjectClass *)&mimeMessageClass) &&
+          (clazz != (MimeObjectClass *)&mimeInlineImageClass) )
+      // not a special inline type, so show as attachment
+      clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+  }
+
+  /* If the option `Show Attachments Inline' is off, now would be the time to change our mind... */
+  /* Also, if we're doing a reply (i.e. quoting the body), then treat that according to preference. */
+  if (opts && ((!opts->show_attachment_inline_p && !forceInline) ||
+               (!opts->quote_attachment_inline_p &&
+                (opts->format_out == nsMimeOutput::nsMimeMessageQuoting ||
+                 opts->format_out == nsMimeOutput::nsMimeMessageBodyQuoting))))
+  {
+    if (mime_subclass_p(clazz, (MimeObjectClass *)&mimeInlineTextClass))
+    {
+      /* It's a text type.  Write it only if it's the *first* part
+         that we're writing, and then only if it has no "filename"
+         specified (the assumption here being, if it has a filename,
+         it wasn't simply typed into the text field -- it was actually
+         an attached document.) */
+      if (opts->state && opts->state->first_part_written_p)
+        clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+      else
+      {
+        /* If there's a name, then write this as an attachment. */
+        char *name = (hdrs ? MimeHeaders_get_name(hdrs, opts) : nullptr);
+        if (name)
+        {
+          clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+          PR_Free(name);
+        }
+      }
+    }
+    else
+      if (mime_subclass_p(clazz,(MimeObjectClass *)&mimeContainerClass) &&
+           !mime_subclass_p(clazz,(MimeObjectClass *)&mimeMessageClass))
+        /* Multipart subtypes are ok, except for messages; descend into
+           multiparts, and defer judgement.
+
+           Encrypted blobs are just like other containers (make the crypto
+           layer invisible, and treat them as simple containers.  So there's
+           no easy way to save encrypted data directly to disk; it will tend
+           to always be wrapped inside a message/rfc822.  That's ok.) */
+          ;
+        else if (opts && opts->part_to_load &&
+                  mime_subclass_p(clazz,(MimeObjectClass *)&mimeMessageClass))
+          /* Descend into messages only if we're looking for a specific sub-part. */
+            ;
+          else
+          {
+            /* Anything else, and display it as a link (and cause subsequent
+               text parts to also be displayed as links.) */
+            clazz = (MimeObjectClass *)&mimeExternalObjectClass;
+          }
+  }
+
+  PR_FREEIF(content_disposition);
+  obj = mime_new (clazz, hdrs, content_type);
+
+ FAIL:
+
+  /* If we decided to ignore the content-type in the headers of this object
+   (see above) then make sure that our new content-type is stored in the
+   object itself.  (Or free it, if we're in an out-of-memory situation.)
+   */
+  if (override_content_type)
+  {
+    if (obj)
+    {
+      PR_FREEIF(obj->content_type);
+      obj->content_type = override_content_type;
+    }
+    else
+    {
+      PR_Free(override_content_type);
+    }
+  }
+
+  return obj;
+}
+
+
+
+static int mime_classinit_1(MimeObjectClass *clazz, MimeObjectClass *target);
+
+static int
+mime_classinit(MimeObjectClass *clazz)
+{
+  int status;
+  if (clazz->class_initialized)
+  return 0;
+
+  NS_ASSERTION(clazz->class_initialize, "1.1 <rhp@netscape.com> 19 Mar 1999 12:00");
+  if (!clazz->class_initialize)
+  return -1;
+
+  /* First initialize the superclass.
+   */
+  if (clazz->superclass && !clazz->superclass->class_initialized)
+  {
+    status = mime_classinit(clazz->superclass);
+    if (status < 0) return status;
+  }
+
+  /* Now run each of the superclass-init procedures in turn,
+   parentmost-first. */
+  status = mime_classinit_1(clazz, clazz);
+  if (status < 0) return status;
+
+  /* Now we're done. */
+  clazz->class_initialized = true;
+  return 0;
+}
+
+static int
+mime_classinit_1(MimeObjectClass *clazz, MimeObjectClass *target)
+{
+  int status;
+  if (clazz->superclass)
+  {
+    status = mime_classinit_1(clazz->superclass, target);
+    if (status < 0) return status;
+  }
+  return clazz->class_initialize(target);
+}
+
+
+bool
+mime_subclass_p(MimeObjectClass *child, MimeObjectClass *parent)
+{
+  if (child == parent)
+  return true;
+  else if (!child->superclass)
+  return false;
+  else
+  return mime_subclass_p(child->superclass, parent);
+}
+
+bool
+mime_typep(MimeObject *obj, MimeObjectClass *clazz)
+{
+  return mime_subclass_p(obj->clazz, clazz);
+}
+
+
+
+/* URL munging
+ */
+
+
+/* Returns a string describing the location of the part (like "2.5.3").
+   This is not a full URL, just a part-number.
+ */
+char *
+mime_part_address(MimeObject *obj)
+{
+  if (!obj->parent)
+  return strdup("0");
+  else
+  {
+    /* Find this object in its parent. */
+    int32_t i, j = -1;
+    char buf [20];
+    char *higher = 0;
+    MimeContainer *cont = (MimeContainer *) obj->parent;
+    NS_ASSERTION(mime_typep(obj->parent,
+                    (MimeObjectClass *)&mimeContainerClass), "1.1 <rhp@netscape.com> 19 Mar 1999 12:00");
+    for (i = 0; i < cont->nchildren; i++)
+    if (cont->children[i] == obj)
+      {
+      j = i+1;
+      break;
+      }
+    if (j == -1)
+    {
+      NS_ERROR("No children under MeimContainer");
+      return 0;
+    }
+
+    PR_snprintf(buf, sizeof(buf), "%ld", j);
+    if (obj->parent->parent)
+    {
+      higher = mime_part_address(obj->parent);
+      if (!higher) return 0;  /* MIME_OUT_OF_MEMORY */
+    }
+
+    if (!higher)
+    return strdup(buf);
+    else
+    {
+      uint32_t slen = strlen(higher) + strlen(buf) + 3;
+      char *s = (char *)PR_MALLOC(slen);
+      if (!s)
+      {
+        PR_Free(higher);
+        return 0;  /* MIME_OUT_OF_MEMORY */
+      }
+      PL_strncpyz(s, higher, slen);
+      PL_strcatn(s, slen, ".");
+      PL_strcatn(s, slen, buf);
+      PR_Free(higher);
+      return s;
+    }
+  }
+}
+
+
+/* Returns a string describing the location of the *IMAP* part (like "2.5.3").
+   This is not a full URL, just a part-number.
+   This part is explicitly passed in the X-Mozilla-IMAP-Part header.
+   Return value must be freed by the caller.
+ */
+char *
+mime_imap_part_address(MimeObject *obj)
+{
+  if (!obj || !obj->headers)
+    return 0;
+  else
+    return MimeHeaders_get(obj->headers, IMAP_EXTERNAL_CONTENT_HEADER, false, false);
+}
+
+/* Returns a full URL if the current mime object has a EXTERNAL_ATTACHMENT_URL_HEADER
+   header.
+   Return value must be freed by the caller.
+*/
+char *
+mime_external_attachment_url(MimeObject *obj)
+{
+  if (!obj || !obj->headers)
+    return 0;
+  else
+    return MimeHeaders_get(obj->headers, EXTERNAL_ATTACHMENT_URL_HEADER, false, false);
+}
+
+#ifdef ENABLE_SMIME
+/* Asks whether the given object is one of the cryptographically signed
+   or encrypted objects that we know about.  (MimeMessageClass uses this
+   to decide if the headers need to be presented differently.)
+ */
+bool
+mime_crypto_object_p(MimeHeaders *hdrs, bool clearsigned_counts, MimeDisplayOptions *opts)
+{
+  char *ct;
+  MimeObjectClass *clazz;
+
+  if (!hdrs) return false;
+
+  ct = MimeHeaders_get (hdrs, HEADER_CONTENT_TYPE, true, false);
+  if (!ct) return false;
+
+  /* Rough cut -- look at the string before doing a more complex comparison. */
+  if (PL_strcasecmp(ct, MULTIPART_SIGNED) &&
+    PL_strncasecmp(ct, "application/", 12))
+  {
+    PR_Free(ct);
+    return false;
+  }
+
+  /* It's a candidate for being a crypto object.  Let's find out for sure... */
+  clazz = mime_find_class(ct, hdrs, opts, true);
+  PR_Free(ct);
+
+  if (clazz == ((MimeObjectClass *)&mimeEncryptedCMSClass))
+  return true;
+  else if (clearsigned_counts &&
+       clazz == ((MimeObjectClass *)&mimeMultipartSignedCMSClass))
+  return true;
+  else
+  return false;
+}
+
+/* Whether the given object has written out the HTML version of its headers
+   in such a way that it will have a "crypto stamp" next to the headers.  If
+   this is true, then the child must write out its HTML slightly differently
+   to take this into account...
+ */
+bool
+mime_crypto_stamped_p(MimeObject *obj)
+{
+  if (!obj) return false;
+  if (mime_typep (obj, (MimeObjectClass *) &mimeMessageClass))
+  return ((MimeMessage *) obj)->crypto_stamped_p;
+  else
+  return false;
+}
+
+#endif // ENABLE_SMIME
+
+/* Puts a part-number into a URL.  If append_p is true, then the part number
+   is appended to any existing part-number already in that URL; otherwise,
+   it replaces it.
+ */
+char *
+mime_set_url_part(const char *url, const char *part, bool append_p)
+{
+  const char *part_begin = 0;
+  const char *part_end = 0;
+  bool got_q = false;
+  const char *s;
+  char *result;
+
+  if (!url || !part) return 0;
+
+  nsAutoCString urlString(url);
+  int32_t typeIndex = urlString.Find("?type=application/x-message-display");
+  if (typeIndex != -1)
+  {
+    urlString.Cut(typeIndex, sizeof("?type=application/x-message-display") - 1);
+    if (urlString.CharAt(typeIndex) == '&')
+      urlString.Replace(typeIndex, 1, '?');
+    url = urlString.get();
+  }
+
+  for (s = url; *s; s++)
+  {
+    if (*s == '?')
+    {
+      got_q = true;
+      if (!PL_strncasecmp(s, "?part=", 6))
+      part_begin = (s += 6);
+    }
+    else if (got_q && *s == '&' && !PL_strncasecmp(s, "&part=", 6))
+    part_begin = (s += 6);
+
+    if (part_begin)
+    {
+      for (; (*s && *s != '?' && *s != '&'); s++)
+      ;
+      part_end = s;
+      break;
+          }
+  }
+
+  uint32_t resultlen = strlen(url) + strlen(part) + 10;
+  result = (char *) PR_MALLOC(resultlen);
+  if (!result) return 0;
+
+  if (part_begin)
+  {
+    if (append_p)
+    {
+      memcpy(result, url, part_end - url);
+      result [part_end - url]     = '.';
+      result [part_end - url + 1] = 0;
+    }
+    else
+    {
+      memcpy(result, url, part_begin - url);
+      result [part_begin - url] = 0;
+    }
+  }
+  else
+  {
+    PL_strncpyz(result, url, resultlen);
+    if (got_q)
+    PL_strcatn(result, resultlen, "&part=");
+    else
+    PL_strcatn(result, resultlen, "?part=");
+  }
+
+  PL_strcatn(result, resultlen, part);
+
+  if (part_end && *part_end)
+  PL_strcatn(result, resultlen, part_end);
+
+  /* Semi-broken kludge to omit a trailing "?part=0". */
+  {
+  int L = strlen(result);
+  if (L > 6 &&
+    (result[L-7] == '?' || result[L-7] == '&') &&
+    !strcmp("part=0", result + L - 6))
+    result[L-7] = 0;
+  }
+
+  return result;
+}
+
+
+
+/* Puts an *IMAP* part-number into a URL.
+   Strips off any previous *IMAP* part numbers, since they are absolute, not relative.
+ */
+char *
+mime_set_url_imap_part(const char *url, const char *imappart, const char *libmimepart)
+{
+  char *result = 0;
+  char *whereCurrent = PL_strstr(url, "/;section=");
+  if (whereCurrent)
+  {
+    *whereCurrent = 0;
+  }
+
+  uint32_t resultLen = strlen(url) + strlen(imappart) + strlen(libmimepart) + 17;
+  result = (char *) PR_MALLOC(resultLen);
+  if (!result) return 0;
+
+  PL_strncpyz(result, url, resultLen);
+  PL_strcatn(result, resultLen, "/;section=");
+  PL_strcatn(result, resultLen, imappart);
+  PL_strcatn(result, resultLen, "?part=");
+  PL_strcatn(result, resultLen, libmimepart);
+
+  if (whereCurrent)
+    *whereCurrent = '/';
+
+  return result;
+}
+
+
+/* Given a part ID, looks through the MimeObject tree for a sub-part whose ID
+   number matches, and returns the MimeObject (else NULL.)
+   (part is not a URL -- it's of the form "1.3.5".)
+ */
+MimeObject *
+mime_address_to_part(const char *part, MimeObject *obj)
+{
+  /* Note: this is an N^2 operation, but the number of parts in a message
+   shouldn't ever be large enough that this really matters... */
+
+  bool match;
+
+  if (!part || !*part)
+  {
+    match = !obj->parent;
+  }
+  else
+  {
+    char *part2 = mime_part_address(obj);
+    if (!part2) return 0;  /* MIME_OUT_OF_MEMORY */
+    match = !strcmp(part, part2);
+    PR_Free(part2);
+  }
+
+  if (match)
+  {
+    /* These are the droids we're looking for. */
+    return obj;
+  }
+  else if (!mime_typep(obj, (MimeObjectClass *) &mimeContainerClass))
+  {
+    /* Not a container, pull up, pull up! */
+    return 0;
+  }
+  else
+  {
+    int32_t i;
+    MimeContainer *cont = (MimeContainer *) obj;
+    for (i = 0; i < cont->nchildren; i++)
+    {
+      MimeObject *o2 = mime_address_to_part(part, cont->children[i]);
+      if (o2) return o2;
+    }
+    return 0;
+  }
+}
+
+/* Given a part ID, looks through the MimeObject tree for a sub-part whose ID
+   number matches; if one is found, returns the Content-Name of that part.
+   Else returns NULL.  (part is not a URL -- it's of the form "1.3.5".)
+ */
+char *
+mime_find_content_type_of_part(const char *part, MimeObject *obj)
+{
+  char *result = 0;
+
+  obj = mime_address_to_part(part, obj);
+  if (!obj) return 0;
+
+  result = (obj->headers ? MimeHeaders_get(obj->headers, HEADER_CONTENT_TYPE, true, false) : 0);
+
+  return result;
+}
+
+/* Given a part ID, looks through the MimeObject tree for a sub-part whose ID
+   number matches; if one is found, returns the Content-Name of that part.
+   Else returns NULL.  (part is not a URL -- it's of the form "1.3.5".)
+ */
+char *
+mime_find_suggested_name_of_part(const char *part, MimeObject *obj)
+{
+  char *result = 0;
+
+  obj = mime_address_to_part(part, obj);
+  if (!obj) return 0;
+
+  result = (obj->headers ? MimeHeaders_get_name(obj->headers, obj->options) : 0);
+
+  /* If this part doesn't have a name, but this part is one fork of an
+   AppleDouble, and the AppleDouble itself has a name, then use that. */
+  if (!result &&
+    obj->parent &&
+    obj->parent->headers &&
+    mime_typep(obj->parent,
+         (MimeObjectClass *) &mimeMultipartAppleDoubleClass))
+  result = MimeHeaders_get_name(obj->parent->headers, obj->options);
+
+  /* Else, if this part is itself an AppleDouble, and one of its children
+   has a name, then use that (check data fork first, then resource.) */
+  if (!result &&
+    mime_typep(obj, (MimeObjectClass *) &mimeMultipartAppleDoubleClass))
+  {
+    MimeContainer *cont = (MimeContainer *) obj;
+    if (cont->nchildren > 1 &&
+      cont->children[1] &&
+      cont->children[1]->headers)
+    result = MimeHeaders_get_name(cont->children[1]->headers, obj->options);
+
+    if (!result &&
+      cont->nchildren > 0 &&
+      cont->children[0] &&
+      cont->children[0]->headers)
+    result = MimeHeaders_get_name(cont->children[0]->headers, obj->options);
+  }
+
+  /* Ok, now we have the suggested name, if any.
+   Now we remove any extensions that correspond to the
+   Content-Transfer-Encoding.  For example, if we see the headers
+
+    Content-Type: text/plain
+    Content-Disposition: inline; filename=foo.text.uue
+    Content-Transfer-Encoding: x-uuencode
+
+   then we would look up (in mime.types) the file extensions which are
+   associated with the x-uuencode encoding, find that "uue" is one of
+   them, and remove that from the end of the file name, thus returning
+   "foo.text" as the name.  This is because, by the time this file ends
+   up on disk, its content-transfer-encoding will have been removed;
+   therefore, we should suggest a file name that indicates that.
+   */
+  if (result && obj->encoding && *obj->encoding)
+  {
+    int32_t L = strlen(result);
+    const char **exts = 0;
+
+    /*
+     I'd like to ask the mime.types file, "what extensions correspond
+     to obj->encoding (which happens to be "x-uuencode") but doing that
+     in a non-sphagetti way would require brain surgery.  So, since
+     currently uuencode is the only content-transfer-encoding which we
+     understand which traditionally has an extension, we just special-
+     case it here!  Icepicks in my forehead!
+
+     Note that it's special-cased in a similar way in libmsg/compose.c.
+     */
+    if (!PL_strcasecmp(obj->encoding, ENCODING_UUENCODE))
+    {
+      static const char *uue_exts[] = { "uu", "uue", 0 };
+      exts = uue_exts;
+    }
+
+    while (exts && *exts)
+    {
+      const char *ext = *exts;
+      int32_t L2 = strlen(ext);
+      if (L > L2 + 1 &&              /* long enough */
+        result[L - L2 - 1] == '.' &&      /* '.' in right place*/
+        !PL_strcasecmp(ext, result + (L - L2)))  /* ext matches */
+      {
+        result[L - L2 - 1] = 0;    /* truncate at '.' and stop. */
+        break;
+      }
+      exts++;
+    }
+  }
+
+  return result;
+}
+
+/* Parse the various "?" options off the URL and into the options struct.
+ */
+int
+mime_parse_url_options(const char *url, MimeDisplayOptions *options)
+{
+  const char *q;
+
+  if (!url || !*url) return 0;
+  if (!options) return 0;
+
+  MimeHeadersState default_headers = options->headers;
+
+  q = PL_strrchr (url, '?');
+  if (! q) return 0;
+  q++;
+  while (*q)
+  {
+    const char *end, *value, *name_end;
+    for (end = q; *end && *end != '&'; end++)
+      ;
+    for (value = q; *value != '=' && value < end; value++)
+      ;
+    name_end = value;
+    if (value < end) value++;
+    if (name_end <= q)
+      ;
+    else if (!PL_strncasecmp ("headers", q, name_end - q))
+    {
+      if (end > value && !PL_strncasecmp ("only", value, end-value))
+        options->headers = MimeHeadersOnly;
+      else if (end > value && !PL_strncasecmp ("none", value, end-value))
+        options->headers = MimeHeadersNone;
+      else if (end > value && !PL_strncasecmp ("all", value, end - value))
+        options->headers = MimeHeadersAll;
+      else if (end > value && !PL_strncasecmp ("some", value, end - value))
+        options->headers = MimeHeadersSome;
+      else if (end > value && !PL_strncasecmp ("micro", value, end - value))
+        options->headers = MimeHeadersMicro;
+      else if (end > value && !PL_strncasecmp ("cite", value, end - value))
+        options->headers = MimeHeadersCitation;
+      else if (end > value && !PL_strncasecmp ("citation", value, end-value))
+        options->headers = MimeHeadersCitation;
+      else
+        options->headers = default_headers;
+    }
+    else if (!PL_strncasecmp ("part", q, name_end - q) &&
+      options->format_out != nsMimeOutput::nsMimeMessageBodyQuoting)
+    {
+      PR_FREEIF (options->part_to_load);
+      if (end > value)
+      {
+        options->part_to_load = (char *) PR_MALLOC(end - value + 1);
+        if (!options->part_to_load)
+          return MIME_OUT_OF_MEMORY;
+        memcpy(options->part_to_load, value, end-value);
+        options->part_to_load[end-value] = 0;
+      }
+    }
+    else if (!PL_strncasecmp ("rot13", q, name_end - q))
+    {
+      options->rot13_p = end <= value || !PL_strncasecmp ("true", value, end - value);
+    }
+    else if (!PL_strncasecmp ("emitter", q, name_end - q))
+    {
+      if ((end > value) && !PL_strncasecmp ("js", value, end - value))
+      {
+        // the js emitter needs to hear about nested message bodies
+        //  in order to build a proper representation.
+        options->notify_nested_bodies = true;
+        // show_attachment_inline_p has the side-effect of letting the
+        //  emitter see all parts of a multipart/alternative, which it
+        //  really appreciates.
+        options->show_attachment_inline_p = true;
+        // however, show_attachment_inline_p also results in a few
+        //  subclasses writing junk into the body for display purposes.
+        // put a stop to these shenanigans by enabling write_pure_bodies.
+        //  current offenders are:
+        //  - MimeInlineImage
+        options->write_pure_bodies = true;
+        // we don't actually care about the data in the attachments, just the
+        // metadata (i.e. size)
+        options->metadata_only = true;
+      }
+    }
+
+    q = end;
+    if (*q)
+      q++;
+  }
+
+
+/* Compatibility with the "?part=" syntax used in the old (Mozilla 2.0)
+   MIME parser.
+
+   Basically, the problem is that the old part-numbering code was totally
+   busted: here's a comparison of the old and new numberings with a pair
+   of hypothetical messages (one with a single part, and one with nested
+   containers.)
+   NEW:      OLD:  OR:
+   message/rfc822
+   image/jpeg           1         0     0
+
+  message/rfc822
+  multipart/mixed      1         0     0
+  text/plain         1.1       1     1
+  image/jpeg         1.2       2     2
+  message/rfc822     1.3       -     3
+  text/plain       1.3.1     3     -
+  message/rfc822     1.4       -     4
+  multipart/mixed  1.4.1     4     -
+  text/plain     1.4.1.1   4.1   -
+  image/jpeg     1.4.1.2   4.2   -
+  text/plain         1.5       5     5
+
+ The "NEW" column is how the current code counts.  The "OLD" column is
+ what "?part=" references would do in 3.0b4 and earlier; you'll see that
+ you couldn't directly refer to the child message/rfc822 objects at all!
+ But that's when it got really weird, because if you turned on
+ "Attachments As Links" (or used a URL like "?inline=false&part=...")
+ then you got a totally different numbering system (seen in the "OR"
+ column.)  Gag!
+
+ So, the problem is, ClariNet had been using these part numbers in their
+ HTML news feeds, as a sleazy way of transmitting both complex HTML layouts
+ and images using NNTP as transport, without invoking HTTP.
+
+ The following clause is to provide some small amount of backward
+ compatibility.  By looking at that table, one can see that in the new
+ model, "part=0" has no meaning, and neither does "part=2" or "part=3"
+ and so on.
+
+ "part=1" is ambiguous between the old and new way, as is any part
+ specification that has a "." in it.
+
+ So, the compatibility hack we do here is: if the part is "0", then map
+ that to "1".  And if the part is >= "2", then prepend "1." to it (so that
+ we map "2" to "1.2", and "3" to "1.3".)
+
+ This leaves the URLs compatible in the cases of:
+
+ = single part messages
+ = references to elements of a top-level multipart except the first
+
+ and leaves them incompatible for:
+
+ = the first part of a top-level multipart
+ = all elements deeper than the outermost part
+
+ Life s#$%s when you don't properly think out things that end up turning
+ into de-facto standards...
+ */
+
+ if (options->part_to_load &&
+   !PL_strchr(options->part_to_load, '.'))    /* doesn't contain a dot */
+ {
+   if (!strcmp(options->part_to_load, "0"))    /* 0 */
+   {
+     PR_Free(options->part_to_load);
+     options->part_to_load = strdup("1");
+     if (!options->part_to_load)
+       return MIME_OUT_OF_MEMORY;
+   }
+   else if (strcmp(options->part_to_load, "1"))  /* not 1 */
+   {
+     const char *prefix = "1.";
+     uint32_t slen = strlen(options->part_to_load) + strlen(prefix) + 1;
+     char *s = (char *) PR_MALLOC(slen);
+     if (!s) return MIME_OUT_OF_MEMORY;
+     PL_strncpyz(s, prefix, slen);
+     PL_strcatn(s, slen, options->part_to_load);
+     PR_Free(options->part_to_load);
+     options->part_to_load = s;
+   }
+ }
+
+  return 0;
+}
+
+
+/* Some output-generation utility functions...
+ */
+
+int
+MimeOptions_write(MimeHeaders *hdrs, MimeDisplayOptions *opt, const char *data,
+                  int32_t length, bool user_visible_p)
+{
+  int status = 0;
+  void* closure = 0;
+  if (!opt || !opt->output_fn || !opt->state)
+  return 0;
+
+  closure = opt->output_closure;
+  if (!closure) closure = opt->stream_closure;
+
+//  PR_ASSERT(opt->state->first_data_written_p);
+
+  if (opt->state->separator_queued_p && user_visible_p)
+  {
+    opt->state->separator_queued_p = false;
+    if (opt->state->separator_suppressed_p)
+      opt->state->separator_suppressed_p = false;
+    else {
+      const char *sep = "<BR><FIELDSET CLASS=\"mimeAttachmentHeader\">";
+      int lstatus = opt->output_fn(sep, strlen(sep), closure);
+      opt->state->separator_suppressed_p = false;
+      if (lstatus < 0) return lstatus;
+
+      nsCString name;
+      name.Adopt(MimeHeaders_get_name(hdrs, opt));
+      MimeHeaders_convert_header_value(opt, name, false);
+
+      if (!name.IsEmpty()) {
+          sep = "<LEGEND CLASS=\"mimeAttachmentHeaderName\">";
+          lstatus = opt->output_fn(sep, strlen(sep), closure);
+          opt->state->separator_suppressed_p = false;
+          if (lstatus < 0) return lstatus;
+
+          nsCString escapedName;
+          escapedName.Adopt(MsgEscapeHTML(name.get()));
+
+          lstatus = opt->output_fn(escapedName.get(),
+                                   escapedName.Length(), closure);
+          opt->state->separator_suppressed_p = false;
+          if (lstatus < 0) return lstatus;
+
+          sep = "</LEGEND>";
+          lstatus = opt->output_fn(sep, strlen(sep), closure);
+          opt->state->separator_suppressed_p = false;
+          if (lstatus < 0) return lstatus;
+      }
+
+      sep = "</FIELDSET><BR/>";
+      lstatus = opt->output_fn(sep, strlen(sep), closure);
+      opt->state->separator_suppressed_p = false;
+      if (lstatus < 0) return lstatus;
+    }
+  }
+  if (user_visible_p)
+  opt->state->separator_suppressed_p = false;
+
+  if (length > 0)
+  {
+    status = opt->output_fn(data, length, closure);
+    if (status < 0) return status;
+  }
+
+  return 0;
+}
+
+int
+MimeObject_write(MimeObject *obj, const char *output, int32_t length,
+         bool user_visible_p)
+{
+  if (!obj->output_p) return 0;
+
+  // if we're stripping attachments, check if any parent is not being ouput
+  if (obj->options->format_out == nsMimeOutput::nsMimeMessageAttach)
+  {
+    // if true, mime generates a separator in html - we don't want that.
+    user_visible_p = false;
+
+    for (MimeObject *parent = obj->parent; parent; parent = parent->parent)
+    {
+      if (!parent->output_p)
+        return 0;
+    }
+  }
+  if (!obj->options->state->first_data_written_p)
+  {
+    int status = MimeObject_output_init(obj, 0);
+    if (status < 0) return status;
+    NS_ASSERTION(obj->options->state->first_data_written_p, "1.1 <rhp@netscape.com> 19 Mar 1999 12:00");
+  }
+
+  return MimeOptions_write(obj->headers, obj->options, output, length, user_visible_p);
+}
+
+int
+MimeObject_write_separator(MimeObject *obj)
+{
+  if (obj->options && obj->options->state &&
+      // we never want separators if we are asking for pure bodies
+      !obj->options->write_pure_bodies)
+    obj->options->state->separator_queued_p = true;
+  return 0;
+}
+
+int
+MimeObject_output_init(MimeObject *obj, const char *content_type)
+{
+  if (obj &&
+    obj->options &&
+    obj->options->state &&
+    !obj->options->state->first_data_written_p)
+  {
+    int status;
+    const char *charset = 0;
+    char *name = 0, *x_mac_type = 0, *x_mac_creator = 0;
+
+    if (!obj->options->output_init_fn)
+    {
+      obj->options->state->first_data_written_p = true;
+      return 0;
+    }
+
+    if (obj->headers)
+    {
+      char *ct;
+      name = MimeHeaders_get_name(obj->headers, obj->options);
+
+      ct = MimeHeaders_get(obj->headers, HEADER_CONTENT_TYPE,
+                 false, false);
+      if (ct)
+      {
+        x_mac_type   = MimeHeaders_get_parameter(ct, PARAM_X_MAC_TYPE, NULL, NULL);
+        x_mac_creator= MimeHeaders_get_parameter(ct, PARAM_X_MAC_CREATOR, NULL, NULL);
+        /* if don't have a x_mac_type and x_mac_creator, we need to try to get it from its parent */
+        if (!x_mac_type && !x_mac_creator && obj->parent && obj->parent->headers)
+        {
+          char * ctp = MimeHeaders_get(obj->parent->headers, HEADER_CONTENT_TYPE, false, false);
+          if (ctp)
+          {
+            x_mac_type   = MimeHeaders_get_parameter(ctp, PARAM_X_MAC_TYPE, NULL, NULL);
+            x_mac_creator= MimeHeaders_get_parameter(ctp, PARAM_X_MAC_CREATOR, NULL, NULL);
+            PR_Free(ctp);
+          }
+        }
+
+        if (!(obj->options->override_charset)) {
+          char *charset = MimeHeaders_get_parameter(ct, "charset", nullptr, nullptr);
+          if (charset)
+          {
+            PR_FREEIF(obj->options->default_charset);
+            obj->options->default_charset = charset;
+          }
+        }
+        PR_Free(ct);
+      }
+    }
+
+    if (mime_typep(obj, (MimeObjectClass *) &mimeInlineTextClass))
+    charset = ((MimeInlineText *)obj)->charset;
+
+    if (!content_type)
+    content_type = obj->content_type;
+    if (!content_type)
+    content_type = TEXT_PLAIN;
+
+    //
+    // Set the charset on the channel we are dealing with so people know
+    // what the charset is set to. Do this for quoting/Printing ONLY!
+    //
+    extern void   ResetChannelCharset(MimeObject *obj);
+    if ( (obj->options) &&
+         ( (obj->options->format_out == nsMimeOutput::nsMimeMessageQuoting) ||
+           (obj->options->format_out == nsMimeOutput::nsMimeMessageBodyQuoting) ||
+           (obj->options->format_out == nsMimeOutput::nsMimeMessageSaveAs) ||
+           (obj->options->format_out == nsMimeOutput::nsMimeMessagePrintOutput) ) )
+      ResetChannelCharset(obj);
+
+    status = obj->options->output_init_fn (content_type, charset, name,
+                       x_mac_type, x_mac_creator,
+                       obj->options->stream_closure);
+    PR_FREEIF(name);
+    PR_FREEIF(x_mac_type);
+    PR_FREEIF(x_mac_creator);
+    obj->options->state->first_data_written_p = true;
+    return status;
+  }
+  return 0;
+}
+
+char *
+mime_get_base_url(const char *url)
+{
+  if (!url)
+    return nullptr;
+
+  const char *s = strrchr(url, '?');
+  if (s && !strncmp(s, "?type=application/x-message-display", sizeof("?type=application/x-message-display") - 1))
+  {
+    const char *nextTerm = strchr(s, '&');
+    s = (nextTerm) ? nextTerm : s + strlen(s) - 1;
+  }
+  // we need to keep the ?number part of the url, or we won't know
+  // which local message the part belongs to.
+  if (s && *s && *(s+1) && !strncmp(s + 1, "number=", sizeof("number=") - 1))
+  {
+    const char *nextTerm = strchr(++s, '&');
+    s = (nextTerm) ? nextTerm : s + strlen(s) - 1;
+  }
+  char *result = (char *) PR_MALLOC(strlen(url) + 1);
+  NS_ASSERTION(result, "out of memory");
+  if (!result)
+    return nullptr;
+
+  memcpy(result, url, s - url);
+  result[s - url] = 0;
+  return result;
+}