NS_IMETHODIMP nsMsgWindow::DoContent(const char *aContentType, bool aIsContentPreferred,
nsIRequest *request, nsIStreamListener **aContentHandler, bool *aAbortProcess)
{
if (aContentType)
{
// forward the DoContent call to our docshell
nsCOMPtr<nsIDocShell> messageWindowDocShell;
GetMessageWindowDocShell(getter_AddRefs(messageWindowDocShell));
nsCOMPtr<nsIURIContentListener> ctnListener = do_QueryInterface(messageWindowDocShell);
if (ctnListener)
{
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
if (!aChannel) return NS_ERROR_FAILURE;
// get the url for the channel...let's hope it is a mailnews url so we can set our msg hdr sink on it..
// right now, this is the only way I can think of to force the msg hdr sink into the mime converter so it can
// get too it later...
nsCOMPtr<nsIURI> uri;
aChannel->GetURI(getter_AddRefs(uri));
if (uri)
{
nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(uri));
if (mailnewsUrl)
mailnewsUrl->SetMsgWindow(this);
}
return ctnListener->DoContent(aContentType, aIsContentPreferred, request, aContentHandler, aAbortProcess);
}
}
return NS_OK;
}
/**
* This function is used to determine if we allow content for a remote message.
* If we reject loading remote content, then we'll inform the message window
* that this message has remote content (and hence we are not loading it).
*
* See ShouldAcceptRemoteContentForMsgHdr for the actual decisions that
* determine if we are going to allow remote content.
*/
void
nsMsgContentPolicy::ShouldAcceptContentForPotentialMsg(nsIURI *aOriginatorLocation,
nsIURI *aContentLocation,
PRInt16 *aDecision)
{
NS_PRECONDITION(*aDecision == nsIContentPolicy::REJECT_REQUEST,
"AllowContentForPotentialMessage expects default decision to be reject!");
// Is it a mailnews url?
nsresult rv;
nsCOMPtr<nsIMsgMessageUrl> msgUrl(do_QueryInterface(aOriginatorLocation,
&rv));
if (NS_FAILED(rv))
{
// It isn't a mailnews url - so we accept the load here, and let other
// content policies make the decision if we should be loading it or not.
*aDecision = nsIContentPolicy::ACCEPT;
return;
}
nsCString resourceURI;
rv = msgUrl->GetUri(getter_Copies(resourceURI));
NS_ENSURE_SUCCESS(rv, );
nsCOMPtr<nsIMsgDBHdr> msgHdr;
rv = GetMsgDBHdrFromURI(resourceURI.get(), getter_AddRefs(msgHdr));
NS_ENSURE_SUCCESS(rv, );
nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(aOriginatorLocation, &rv));
NS_ENSURE_SUCCESS(rv, );
// Get a decision on whether or not to allow remote content for this message
// header.
*aDecision = ShouldAcceptRemoteContentForMsgHdr(msgHdr, aOriginatorLocation,
aContentLocation);
// If we're not allowing the remote content, tell the nsIMsgWindow loading
// this url that this is the case, so that the UI knows to show the remote
// content header bar, so the user can override if they wish.
if (*aDecision == nsIContentPolicy::REJECT_REQUEST)
{
nsCOMPtr<nsIMsgWindow> msgWindow;
(void)mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
if (msgWindow)
{
nsCOMPtr<nsIRunnable> event = new RemoteContentNotifierEvent(msgWindow,
msgHdr);
// Post this as an event because it can cause dom mutations, and we
// get called at a bad time to be causing dom mutations.
if (event)
NS_DispatchToCurrentThread(event);
}
}
}
nsresult
nsMimeHtmlDisplayEmitter::EndBody()
{
if (mFormat != nsMimeOutput::nsMimeMessageFilterSniffer)
{
UtilityWriteCRLF("</body>");
UtilityWriteCRLF("</html>");
}
nsCOMPtr<nsIMsgHeaderSink> headerSink;
nsresult rv = GetHeaderSink(getter_AddRefs(headerSink));
nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl (do_QueryInterface(mURL, &rv));
if (headerSink)
headerSink->OnEndMsgHeaders(mailnewsUrl);
return NS_OK;
}
int32_t nsMailboxProtocol::ReadMessageResponse(nsIInputStream * inputStream, uint64_t sourceOffset, uint32_t length)
{
char *line = nullptr;
uint32_t status = 0;
nsresult rv = NS_OK;
mCurrentProgress += length;
// if we are doing a move or a copy, forward the data onto the copy handler...
// if we want to display the message then parse the incoming data...
if (m_channelListener)
{
// just forward the data we read in to the listener...
rv = m_channelListener->OnDataAvailable(this, m_channelContext, inputStream, sourceOffset, length);
}
else
{
bool pauseForMoreData = false;
bool canonicalLineEnding = false;
nsCOMPtr<nsIMsgMessageUrl> msgurl = do_QueryInterface(m_runningUrl);
if (msgurl)
msgurl->GetCanonicalLineEnding(&canonicalLineEnding);
while ((line = m_lineStreamBuffer->ReadNextLine(inputStream, status, pauseForMoreData)) &&
!pauseForMoreData)
{
/* When we're sending this line to a converter (ie,
it's a message/rfc822) use the local line termination
convention, not CRLF. This makes text articles get
saved with the local line terminators. Since SMTP
and NNTP mandate the use of CRLF, it is expected that
the local system will convert that to the local line
terminator as it is read.
*/
// mscott - the firstline hack is aimed at making sure we don't write
// out the dummy header when we are trying to display the message.
// The dummy header is the From line with the date tag on it.
if (m_msgFileOutputStream && TestFlag(MAILBOX_MSG_PARSE_FIRST_LINE))
{
uint32_t count = 0;
rv = m_msgFileOutputStream->Write(line, PL_strlen(line), &count);
if (NS_FAILED(rv))
break;
if (canonicalLineEnding)
rv = m_msgFileOutputStream->Write(CRLF, 2, &count);
else
rv = m_msgFileOutputStream->Write(MSG_LINEBREAK,
MSG_LINEBREAK_LEN, &count);
if (NS_FAILED(rv))
break;
}
else
SetFlag(MAILBOX_MSG_PARSE_FIRST_LINE);
PR_Free(line);
}
PR_Free(line);
}
SetFlag(MAILBOX_PAUSE_FOR_READ); // wait for more data to become available...
if (mProgressEventSink && m_runningUrl)
{
int64_t maxProgress;
nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(m_runningUrl));
mailnewsUrl->GetMaxProgress(&maxProgress);
mProgressEventSink->OnProgress(this, m_channelContext,
mCurrentProgress,
maxProgress);
}
if (NS_FAILED(rv)) return -1;
return 0;
}