Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1716 insertions, 0 deletions

diff --git a/comm/mailnews/mime/src/mimei.cpp b/comm/mailnews/mime/src/mimei.cpp
new file mode 100644
index 0000000000..3001189f8e
--- /dev/null
+++ b/comm/mailnews/mime/src/mimei.cpp
@@ -0,0 +1,1716 @@
+/* -*- 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.
+ */
+
+// clang-format off
+#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 */
+// clang-format on
+
+#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 "mimemoz2.h"
+#include "nsIMimeContentTypeHandler.h"
+#include "nsICategoryManager.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"
+#include "nsIMailChannel.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 = nullptr;
+
+/*
+ * 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 = nullptr;
+  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 specific 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 specific 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 = nullptr;
+  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,
+                                  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(rdfURI);
+        if (!rdfURI.IsEmpty()) {
+          nsCOMPtr<nsIMsgDBHdr> msgHdr;
+          GetMsgDBHdrFromURI(rdfURI, 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", 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)) != nullptr) {
+#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", nullptr, nullptr);
+
+        mime_stream_data* msd = (mime_stream_data*)(opts->stream_closure);
+        nsCOMPtr<nsIMailChannel> mailChannel = do_QueryInterface(msd->channel);
+        if (mailChannel) {
+          mailChannel->SetImipMethod(
+              nsCString(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/vcard", 10) ||
+         !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 truly 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",
+                                                nullptr, nullptr)
+                    : 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, nullptr, nullptr)
+               : 0;
+        char* micalg =
+            ct ? MimeHeaders_get_parameter(ct, PARAM_MICALG, nullptr, nullptr)
+               : 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(
+              nsDependentCString(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 (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*)&mimeSuppressedCryptoClass;
+      } else {
+        char* ct =
+            hdrs ? MimeHeaders_get(hdrs, HEADER_CONTENT_TYPE, false, false)
+                 : nullptr;
+        char* st =
+            ct ? MimeHeaders_get_parameter(ct, "smime-type", nullptr, nullptr)
+               : 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);
+
+      // Workaround 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*)&mimeMessageClass) &&
+        (clazz != (MimeObjectClass*)&mimeInlineImageClass) &&
+        (!opts->show_attachment_inline_text ||
+         ((clazz != (MimeObjectClass*)&mimeInlineTextHTMLClass) &&
+          (clazz != (MimeObjectClass*)&mimeInlineTextHTMLParsedClass) &&
+          (clazz != (MimeObjectClass*)&mimeInlineTextHTMLSanitizedClass) &&
+          (clazz != (MimeObjectClass*)&mimeInlineTextHTMLAsPlaintextClass) &&
+          (clazz != (MimeObjectClass*)&mimeInlineTextRichtextClass) &&
+          (clazz != (MimeObjectClass*)&mimeInlineTextEnrichedClass) &&
+          (clazz != (MimeObjectClass*)&mimeInlineTextClass) &&
+          (clazz != (MimeObjectClass*)&mimeInlineTextPlainClass) &&
+          (clazz != (MimeObjectClass*)&mimeInlineTextPlainFlowedClass)))) {
+      // not a special inline type, so show as attachment
+      // However, mimeSuppressedCryptoClass is treated identically as
+      // mimeExternalObjectClass, let's not lose that type information.
+      if (clazz != (MimeObjectClass*)&mimeSuppressedCryptoClass) {
+        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;
+  if (!child->superclass) return false;
+  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");
+
+  /* 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);
+
+  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;
+  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;
+  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;
+
+  if (clearsigned_counts &&
+      clazz == ((MimeObjectClass*)&mimeMultipartSignedCMSClass))
+    return true;
+
+  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) {
+      while (*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;
+    end = q;
+    while (*end && *end != '&') end++;
+    value = q;
+    while (*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=\"moz-mime-attachment-header\">";
+      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=\"moz-mime-attachment-header-name\">";
+        lstatus = opt->output_fn(sep, strlen(sep), closure);
+        opt->state->separator_suppressed_p = false;
+        if (lstatus < 0) return lstatus;
+
+        nsCString escapedName;
+        nsAppendEscapedHTML(name, escapedName);
+
+        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>";
+      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 output
+  if (obj->options &&
+      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 && !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, nullptr, nullptr);
+        x_mac_creator = MimeHeaders_get_parameter(ct, PARAM_X_MAC_CREATOR,
+                                                  nullptr, nullptr);
+        /* 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,
+                                                   nullptr, nullptr);
+            x_mac_creator = MimeHeaders_get_parameter(ctp, PARAM_X_MAC_CREATOR,
+                                                      nullptr, nullptr);
+            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, '&');
+    // strlen(s) cannot be zero, because it matches the above text
+    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;
+}