NS_INTERFACE_MAP_END_THREADSAFE
static nsresult GetMessage(nsIURI *aURL, nsIMsgDBHdr **message)
{
NS_ENSURE_ARG_POINTER(message);
nsCOMPtr<nsIMsgMessageUrl> uriURL;
nsresult rv;
//Need to get message we are about to copy
uriURL = do_QueryInterface(aURL, &rv);
if(NS_FAILED(rv))
return rv;
// get the uri. first try and use the original message spec
// if that fails, use the spec of nsIURI that we're called with
nsCString uri;
rv = uriURL->GetOriginalSpec(getter_Copies(uri));
if (NS_FAILED(rv) || uri.IsEmpty()) {
rv = uriURL->GetUri(getter_Copies(uri));
NS_ENSURE_SUCCESS(rv,rv);
}
nsCOMPtr <nsIMsgMessageService> msgMessageService;
rv = GetMessageServiceFromURI(uri, getter_AddRefs(msgMessageService));
NS_ENSURE_SUCCESS(rv,rv);
if (!msgMessageService)
return NS_ERROR_FAILURE;
rv = msgMessageService->MessageURIToMsgHdr(uri.get(), message);
return rv;
}
nsresult nsMsgSearchSession::GetNextUrl()
{
nsCString nextUrl;
nsCOMPtr <nsIMsgMessageService> msgService;
PRBool stopped = PR_FALSE;
nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(m_msgWindowWeak));
if (msgWindow)
msgWindow->GetStopped(&stopped);
if (stopped)
return NS_OK;
m_urlQueue.CStringAt(m_urlQueueIndex, nextUrl);
nsMsgSearchScopeTerm *currentTerm = GetRunningScope();
EnableFolderNotifications(PR_FALSE);
nsCOMPtr <nsIMsgFolder> folder = currentTerm->m_folder;
if (folder)
{
nsCString folderUri;
folder->GetURI(folderUri);
nsresult rv = GetMessageServiceFromURI(folderUri, getter_AddRefs(msgService));
if (NS_SUCCEEDED(rv) && msgService && currentTerm)
msgService->Search(this, msgWindow, currentTerm->m_folder, nextUrl.get());
return rv;
}
return NS_OK;
}
nsresult nsMsgSearchSession::GetNextUrl()
{
nsCString nextUrl;
nsCOMPtr<nsIMsgMessageService> msgService;
bool stopped = false;
nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(m_msgWindowWeak));
if (msgWindow)
msgWindow->GetStopped(&stopped);
if (stopped)
return NS_OK;
nextUrl = m_urlQueue[m_urlQueueIndex];
nsMsgSearchScopeTerm *currentTerm = GetRunningScope();
NS_ENSURE_TRUE(currentTerm, NS_ERROR_NULL_POINTER);
EnableFolderNotifications(false);
nsCOMPtr<nsIMsgFolder> folder = currentTerm->m_folder;
if (folder)
{
nsCString folderUri;
folder->GetURI(folderUri);
nsresult rv = GetMessageServiceFromURI(folderUri, getter_AddRefs(msgService));
if (NS_SUCCEEDED(rv) && msgService && currentTerm)
msgService->Search(this, msgWindow, currentTerm->m_folder, nextUrl.get());
return rv;
}
return NS_OK;
}
nsresult
nsMsgSearchDBView::GetFolderFromMsgURI(const char *aMsgURI, nsIMsgFolder **aFolder)
{
nsCOMPtr <nsIMsgMessageService> msgMessageService;
nsresult rv = GetMessageServiceFromURI(nsDependentCString(aMsgURI), getter_AddRefs(msgMessageService));
NS_ENSURE_SUCCESS(rv,rv);
nsCOMPtr <nsIMsgDBHdr> msgHdr;
rv = msgMessageService->MessageURIToMsgHdr(aMsgURI, getter_AddRefs(msgHdr));
NS_ENSURE_SUCCESS(rv,rv);
return msgHdr->GetFolder(aFolder);
}
nsresult
nsMsgPrintEngine::FireThatLoadOperation(const nsString& uri)
{
nsresult rv;
nsCString uriCStr;
LossyCopyUTF16toASCII(uri, uriCStr);
nsCOMPtr <nsIMsgMessageService> messageService;
// if this is a data: url, skip it, because
// we've already got something we can print
// and we know it is not a message.
//
// if this an about:blank url, skip it, because
// ...
//
// if this is an addbook: url, skip it, because
// we know that isn't a message.
//
// if this is a message part (or .eml file on disk)
// skip it, because we don't want to print the parent message
// we want to print the part.
// example: imap://sspitzer@nsmail-1:143/fetch%3EUID%3E/INBOX%3E180958?part=1.1.2&type=application/x-message-display&filename=test"
if (!StringBeginsWith(uriCStr, NS_LITERAL_CSTRING(DATA_URL_PREFIX)) &&
!StringBeginsWith(uriCStr, NS_LITERAL_CSTRING(ADDBOOK_URL_PREFIX)) &&
!uriCStr.EqualsLiteral("about:blank") &&
uriCStr.Find(NS_LITERAL_CSTRING("type=application/x-message-display")) == -1) {
rv = GetMessageServiceFromURI(uriCStr, getter_AddRefs(messageService));
}
if (NS_SUCCEEDED(rv) && messageService)
rv = messageService->DisplayMessageForPrinting(uriCStr.get(), mDocShell, nsnull, nsnull, nsnull);
//If it's not something we know about, then just load try loading it directly.
else
{
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
if (webNav)
rv = webNav->LoadURI(uri.get(), // URI string
nsIWebNavigation::LOAD_FLAGS_NONE, // Load flags
nsnull, // Referring URI
nsnull, // Post data
nsnull); // Extra headers
}
return rv;
}
nsresult
nsFolderCompactState::Init(nsIMsgFolder *folder, const char *baseMsgUri, nsIMsgDatabase *db,
nsIFile *path, nsIMsgWindow *aMsgWindow)
{
nsresult rv;
m_folder = folder;
m_baseMessageUri = baseMsgUri;
m_file = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
m_file->InitWithFile(path);
// need to make sure the temp file goes in the same real directory
// as the original file, so resolve sym links.
m_file->SetFollowLinks(true);
m_file->SetNativeLeafName(NS_LITERAL_CSTRING("nstmp"));
rv = m_file->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600); //make sure we are not crunching existing nstmp file
NS_ENSURE_SUCCESS(rv, rv);
m_window = aMsgWindow;
m_keyArray = new nsMsgKeyArray;
m_size = 0;
m_totalMsgSize = 0;
rv = InitDB(db);
if (NS_FAILED(rv))
{
CleanupTempFilesAfterError();
return rv;
}
m_curIndex = 0;
rv = MsgNewBufferedFileOutputStream(getter_AddRefs(m_fileStream), m_file, -1, 00600);
if (NS_FAILED(rv))
m_folder->ThrowAlertMsg("compactFolderWriteFailed", m_window);
else
rv = GetMessageServiceFromURI(nsDependentCString(baseMsgUri),
getter_AddRefs(m_messageService));
if (NS_FAILED(rv))
{
m_status = rv;
}
return rv;
}
nsresult
nsMsgAttachmentHandler::SnarfMsgAttachment(nsMsgCompFields *compFields)
{
nsresult rv = NS_ERROR_INVALID_ARG;
nsCOMPtr <nsIMsgMessageService> messageService;
if (m_uri.Find("-message:", CaseInsensitiveCompare) != -1)
{
nsCOMPtr <nsIFile> tmpFile;
rv = nsMsgCreateTempFile("nsmail.tmp", getter_AddRefs(tmpFile));
NS_ENSURE_SUCCESS(rv, rv);
mTmpFile = do_QueryInterface(tmpFile);
mDeleteFile = true;
mCompFields = compFields;
m_type = MESSAGE_RFC822;
m_overrideType = MESSAGE_RFC822;
if (!mTmpFile)
{
rv = NS_ERROR_FAILURE;
goto done;
}
rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mOutFile), mTmpFile, -1, 00600);
if (NS_FAILED(rv) || !mOutFile)
{
if (m_mime_delivery_state)
{
nsCOMPtr<nsIMsgSendReport> sendReport;
m_mime_delivery_state->GetSendReport(getter_AddRefs(sendReport));
if (sendReport)
{
nsAutoString error_msg;
nsMsgBuildMessageWithTmpFile(mTmpFile, error_msg);
sendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), false);
}
}
rv = NS_MSG_UNABLE_TO_OPEN_TMP_FILE;
goto done;
}
nsCOMPtr<nsIURLFetcher> fetcher = do_CreateInstance(NS_URLFETCHER_CONTRACTID, &rv);
if (NS_FAILED(rv) || !fetcher)
{
if (NS_SUCCEEDED(rv))
rv = NS_ERROR_UNEXPECTED;
goto done;
}
rv = fetcher->Initialize(mTmpFile, mOutFile, FetcherURLDoneCallback, this);
rv = GetMessageServiceFromURI(m_uri, getter_AddRefs(messageService));
if (NS_SUCCEEDED(rv) && messageService)
{
nsCAutoString uri(m_uri);
uri += (uri.FindChar('?') == kNotFound) ? '?' : '&';
uri.Append("fetchCompleteMessage=true");
nsCOMPtr<nsIStreamListener> strListener;
fetcher->QueryInterface(NS_GET_IID(nsIStreamListener), getter_AddRefs(strListener));
// initialize a new stream converter, that uses the strListener as its input
// obtain the input stream listener from the new converter,
// and pass the converter's input stream listener to DisplayMessage
m_mime_parser = do_CreateInstance(NS_MAILNEWS_MIME_STREAM_CONVERTER_CONTRACTID, &rv);
if (NS_FAILED(rv))
goto done;
// Set us as the output stream for HTML data from libmime...
nsCOMPtr<nsIMimeStreamConverter> mimeConverter = do_QueryInterface(m_mime_parser);
if (mimeConverter)
{
mimeConverter->SetMimeOutputType(nsMimeOutput::nsMimeMessageDecrypt);
mimeConverter->SetForwardInline(false);
mimeConverter->SetIdentity(nsnull);
mimeConverter->SetOriginalMsgURI(nsnull);
}
nsCOMPtr<nsIStreamListener> convertedListener = do_QueryInterface(m_mime_parser, &rv);
if (NS_FAILED(rv))
goto done;
nsCOMPtr<nsIURI> aURL;
rv = messageService->GetUrlForUri(uri.get(), getter_AddRefs(aURL), nsnull);
if (aURL)
aURL->SetSpec(nsDependentCString(uri.get()));
rv = NS_NewInputStreamChannel(getter_AddRefs(m_converter_channel), aURL, nsnull);
if (NS_FAILED(rv))
goto done;
rv = m_mime_parser->AsyncConvertData(
"message/rfc822",
"message/rfc822",
strListener, m_converter_channel);
if (NS_FAILED(rv))
goto done;
rv = messageService->DisplayMessage(uri.get(), convertedListener, nsnull, nsnull, nsnull, nsnull);
}
}
done:
if (NS_FAILED(rv))
{
if (mOutFile)
{
mOutFile->Close();
mOutFile = nsnull;
}
if (mTmpFile)
{
mTmpFile->Remove(false);
mTmpFile = nsnull;
}
}
return rv;
}
/**
* Content policy logic for mail windows
*
*/
nsresult nsMsgContentPolicy::MailShouldLoad(nsIURI * aRequestingLocation, nsIURI * aContentLocation, PRInt16 * aDecision)
{
NS_ENSURE_TRUE(aRequestingLocation, NS_OK);
// Allow remote content when using a remote start page in the message pane.
// aRequestingLocation is the url currently loaded in the message pane.
// If that's an http / https url (as opposed to a mail url) then we
// must be loading a start page and not a message.
PRBool isHttp;
PRBool isHttps;
nsresult rv = aRequestingLocation->SchemeIs("http", &isHttp);
rv |= aRequestingLocation->SchemeIs("https", &isHttps);
if (NS_SUCCEEDED(rv) && (isHttp || isHttps))
{
*aDecision = nsIContentPolicy::ACCEPT;
return NS_OK;
}
// (1) examine the msg hdr value for the remote content policy on this particular message to
// see if this particular message has special rights to bypass the remote content check
// (2) special case RSS urls, always allow them to load remote images since the user explicitly
// subscribed to the feed.
// (3) Check the personal address book and use it as a white list for senders
// who are allowed to send us remote images
// get the msg hdr for the message URI we are actually loading
nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(aRequestingLocation, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCString resourceURI;
msgUrl->GetUri(getter_Copies(resourceURI));
// get the msg service for this URI
nsCOMPtr<nsIMsgMessageService> msgService;
rv = GetMessageServiceFromURI(resourceURI, getter_AddRefs(msgService));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgDBHdr> msgHdr;
rv = msgService->MessageURIToMsgHdr(resourceURI.get(), getter_AddRefs(msgHdr));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(aRequestingLocation, &rv);
NS_ENSURE_SUCCESS(rv, rv);
AllowRemoteContentForMsgHdr(msgHdr, aRequestingLocation, aContentLocation, aDecision);
if (*aDecision == nsIContentPolicy::REJECT_REQUEST)
{
// now we need to call out the msg sink informing it that this message has remote content
nsCOMPtr<nsIMsgWindow> msgWindow;
rv = mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
if (msgWindow)
{
nsCOMPtr<nsIMsgHeaderSink> msgHdrSink;
rv = msgWindow->GetMsgHeaderSink(getter_AddRefs(msgHdrSink));
if (msgHdrSink)
msgHdrSink->OnMsgHasRemoteContent(msgHdr); // notify the UI to show the remote content hdr bar so the user can overide
}
}
return NS_OK;
}
nsresult
nsMsgSendLater::StartNextMailFileSend(nsresult prevStatus)
{
bool hasMoreElements = false;
if ((!mEnumerator) ||
NS_FAILED(mEnumerator->HasMoreElements(&hasMoreElements)) ||
!hasMoreElements)
{
// Notify that this message has finished being sent.
NotifyListenersOnProgress(mTotalSendCount, mMessagesToSend.Count(), 100, 100);
// EndSendMessages resets everything for us
EndSendMessages(prevStatus, nullptr, mTotalSendCount, mTotalSentSuccessfully);
// XXX Should we be releasing references so that we don't hold onto items
// unnecessarily.
return NS_OK;
}
// If we've already sent a message, and are sending more, send out a progress
// update with 100% for both send and copy as we must have finished by now.
if (mTotalSendCount)
NotifyListenersOnProgress(mTotalSendCount, mMessagesToSend.Count(), 100, 100);
nsCOMPtr<nsISupports> currentItem;
nsresult rv = mEnumerator->GetNext(getter_AddRefs(currentItem));
NS_ENSURE_SUCCESS(rv, rv);
mMessage = do_QueryInterface(currentItem);
if (!mMessage)
return NS_ERROR_NOT_AVAILABLE;
if (!mMessageFolder)
return NS_ERROR_UNEXPECTED;
nsCString messageURI;
mMessageFolder->GetUriForMsg(mMessage, messageURI);
rv = nsMsgCreateTempFile("nsqmail.tmp", getter_AddRefs(mTempFile));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgMessageService> messageService;
rv = GetMessageServiceFromURI(messageURI, getter_AddRefs(messageService));
if (NS_FAILED(rv) && !messageService)
return NS_ERROR_FACTORY_NOT_LOADED;
++mTotalSendCount;
nsCString identityKey;
rv = mMessage->GetStringProperty(HEADER_X_MOZILLA_IDENTITY_KEY,
getter_Copies(identityKey));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgIdentity> identity;
rv = GetIdentityFromKey(identityKey.get(), getter_AddRefs(identity));
NS_ENSURE_SUCCESS(rv, rv);
// Notify that we're just about to start sending this message
NotifyListenersOnMessageStartSending(mTotalSendCount, mMessagesToSend.Count(),
identity);
// Setup what we need to parse the data stream correctly
m_inhead = true;
m_headersFP = 0;
m_headersPosition = 0;
m_bytesRead = 0;
m_position = 0;
m_flagsPosition = 0;
m_headersSize = 0;
PR_FREEIF(mLeftoverBuffer);
// Now, get our stream listener interface and plug it into the DisplayMessage
// operation
AddRef();
rv = messageService->DisplayMessage(messageURI.get(),
static_cast<nsIStreamListener*>(this),
nullptr, nullptr, nullptr, nullptr);
Release();
return rv;
}
nsresult
nsMsgQuote::QuoteMessage(const char *msgURI, bool quoteHeaders,
nsIMsgQuotingOutputStreamListener * aQuoteMsgStreamListener,
const char * aMsgCharSet, bool headersOnly,
nsIMsgDBHdr *aMsgHdr)
{
nsresult rv;
if (!msgURI)
return NS_ERROR_INVALID_ARG;
mQuoteHeaders = quoteHeaders;
mStreamListener = aQuoteMsgStreamListener;
nsAutoCString msgUri(msgURI);
bool fileUrl = !strncmp(msgURI, "file:", 5);
bool forwardedMessage = PL_strstr(msgURI, "&realtype=message/rfc822") != nullptr;
nsCOMPtr<nsIURI> aURL;
if (fileUrl)
{
msgUri.Replace(0, 5, NS_LITERAL_CSTRING("mailbox:"));
msgUri.AppendLiteral("?number=0");
rv = NS_NewURI(getter_AddRefs(aURL), msgUri);
nsCOMPtr<nsIMsgMessageUrl> mailUrl(do_QueryInterface(aURL));
if (mailUrl)
mailUrl->SetMessageHeader(aMsgHdr);
}
else if (forwardedMessage)
rv = NS_NewURI(getter_AddRefs(aURL), msgURI);
else
{
nsCOMPtr <nsIMsgMessageService> msgService;
rv = GetMessageServiceFromURI(nsDependentCString(msgURI), getter_AddRefs(msgService));
if (NS_FAILED(rv)) return rv;
rv = msgService->GetUrlForUri(msgURI, getter_AddRefs(aURL), nullptr);
}
if (NS_FAILED(rv)) return rv;
nsCOMPtr <nsIURL> mailNewsUrl = do_QueryInterface(aURL, &rv);
NS_ENSURE_SUCCESS(rv,rv);
nsAutoCString queryPart;
rv = mailNewsUrl->GetQuery(queryPart);
if (!queryPart.IsEmpty())
queryPart.Append('&');
if (headersOnly) /* We don't need to quote the message body but we still need to extract the headers */
queryPart.Append("header=only");
else if (quoteHeaders)
queryPart.Append("header=quote");
else
queryPart.Append("header=quotebody");
rv = mailNewsUrl->SetQuery(queryPart);
NS_ENSURE_SUCCESS(rv,rv);
// if we were given a non empty charset, then use it
if (aMsgCharSet && *aMsgCharSet)
{
nsCOMPtr<nsIMsgI18NUrl> i18nUrl (do_QueryInterface(aURL));
if (i18nUrl)
i18nUrl->SetCharsetOverRide(aMsgCharSet);
}
mQuoteListener = do_CreateInstance(NS_MSGQUOTELISTENER_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
mQuoteListener->SetMsgQuote(this);
// funky magic go get the isupports for this class which inherits from multiple interfaces.
nsISupports * supports;
QueryInterface(NS_GET_IID(nsISupports), (void **) &supports);
nsCOMPtr<nsISupports> quoteSupport = supports;
NS_IF_RELEASE(supports);
// now we want to create a necko channel for this url and we want to open it
mQuoteChannel = nullptr;
nsCOMPtr<nsIIOService> netService =
mozilla::services::GetIOService();
NS_ENSURE_TRUE(netService, NS_ERROR_UNEXPECTED);
rv = netService->NewChannelFromURI(aURL, getter_AddRefs(mQuoteChannel));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsISupports> ctxt = do_QueryInterface(aURL);
nsCOMPtr<nsIStreamConverterService> streamConverterService =
do_GetService("@mozilla.org/streamConverters;1", &rv);
NS_ENSURE_SUCCESS(rv,rv);
nsCOMPtr<nsIStreamListener> convertedListener;
rv = streamConverterService->AsyncConvertData("message/rfc822",
"application/vnd.mozilla.xul+xml",
mStreamListener,
quoteSupport,
getter_AddRefs(convertedListener));
if (NS_FAILED(rv)) return rv;
// now try to open the channel passing in our display consumer as the listener
rv = mQuoteChannel->AsyncOpen(convertedListener, ctxt);
return rv;
}
