Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "nsImapBodyShell.h"
#include "nsImapProtocol.h"
#include "nsMimeTypes.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).
// ---------------------------------- -----------------------------------
// 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) {}