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, 1060 insertions, 0 deletions

diff --git a/comm/mailnews/imap/src/nsImapBodyShell.cpp b/comm/mailnews/imap/src/nsImapBodyShell.cpp
new file mode 100644
index 0000000000..fecd4230b7
--- /dev/null
+++ b/comm/mailnews/imap/src/nsImapBodyShell.cpp
@@ -0,0 +1,1060 @@
+/* -*- 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/. */
+
+#include "msgCore.h"
+#include "nsImapBodyShell.h"
+#include "nsImapProtocol.h"
+#include "nsMimeTypes.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Logging.h"
+
+// need to talk to Rich about this...
+#define IMAP_EXTERNAL_CONTENT_HEADER "X-Mozilla-IMAP-Part"
+
+using namespace mozilla;
+extern LazyLogModule IMAPCache;  // defined in nsImapProtocol.cpp
+
+// imapbody.cpp
+// Implementation of the nsImapBodyShell and associated classes
+// These are used to parse IMAP BODYSTRUCTURE responses, and intelligently (?)
+// figure out what parts we need to display inline.
+
+/*
+   Create a nsImapBodyShell from a full BODYSTRUCUTRE response from the
+   parser.
+
+   The body shell represents a single, top-level object, the message.  The
+   message body might be treated as either a container or a leaf (just like any
+   arbitrary part).
+
+   Steps for creating a part:
+   1. Pull out the paren grouping for the part
+   2. Create a generic part object with that buffer
+   3. The factory will return either a leaf or container, depending on what
+      it really is.
+   4. It is responsible for parsing its children, if there are any
+*/
+
+///////////// nsImapBodyShell ////////////////////////////////////
+
+NS_IMPL_ISUPPORTS0(nsImapBodyShell)
+
+nsImapBodyShell::nsImapBodyShell(nsIMAPBodypartMessage* message, uint32_t UID,
+                                 uint32_t UIDValidity, const char* folderName,
+                                 bool showAttachmentsInline)
+    : m_message(message),
+      m_isValid(false),
+      m_folderName(folderName),
+      m_generatingPart(nullptr),
+      m_isBeingGenerated(false),
+      m_cached(false),
+      m_generatingWholeMessage(false),
+      m_contentModified(IMAP_ContentModifiedType::IMAP_CONTENT_NOT_MODIFIED) {
+  m_UID = "";
+  m_UID.AppendInt(UID);
+  m_UID_validity = m_UID;
+  m_UID_validity.AppendInt(UIDValidity);
+
+  m_contentModified = showAttachmentsInline
+                          ? IMAP_CONTENT_MODIFIED_VIEW_INLINE
+                          : IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS;
+
+  SetIsValid(m_message != nullptr);
+}
+
+nsImapBodyShell::~nsImapBodyShell() {
+  delete m_message;
+  m_prefetchQueue.Clear();
+}
+
+void nsImapBodyShell::SetIsValid(bool valid) { m_isValid = valid; }
+
+// Fills in buffer (and adopts storage) for header object
+void nsImapBodyShell::AdoptMessageHeaders(char* headers, const char* partNum) {
+  if (!GetIsValid()) return;
+
+  if (!partNum) partNum = "0";
+
+  // we are going to say that a message header object only has
+  // part data, and no header data.
+  nsIMAPBodypart* foundPart = m_message->FindPartWithNumber(partNum);
+  if (foundPart) {
+    nsIMAPBodypartMessage* messageObj = foundPart->GetnsIMAPBodypartMessage();
+    if (messageObj) {
+      messageObj->AdoptMessageHeaders(headers);
+      if (!messageObj->GetIsValid()) SetIsValid(false);
+    } else {
+      // We were filling in message headers for a given part number.
+      // We looked up that part number, found an object, but it
+      // wasn't of type message/rfc822.
+      // Something's wrong.
+      NS_ASSERTION(false, "object not of type message rfc822");
+    }
+  } else
+    SetIsValid(false);
+}
+
+// Fills in buffer (and adopts storage) for MIME headers in appropriate object.
+// If object can't be found, sets isValid to false.
+void nsImapBodyShell::AdoptMimeHeader(const char* partNum, char* mimeHeader) {
+  if (!GetIsValid()) return;
+
+  NS_ASSERTION(partNum, "null partnum in body shell");
+
+  nsIMAPBodypart* foundPart = m_message->FindPartWithNumber(partNum);
+
+  if (foundPart) {
+    foundPart->AdoptHeaderDataBuffer(mimeHeader);
+    if (!foundPart->GetIsValid()) SetIsValid(false);
+  } else {
+    SetIsValid(false);
+  }
+}
+
+void nsImapBodyShell::AddPrefetchToQueue(nsIMAPeFetchFields fields,
+                                         const char* partNumber) {
+  nsIMAPMessagePartID newPart(fields, partNumber);
+  m_prefetchQueue.AppendElement(newPart);
+}
+
+// Requires that the shell is valid when called
+// Performs a preflight check on all message parts to see if they are all
+// inline.  Returns true if all parts are inline, false otherwise.
+bool nsImapBodyShell::PreflightCheckAllInline() {
+  bool rv = m_message->PreflightCheckAllInline(this);
+  //  if (rv)
+  //    MOZ_LOG(IMAP, out, ("BODYSHELL: All parts inline.  Reverting to whole
+  //    message download."));
+  return rv;
+}
+
+// When partNum is NULL, Generates a whole message and intelligently
+// leaves out parts that are not inline.
+
+// When partNum is not NULL, Generates a MIME part that hasn't been downloaded
+// yet Ok, here's how we're going to do this.  Essentially, this will be the
+// mirror image of the "normal" generation. All parts will be left out except a
+// single part which is explicitly specified.  All relevant headers will be
+// included. Libmime will extract only the part of interest, so we don't have to
+// worry about the other parts.  This also has the advantage that it looks like
+// it will be more workable for nested parts.  For instance, if a user clicks on
+// a link to a forwarded message, then that forwarded message may be generated
+// along with any images that the forwarded message contains, for instance.
+
+int32_t nsImapBodyShell::Generate(nsImapProtocol* conn, char* partNum) {
+  // Hold the connection in existence for the duration.
+  RefPtr<nsImapProtocol> kungFuDeathGrip(conn);
+
+  m_isBeingGenerated = true;
+  m_generatingPart = partNum;
+  int32_t contentLength = 0;
+
+  if (!GetIsValid() || PreflightCheckAllInline()) {
+    // We don't have a valid shell, or all parts are going to be inline anyway.
+    // Fall back to fetching the whole message.
+#ifdef DEBUG_chrisf
+    NS_ASSERTION(GetIsValid());
+#endif
+    m_generatingWholeMessage = true;
+    uint32_t messageSize = conn->GetMessageSize(GetUID());
+    MOZ_LOG(IMAPCache, LogLevel::Debug,
+            ("Generate(): Set IMAP_CONTENT_NOT MODIFIED"));
+    // So that when we cache it, we know we have the whole message.
+    conn->SetContentModified(IMAP_CONTENT_NOT_MODIFIED);
+    if (!conn->DeathSignalReceived())
+      conn->FallbackToFetchWholeMsg(GetUID(), messageSize);
+    contentLength = (int32_t)messageSize;  // ugh
+  } else {
+    // We have a valid shell.
+    bool streamCreated = false;
+    m_generatingWholeMessage = false;
+
+    ////// PASS 1 : PREFETCH ///////
+    // First, prefetch any additional headers/data that we need
+    if (!conn->GetPseudoInterrupted())
+      m_message->Generate(
+          this, conn, false,
+          true);  // This queues up everything we need to prefetch
+    // Now, run a single pipelined prefetch  (neato!)
+    conn->PipelinedFetchMessageParts(GetUID(), m_prefetchQueue);
+    m_prefetchQueue.Clear();
+
+    ////// PASS 2 : COMPUTE STREAM SIZE ///////
+    // Next, figure out the size from the parts that we're going to fill in,
+    // plus all of the MIME headers, plus the message header itself
+    if (!conn->GetPseudoInterrupted())
+      contentLength = m_message->Generate(this, conn, false, false);
+
+    // Setup the stream
+    if (!conn->GetPseudoInterrupted() && !conn->DeathSignalReceived()) {
+      nsresult rv = conn->BeginMessageDownLoad(contentLength, MESSAGE_RFC822);
+      if (NS_FAILED(rv)) {
+        m_generatingPart = nullptr;
+        conn->AbortMessageDownLoad();
+        return 0;
+      }
+      streamCreated = true;
+    }
+
+    ////// PASS 3 : GENERATE ///////
+    // Generate the message
+    if (!conn->GetPseudoInterrupted() && !conn->DeathSignalReceived())
+      m_message->Generate(this, conn, true, false);
+
+    // Close the stream here - normal.  If pseudointerrupted, the connection
+    // will abort the download stream
+    if (!conn->GetPseudoInterrupted() && !conn->DeathSignalReceived())
+      conn->NormalMessageEndDownload();
+    else if (streamCreated)
+      conn->AbortMessageDownLoad();
+
+    m_generatingPart = NULL;
+  }
+
+  m_isBeingGenerated = false;
+  return contentLength;
+}
+
+///////////// nsIMAPBodypart ////////////////////////////////////
+
+nsIMAPBodypart::nsIMAPBodypart(char* partNumber, nsIMAPBodypart* parentPart) {
+  SetIsValid(true);
+  m_parentPart = parentPart;
+  m_partNumberString = partNumber;  // storage adopted
+  m_partData = NULL;
+  m_headerData = NULL;
+  m_boundaryData = NULL;  // initialize from parsed BODYSTRUCTURE
+  m_contentLength = 0;
+  m_partLength = 0;
+
+  m_contentType = NULL;
+  m_bodyType = NULL;
+  m_bodySubType = NULL;
+  m_bodyID = NULL;
+  m_bodyDescription = NULL;
+  m_bodyEncoding = NULL;
+}
+
+nsIMAPBodypart::~nsIMAPBodypart() {
+  PR_FREEIF(m_partNumberString);
+  PR_FREEIF(m_contentType);
+  PR_FREEIF(m_bodyType);
+  PR_FREEIF(m_bodySubType);
+  PR_FREEIF(m_bodyID);
+  PR_FREEIF(m_bodyDescription);
+  PR_FREEIF(m_bodyEncoding);
+  PR_FREEIF(m_partData);
+  PR_FREEIF(m_headerData);
+  PR_FREEIF(m_boundaryData);
+}
+
+void nsIMAPBodypart::SetIsValid(bool valid) {
+  m_isValid = valid;
+  if (!m_isValid) {
+    // MOZ_LOG(IMAP, out, ("BODYSHELL: Part is invalid.  Part Number: %s
+    // Content-Type: %s", m_partNumberString, m_contentType));
+  }
+}
+
+// Adopts storage for part data buffer.  If NULL, sets isValid to false.
+void nsIMAPBodypart::AdoptPartDataBuffer(char* buf) {
+  m_partData = buf;
+  if (!m_partData) {
+    SetIsValid(false);
+  }
+}
+
+// Adopts storage for header data buffer.  If NULL, sets isValid to false.
+void nsIMAPBodypart::AdoptHeaderDataBuffer(char* buf) {
+  m_headerData = buf;
+  if (!m_headerData) {
+    SetIsValid(false);
+  }
+}
+
+// Finds the part with given part number
+// Returns a nsIMAPBodystructure of the matched part if it is this
+// or one of its children.  Returns NULL otherwise.
+nsIMAPBodypart* nsIMAPBodypart::FindPartWithNumber(const char* partNum) {
+  // either brute force, or do it the smart way - look at the number.
+  // (the parts should be ordered, and hopefully indexed by their number)
+
+  if (m_partNumberString && !PL_strcasecmp(partNum, m_partNumberString))
+    return this;
+
+  // if (!m_partNumberString && !PL_strcasecmp(partNum, "1"))
+  //   return this;
+
+  return NULL;
+}
+
+void nsIMAPBodypart::QueuePrefetchMIMEHeader(nsImapBodyShell* aShell) {
+  aShell->AddPrefetchToQueue(kMIMEHeader, m_partNumberString);
+}
+
+int32_t nsIMAPBodypart::GenerateMIMEHeader(nsImapBodyShell* aShell,
+                                           nsImapProtocol* conn, bool stream,
+                                           bool prefetch) {
+  if (prefetch && !m_headerData) {
+    QueuePrefetchMIMEHeader(aShell);
+    return 0;
+  }
+  if (m_headerData) {
+    int32_t mimeHeaderLength = 0;
+
+    if (!ShouldFetchInline(aShell)) {
+      // if this part isn't inline, add the X-Mozilla-IMAP-Part header
+      char* xPartHeader = PR_smprintf("%s: %s", IMAP_EXTERNAL_CONTENT_HEADER,
+                                      m_partNumberString);
+      if (xPartHeader) {
+        if (stream) {
+          conn->Log("SHELL", "GENERATE-XHeader", m_partNumberString);
+          conn->HandleMessageDownLoadLine(xPartHeader, false);
+        }
+        mimeHeaderLength += PL_strlen(xPartHeader);
+        PR_Free(xPartHeader);
+      }
+    }
+
+    mimeHeaderLength += PL_strlen(m_headerData);
+    if (stream) {
+      conn->Log("SHELL", "GENERATE-MIMEHeader", m_partNumberString);
+      conn->HandleMessageDownLoadLine(m_headerData,
+                                      false);  // all one line?  Can we do that?
+    }
+
+    return mimeHeaderLength;
+  }
+
+  SetIsValid(false);  // prefetch didn't adopt a MIME header
+  return 0;
+}
+
+int32_t nsIMAPBodypart::GeneratePart(nsImapBodyShell* aShell,
+                                     nsImapProtocol* conn, bool stream,
+                                     bool prefetch) {
+  if (prefetch) return 0;  // don't need to prefetch anything
+
+  if (m_partData)  // we have prefetched the part data
+  {
+    if (stream) {
+      conn->Log("SHELL", "GENERATE-Part-Prefetched", m_partNumberString);
+      conn->HandleMessageDownLoadLine(m_partData, false);
+    }
+    return PL_strlen(m_partData);
+  }
+
+  // we are fetching and streaming this part's body as we go
+  if (stream && !conn->DeathSignalReceived()) {
+    char* generatingPart = aShell->GetGeneratingPart();
+    bool fetchingSpecificPart =
+        (generatingPart && !PL_strcmp(generatingPart, m_partNumberString));
+
+    conn->Log("SHELL", "GENERATE-Part-Inline", m_partNumberString);
+    MOZ_LOG(IMAPCache, LogLevel::Debug,
+            ("GeneratePart(): Call FetchTryChunking() part length=%" PRIi32
+             ", part number=%s",
+             m_partLength, m_partNumberString));
+    conn->FetchTryChunking(aShell->GetUID(), kMIMEPart, true,
+                           m_partNumberString, m_partLength,
+                           !fetchingSpecificPart);
+  }
+  return m_partLength;  // the part length has been filled in from the
+                        // BODYSTRUCTURE response
+}
+
+int32_t nsIMAPBodypart::GenerateBoundary(nsImapBodyShell* aShell,
+                                         nsImapProtocol* conn, bool stream,
+                                         bool prefetch, bool lastBoundary) {
+  if (prefetch) return 0;  // don't need to prefetch anything
+
+  if (m_boundaryData) {
+    if (!lastBoundary) {
+      if (stream) {
+        conn->Log("SHELL", "GENERATE-Boundary", m_partNumberString);
+        conn->HandleMessageDownLoadLine(m_boundaryData, false);
+      }
+      return PL_strlen(m_boundaryData);
+    }
+
+    // the last boundary
+    char* lastBoundaryData = PR_smprintf("%s--", m_boundaryData);
+    if (lastBoundaryData) {
+      if (stream) {
+        conn->Log("SHELL", "GENERATE-Boundary-Last", m_partNumberString);
+        conn->HandleMessageDownLoadLine(lastBoundaryData, false);
+      }
+      int32_t rv = PL_strlen(lastBoundaryData);
+      PR_Free(lastBoundaryData);
+      return rv;
+    }
+    // HandleMemoryFailure();
+    return 0;
+  }
+  return 0;
+}
+
+int32_t nsIMAPBodypart::GenerateEmptyFilling(nsImapBodyShell* aShell,
+                                             nsImapProtocol* conn, bool stream,
+                                             bool prefetch) {
+  if (prefetch) return 0;  // don't need to prefetch anything
+
+  const nsString& emptyString = conn->GetEmptyMimePartString();
+  if (!emptyString.IsEmpty()) {
+    if (stream) {
+      conn->Log("SHELL", "GENERATE-Filling", m_partNumberString);
+      conn->HandleMessageDownLoadLine(NS_ConvertUTF16toUTF8(emptyString).get(),
+                                      false);
+    }
+    return emptyString.Length();
+  }
+  return 0;
+}
+
+// Returns true if the prefs say that this content type should
+// explicitly be kept in when filling in the shell
+bool nsIMAPBodypart::ShouldExplicitlyFetchInline() { return false; }
+
+// Returns true if the prefs say that this content type should
+// explicitly be left out when filling in the shell
+bool nsIMAPBodypart::ShouldExplicitlyNotFetchInline() { return false; }
+
+///////////// nsIMAPBodypartLeaf /////////////////////////////
+
+nsIMAPBodypartLeaf::nsIMAPBodypartLeaf(char* partNum,
+                                       nsIMAPBodypart* parentPart,
+                                       char* bodyType, char* bodySubType,
+                                       char* bodyID, char* bodyDescription,
+                                       char* bodyEncoding, int32_t partLength,
+                                       bool preferPlainText)
+    : nsIMAPBodypart(partNum, parentPart), mPreferPlainText(preferPlainText) {
+  m_bodyType = bodyType;
+  m_bodySubType = bodySubType;
+  m_bodyID = bodyID;
+  m_bodyDescription = bodyDescription;
+  m_bodyEncoding = bodyEncoding;
+  m_partLength = partLength;
+  if (m_bodyType && m_bodySubType) {
+    m_contentType = PR_smprintf("%s/%s", m_bodyType, m_bodySubType);
+  }
+  SetIsValid(true);
+}
+
+nsIMAPBodypartType nsIMAPBodypartLeaf::GetType() { return IMAP_BODY_LEAF; }
+
+int32_t nsIMAPBodypartLeaf::Generate(nsImapBodyShell* aShell,
+                                     nsImapProtocol* conn, bool stream,
+                                     bool prefetch) {
+  int32_t len = 0;
+
+  if (GetIsValid()) {
+    if (stream && !prefetch)
+      conn->Log("SHELL", "GENERATE-Leaf", m_partNumberString);
+
+    // Stream out the MIME part boundary
+    // GenerateBoundary();
+    NS_ASSERTION(m_parentPart, "part has no parent");
+    // nsIMAPBodypartMessage *parentMessage = m_parentPart ?
+    // m_parentPart->GetnsIMAPBodypartMessage() : NULL;
+
+    // Stream out the MIME header of this part, if this isn't the only body part
+    // of a message
+    // if (parentMessage ? !parentMessage->GetIsTopLevelMessage() : true)
+    if ((m_parentPart->GetType() != IMAP_BODY_MESSAGE_RFC822) &&
+        !conn->GetPseudoInterrupted())
+      len += GenerateMIMEHeader(aShell, conn, stream, prefetch);
+
+    if (!conn->GetPseudoInterrupted()) {
+      if (ShouldFetchInline(aShell)) {
+        // Fetch and stream the content of this part
+        len += GeneratePart(aShell, conn, stream, prefetch);
+      } else {
+        // fill in the filling within the empty part
+        len += GenerateEmptyFilling(aShell, conn, stream, prefetch);
+      }
+    }
+  }
+  m_contentLength = len;
+  return m_contentLength;
+}
+
+// returns true if this part should be fetched inline for generation.
+bool nsIMAPBodypartLeaf::ShouldFetchInline(nsImapBodyShell* aShell) {
+  char* generatingPart = aShell->GetGeneratingPart();
+  if (generatingPart) {
+    // If we are generating a specific part
+    if (!PL_strcmp(generatingPart, m_partNumberString)) {
+      // This is the part we're generating
+      return true;
+    }
+
+    // If this is the only body part of a message, and that
+    // message is the part being generated, then this leaf should
+    // be inline as well.
+    if ((m_parentPart->GetType() == IMAP_BODY_MESSAGE_RFC822) &&
+        (!PL_strcmp(m_parentPart->GetPartNumberString(), generatingPart)))
+      return true;
+
+    // The parent of this part is a multipart
+    if (m_parentPart->GetType() == IMAP_BODY_MULTIPART) {
+      // This is the first text part of a forwarded message
+      // with a multipart body, and that message is being generated,
+      // then generate this part.
+      nsIMAPBodypart* grandParent = m_parentPart->GetParentPart();
+      // grandParent must exist, since multiparts need parents
+      NS_ASSERTION(grandParent, "grandparent doesn't exist for multi-part alt");
+      if (grandParent && (grandParent->GetType() == IMAP_BODY_MESSAGE_RFC822) &&
+          (!PL_strcmp(grandParent->GetPartNumberString(), generatingPart)) &&
+          (m_partNumberString[PL_strlen(m_partNumberString) - 1] == '1') &&
+          !PL_strcasecmp(m_bodyType, "text"))
+        return true;  // we're downloading it inline
+
+      // This is a child of a multipart/appledouble attachment,
+      // and that multipart/appledouble attachment is being generated
+      if (!PL_strcasecmp(m_parentPart->GetBodySubType(), "appledouble") &&
+          !PL_strcmp(m_parentPart->GetPartNumberString(), generatingPart))
+        return true;  // we're downloading it inline
+    }
+
+    // Leave out all other leaves if this isn't the one
+    // we're generating.
+    // Maybe change later to check parents, etc.
+    return false;
+  }
+
+  // We are generating the whole message, possibly (hopefully)
+  // leaving out non-inline parts
+  if (ShouldExplicitlyFetchInline()) return true;
+  if (ShouldExplicitlyNotFetchInline()) return false;
+
+  // If the parent is a message (this is the only body part of that
+  // message), and that message should be inline, then its body
+  // should inherit the inline characteristics of that message
+  if (m_parentPart->GetType() == IMAP_BODY_MESSAGE_RFC822)
+    return m_parentPart->ShouldFetchInline(aShell);
+
+  // View Attachments As Links is on.
+  if (!(aShell->GetContentModified() == IMAP_CONTENT_MODIFIED_VIEW_INLINE)) {
+    // The last text part is still displayed inline,
+    // even if View Attachments As Links is on.
+    nsIMAPBodypart* grandParentPart = m_parentPart->GetParentPart();
+    if ((mPreferPlainText ||
+         !PL_strcasecmp(m_parentPart->GetBodySubType(), "mixed")) &&
+        !PL_strcmp(m_partNumberString, "1") &&
+        !PL_strcasecmp(m_bodyType, "text"))
+      return true;  // we're downloading it inline
+
+    if ((!PL_strcasecmp(m_parentPart->GetBodySubType(), "alternative") ||
+         (grandParentPart &&
+          !PL_strcasecmp(grandParentPart->GetBodySubType(), "alternative"))) &&
+        !PL_strcasecmp(m_bodyType, "text") &&
+        ((!PL_strcasecmp(m_bodySubType, "plain") && mPreferPlainText) ||
+         (!PL_strcasecmp(m_bodySubType, "html") && !mPreferPlainText)))
+      return true;
+
+    // This is the first text part of a top-level multipart.
+    // For instance, a message with multipart body, where the first
+    // part is multipart, and this is the first leaf of that first part.
+    if (m_parentPart->GetType() == IMAP_BODY_MULTIPART &&
+        (PL_strlen(m_partNumberString) >= 2) &&
+        !PL_strcmp(m_partNumberString + PL_strlen(m_partNumberString) - 2,
+                   ".1") &&  // this is the first text type on this level
+        (!PL_strcmp(m_parentPart->GetPartNumberString(), "1") ||
+         !PL_strcmp(m_parentPart->GetPartNumberString(), "2")) &&
+        !PL_strcasecmp(m_bodyType, "text"))
+      return true;
+    // This is the first text part of a top-level multipart of the
+    // toplevelmessage This 'assumes' the text body is first leaf. This is not
+    // required for valid email. The only other way is to get
+    // content-disposition = attachment and exclude those text parts.
+    if (m_parentPart->GetType() == IMAP_BODY_MULTIPART &&
+        !PL_strcasecmp(m_bodyType, "text") &&
+        !PL_strcmp(m_parentPart->GetPartNumberString(), "0") &&
+        !PL_strcmp(m_partNumberString, "1"))
+      return true;
+
+    // we may have future problems needing tests here
+
+    return false;  // we can leave it on the server
+  }
+#ifdef XP_MACOSX
+  // If it is either applesingle, or a resource fork for appledouble
+  if (!PL_strcasecmp(m_contentType, "application/applefile")) {
+    // if it is appledouble
+    if (m_parentPart->GetType() == IMAP_BODY_MULTIPART &&
+        !PL_strcasecmp(m_parentPart->GetBodySubType(), "appledouble")) {
+      // This is the resource fork of a multipart/appledouble.
+      // We inherit the inline attributes of the parent,
+      // which was derived from its OTHER child.  (The data fork.)
+      return m_parentPart->ShouldFetchInline(aShell);
+    }
+    // it is applesingle
+    return false;  // we can leave it on the server
+  }
+#endif  // XP_MACOSX
+
+  // Fetch type APPLICATION now if the subtype is a signature or if it's an
+  // octet-stream. Otherwise, fetch on demand.
+  if (!PL_strcasecmp(m_bodyType, "APPLICATION") &&
+      PL_strncasecmp(m_bodySubType, "x-pkcs7", 7) &&
+      PL_strcasecmp(m_bodySubType, "octet-stream"))
+    return false;  // we can leave it on the server
+  if (!PL_strcasecmp(m_bodyType, "AUDIO")) return false;
+  // Here's where we can add some more intelligence -- let's leave out
+  // any other parts that we know we can't display inline.
+  return true;  // we're downloading it inline
+}
+
+bool nsIMAPBodypartMultipart::IsLastTextPart(const char* partNumberString) {
+  // iterate backwards over the parent's part list and if the part is
+  // text, compare it to the part number string
+  for (int i = m_partList.Length() - 1; i >= 0; i--) {
+    nsIMAPBodypart* part = m_partList[i];
+    if (!PL_strcasecmp(part->GetBodyType(), "text"))
+      return !PL_strcasecmp(part->GetPartNumberString(), partNumberString);
+  }
+  return false;
+}
+
+bool nsIMAPBodypartLeaf::PreflightCheckAllInline(nsImapBodyShell* aShell) {
+  // only need to check this part, since it has no children.
+  return ShouldFetchInline(aShell);
+}
+
+///////////// nsIMAPBodypartMessage ////////////////////////
+
+nsIMAPBodypartMessage::nsIMAPBodypartMessage(
+    char* partNum, nsIMAPBodypart* parentPart, bool topLevelMessage,
+    char* bodyType, char* bodySubType, char* bodyID, char* bodyDescription,
+    char* bodyEncoding, int32_t partLength, bool preferPlainText)
+    : nsIMAPBodypartLeaf(partNum, parentPart, bodyType, bodySubType, bodyID,
+                         bodyDescription, bodyEncoding, partLength,
+                         preferPlainText) {
+  m_topLevelMessage = topLevelMessage;
+  if (m_topLevelMessage) {
+    m_partNumberString = PR_smprintf("0");
+    if (!m_partNumberString) {
+      SetIsValid(false);
+      return;
+    }
+  }
+  m_body = NULL;
+  m_headers = new nsIMAPMessageHeaders(
+      m_partNumberString, this);  // We always have a Headers object
+  if (!m_headers || !m_headers->GetIsValid()) {
+    SetIsValid(false);
+    return;
+  }
+  SetIsValid(true);
+}
+
+void nsIMAPBodypartMessage::SetBody(nsIMAPBodypart* body) {
+  if (m_body) delete m_body;
+  m_body = body;
+}
+
+nsIMAPBodypartType nsIMAPBodypartMessage::GetType() {
+  return IMAP_BODY_MESSAGE_RFC822;
+}
+
+nsIMAPBodypartMessage::~nsIMAPBodypartMessage() {
+  delete m_headers;
+  delete m_body;
+}
+
+int32_t nsIMAPBodypartMessage::Generate(nsImapBodyShell* aShell,
+                                        nsImapProtocol* conn, bool stream,
+                                        bool prefetch) {
+  if (!GetIsValid()) return 0;
+
+  m_contentLength = 0;
+
+  if (stream && !prefetch)
+    conn->Log("SHELL", "GENERATE-MessageRFC822", m_partNumberString);
+
+  if (!m_topLevelMessage &&
+      !conn->GetPseudoInterrupted())  // not the top-level message - we need
+                                      // the MIME header as well as the
+                                      // message header
+  {
+    // but we don't need the MIME headers of a message/rfc822 part if this
+    // content type is in (part of) the main msg header. In other words, we
+    // still need these MIME headers if this message/rfc822 body part is
+    // enclosed in the msg body (most likely as a body part of a multipart/mixed
+    // msg).
+    //       Don't fetch (bug 128888)              Do fetch (bug 168097)
+    //  ----------------------------------  -----------------------------------
+    //  message/rfc822  (parent part)       message/rfc822
+    //   message/rfc822 <<<---               multipart/mixed  (parent part)
+    //    multipart/mixed                     message/rfc822  <<<---
+    //     text/html   (body text)             multipart/mixed
+    //     text/plain  (attachment)             text/html   (body text)
+    //     application/msword (attachment)      text/plain  (attachment)
+    //                                          application/msword (attachment)
+    // "<<<---" points to the part we're examining here.
+    if (PL_strcasecmp(m_bodyType, "message") ||
+        PL_strcasecmp(m_bodySubType, "rfc822") ||
+        PL_strcasecmp(m_parentPart->GetBodyType(), "message") ||
+        PL_strcasecmp(m_parentPart->GetBodySubType(), "rfc822"))
+      m_contentLength += GenerateMIMEHeader(aShell, conn, stream, prefetch);
+  }
+
+  if (!conn->GetPseudoInterrupted())
+    m_contentLength += m_headers->Generate(aShell, conn, stream, prefetch);
+  if (!conn->GetPseudoInterrupted())
+    m_contentLength += m_body->Generate(aShell, conn, stream, prefetch);
+
+  return m_contentLength;
+}
+
+bool nsIMAPBodypartMessage::ShouldFetchInline(nsImapBodyShell* aShell) {
+  if (m_topLevelMessage)  // the main message should always be defined as
+                          // "inline"
+    return true;
+
+  char* generatingPart = aShell->GetGeneratingPart();
+  if (generatingPart) {
+    // If we are generating a specific part
+    // Always generate containers (just don't fill them in)
+    // because it is low cost (everything is cached)
+    // and it gives the message its full MIME structure,
+    // to avoid any potential mishap.
+    return true;
+  }
+
+  // Generating whole message
+  if (ShouldExplicitlyFetchInline()) return true;
+  if (ShouldExplicitlyNotFetchInline()) return false;
+
+  // Message types are inline, by default.
+  return true;
+}
+
+bool nsIMAPBodypartMessage::PreflightCheckAllInline(nsImapBodyShell* aShell) {
+  if (!ShouldFetchInline(aShell)) return false;
+
+  return m_body->PreflightCheckAllInline(aShell);
+}
+
+// Fills in buffer (and adopts storage) for header object
+void nsIMAPBodypartMessage::AdoptMessageHeaders(char* headers) {
+  if (!GetIsValid()) return;
+
+  // we are going to say that the message headers only have
+  // part data, and no header data.
+  m_headers->AdoptPartDataBuffer(headers);
+  if (!m_headers->GetIsValid()) SetIsValid(false);
+}
+
+// Finds the part with given part number
+// Returns a nsIMAPBodystructure of the matched part if it is this
+// or one of its children.  Returns NULL otherwise.
+nsIMAPBodypart* nsIMAPBodypartMessage::FindPartWithNumber(const char* partNum) {
+  // either brute force, or do it the smart way - look at the number.
+  // (the parts should be ordered, and hopefully indexed by their number)
+
+  if (!PL_strcasecmp(partNum, m_partNumberString)) return this;
+
+  return m_body->FindPartWithNumber(partNum);
+}
+
+///////////// nsIMAPBodypartMultipart ////////////////////////
+
+nsIMAPBodypartMultipart::nsIMAPBodypartMultipart(char* partNum,
+                                                 nsIMAPBodypart* parentPart)
+    : nsIMAPBodypart(partNum, parentPart) {
+  if (!m_parentPart || (m_parentPart->GetType() == IMAP_BODY_MESSAGE_RFC822)) {
+    // the multipart (this) will inherit the part number of its parent
+    PR_FREEIF(m_partNumberString);
+    if (!m_parentPart) {
+      m_partNumberString = PR_smprintf("0");
+    } else
+      m_partNumberString = NS_xstrdup(m_parentPart->GetPartNumberString());
+  }
+  m_bodyType = NS_xstrdup("multipart");
+  if (m_parentPart && m_bodyType)
+    SetIsValid(true);
+  else
+    SetIsValid(false);
+}
+
+nsIMAPBodypartType nsIMAPBodypartMultipart::GetType() {
+  return IMAP_BODY_MULTIPART;
+}
+
+nsIMAPBodypartMultipart::~nsIMAPBodypartMultipart() {
+  for (int i = m_partList.Length() - 1; i >= 0; i--) {
+    delete m_partList[i];
+  }
+}
+
+void nsIMAPBodypartMultipart::SetBodySubType(char* bodySubType) {
+  PR_FREEIF(m_bodySubType);
+  PR_FREEIF(m_contentType);
+  m_bodySubType = bodySubType;
+  if (m_bodyType && m_bodySubType)
+    m_contentType = PR_smprintf("%s/%s", m_bodyType, m_bodySubType);
+}
+
+int32_t nsIMAPBodypartMultipart::Generate(nsImapBodyShell* aShell,
+                                          nsImapProtocol* conn, bool stream,
+                                          bool prefetch) {
+  int32_t len = 0;
+
+  if (GetIsValid()) {
+    if (stream && !prefetch)
+      conn->Log("SHELL", "GENERATE-Multipart", m_partNumberString);
+
+    // Stream out the MIME header of this part
+
+    bool parentIsMessageType =
+        GetParentPart()
+            ? (GetParentPart()->GetType() == IMAP_BODY_MESSAGE_RFC822)
+            : true;
+
+    // If this is multipart/signed, then we always want to generate the MIME
+    // headers of this multipart. Otherwise, we only want to do it if the parent
+    // is not of type "message"
+    bool needMIMEHeader =
+        !parentIsMessageType;  // !PL_strcasecmp(m_bodySubType, "signed") ? true
+                               // : !parentIsMessageType;
+    if (needMIMEHeader &&
+        !conn->GetPseudoInterrupted())  // not a message body's type
+    {
+      len += GenerateMIMEHeader(aShell, conn, stream, prefetch);
+    }
+
+    if (ShouldFetchInline(aShell)) {
+      for (auto part : m_partList) {
+        if (!conn->GetPseudoInterrupted())
+          len += GenerateBoundary(aShell, conn, stream, prefetch, false);
+        if (!conn->GetPseudoInterrupted())
+          len += part->Generate(aShell, conn, stream, prefetch);
+      }
+      if (!conn->GetPseudoInterrupted())
+        len += GenerateBoundary(aShell, conn, stream, prefetch, true);
+    } else {
+      // fill in the filling within the empty part
+      if (!conn->GetPseudoInterrupted())
+        len += GenerateEmptyFilling(aShell, conn, stream, prefetch);
+    }
+  }
+  m_contentLength = len;
+  return m_contentLength;
+}
+
+bool nsIMAPBodypartMultipart::ShouldFetchInline(nsImapBodyShell* aShell) {
+  char* generatingPart = aShell->GetGeneratingPart();
+  if (generatingPart) {
+    // If we are generating a specific part
+    // Always generate containers (just don't fill them in)
+    // because it is low cost (everything is cached)
+    // and it gives the message its full MIME structure,
+    // to avoid any potential mishap.
+    return true;
+  }
+
+  // Generating whole message
+  if (ShouldExplicitlyFetchInline()) return true;
+  if (ShouldExplicitlyNotFetchInline()) return false;
+
+  if (!PL_strcasecmp(m_bodySubType, "alternative")) return true;
+
+  nsIMAPBodypart* grandparentPart = m_parentPart->GetParentPart();
+
+  // if we're a multipart sub-part of multipart alternative, we need to
+  // be fetched because mime will always display us.
+  if (!PL_strcasecmp(m_parentPart->GetBodySubType(), "alternative") &&
+      GetType() == IMAP_BODY_MULTIPART)
+    return true;
+  // If "Show Attachments as Links" is on, and
+  // the parent of this multipart is not a message,
+  // then it's not inline.
+  if (!(aShell->GetContentModified() == IMAP_CONTENT_MODIFIED_VIEW_INLINE) &&
+      (m_parentPart->GetType() != IMAP_BODY_MESSAGE_RFC822) &&
+      (m_parentPart->GetType() == IMAP_BODY_MULTIPART
+           ? (grandparentPart
+                  ? grandparentPart->GetType() != IMAP_BODY_MESSAGE_RFC822
+                  : true)
+           : true))
+    return false;
+
+  // multiparts are always inline (even multipart/appledouble)
+  // (their children might not be, though)
+  return true;
+}
+
+bool nsIMAPBodypartMultipart::PreflightCheckAllInline(nsImapBodyShell* aShell) {
+  bool rv = ShouldFetchInline(aShell);
+
+  size_t i = 0;
+  while (rv && (i < m_partList.Length())) {
+    rv = m_partList[i]->PreflightCheckAllInline(aShell);
+    i++;
+  }
+
+  return rv;
+}
+
+nsIMAPBodypart* nsIMAPBodypartMultipart::FindPartWithNumber(
+    const char* partNum) {
+  NS_ASSERTION(partNum, "null part passed into FindPartWithNumber");
+
+  // check this
+  if (!PL_strcmp(partNum, m_partNumberString)) return this;
+
+  // check children
+  for (int i = m_partList.Length() - 1; i >= 0; i--) {
+    nsIMAPBodypart* foundPart = m_partList[i]->FindPartWithNumber(partNum);
+    if (foundPart) return foundPart;
+  }
+
+  // not this, or any of this's children
+  return NULL;
+}
+
+///////////// nsIMAPMessageHeaders ////////////////////////////////////
+
+nsIMAPMessageHeaders::nsIMAPMessageHeaders(char* partNum,
+                                           nsIMAPBodypart* parentPart)
+    : nsIMAPBodypart(partNum, parentPart) {
+  if (!partNum) {
+    SetIsValid(false);
+    return;
+  }
+  m_partNumberString = NS_xstrdup(partNum);
+  if (!m_partNumberString) {
+    SetIsValid(false);
+    return;
+  }
+  if (!m_parentPart || !m_parentPart->GetnsIMAPBodypartMessage()) {
+    // Message headers created without a valid Message parent
+    NS_ASSERTION(false, "creating message headers with invalid message parent");
+    SetIsValid(false);
+  }
+}
+
+nsIMAPBodypartType nsIMAPMessageHeaders::GetType() {
+  return IMAP_BODY_MESSAGE_HEADER;
+}
+
+void nsIMAPMessageHeaders::QueuePrefetchMessageHeaders(
+    nsImapBodyShell* aShell) {
+  if (!m_parentPart->GetnsIMAPBodypartMessage()
+           ->GetIsTopLevelMessage())  // not top-level headers
+    aShell->AddPrefetchToQueue(kRFC822HeadersOnly, m_partNumberString);
+  else
+    aShell->AddPrefetchToQueue(kRFC822HeadersOnly, NULL);
+}
+
+int32_t nsIMAPMessageHeaders::Generate(nsImapBodyShell* aShell,
+                                       nsImapProtocol* conn, bool stream,
+                                       bool prefetch) {
+  // prefetch the header
+  if (prefetch && !m_partData && !conn->DeathSignalReceived()) {
+    QueuePrefetchMessageHeaders(aShell);
+  }
+
+  if (stream && !prefetch)
+    conn->Log("SHELL", "GENERATE-MessageHeaders", m_partNumberString);
+
+  // stream out the part data
+  if (ShouldFetchInline(aShell)) {
+    if (!conn->GetPseudoInterrupted())
+      m_contentLength = GeneratePart(aShell, conn, stream, prefetch);
+  } else {
+    m_contentLength = 0;  // don't fill in any filling for the headers
+  }
+  return m_contentLength;
+}
+
+bool nsIMAPMessageHeaders::ShouldFetchInline(nsImapBodyShell* aShell) {
+  return m_parentPart->ShouldFetchInline(aShell);
+}
+
+///////////// nsImapBodyShellCache ////////////////////////////////////
+
+nsImapBodyShellCache::nsImapBodyShellCache()
+    : m_shellList(kMaxEntries), m_shellHash(kMaxEntries) {}
+
+// We'll use an LRU scheme here.
+// We will add shells in numerical order, so the
+// least recently used one will be in slot 0.
+void nsImapBodyShellCache::EjectEntry() {
+  MOZ_ASSERT(!m_shellList.IsEmpty());
+
+  nsImapBodyShell* removedShell = m_shellList.ElementAt(0);
+
+  m_shellList.RemoveElementAt(0);
+  m_shellHash.Remove(removedShell->GetUID());
+}
+
+void nsImapBodyShellCache::Clear() {
+  m_shellList.ClearAndRetainStorage();
+  m_shellHash.Clear();
+}
+
+void nsImapBodyShellCache::AddShellToCache(nsImapBodyShell* shell) {
+  // If it's already in the cache, then just return.
+  // This has the side-effect of re-ordering the LRU list
+  // to put this at the top, which is good, because it's what we want.
+  if (FindShellForUID(shell->GetUID_validity(), shell->GetFolderName(),
+                      shell->GetContentModified())) {
+    return;
+  }
+
+  // OK, so it's not in the cache currently.
+
+  // First, for safety sake, remove any entry with the given UID,
+  // just in case we have a collision between two messages in different
+  // folders with the same UID.
+  RefPtr<nsImapBodyShell> foundShell;
+  m_shellHash.Get(shell->GetUID_validity(), getter_AddRefs(foundShell));
+  if (foundShell) {
+    m_shellHash.Remove(foundShell->GetUID_validity());
+    m_shellList.RemoveElement(foundShell);
+  }
+
+  // Make sure there's enough room
+  while (m_shellList.Length() > (kMaxEntries - 1)) {
+    EjectEntry();
+  }
+
+  // Add the new one to the cache
+  m_shellList.AppendElement(shell);
+
+  m_shellHash.InsertOrUpdate(shell->GetUID_validity(), RefPtr{shell});
+  shell->SetIsCached(true);
+}
+
+nsImapBodyShell* nsImapBodyShellCache::FindShellForUID(
+    nsACString const& UID, nsACString const& mailboxName,
+    IMAP_ContentModifiedType modType) {
+  RefPtr<nsImapBodyShell> foundShell;
+  m_shellHash.Get(UID, getter_AddRefs(foundShell));
+  if (!foundShell) return nullptr;
+  // Make sure the content-modified types are compatible.
+  // This allows us to work seamlessly while people switch between
+  // View Attachments Inline and View Attachments As Links.
+  // Enforce the invariant that any cached shell we use
+  // match the current content-modified settings.
+  if (modType != foundShell->GetContentModified()) return nullptr;
+
+  // mailbox names must match also.
+  if (!mailboxName.Equals(foundShell->GetFolderName())) return nullptr;
+
+  // adjust the LRU stuff. This defeats the performance gain of the hash if
+  // it actually is found since this is linear.
+  m_shellList.RemoveElement(foundShell);
+  m_shellList.AppendElement(foundShell);  // Adds to end
+
+  return foundShell;
+}
+
+///////////// nsIMAPMessagePartID ////////////////////////////////////
+
+nsIMAPMessagePartID::nsIMAPMessagePartID(nsIMAPeFetchFields fields,
+                                         const char* partNumberString)
+    : m_partNumberString(partNumberString), m_fields(fields) {}