NS_IMETHODIMP nsMsgBrkMBoxStore::IsSummaryFileValid(nsIMsgFolder *aFolder,
nsIMsgDatabase *aDB,
bool *aResult)
{
NS_ENSURE_ARG_POINTER(aFolder);
NS_ENSURE_ARG_POINTER(aDB);
NS_ENSURE_ARG_POINTER(aResult);
// We only check local folders for db validity.
nsCOMPtr<nsIMsgLocalMailFolder> localFolder(do_QueryInterface(aFolder));
if (!localFolder)
{
*aResult = true;
return NS_OK;
}
nsCOMPtr<nsIFile> pathFile;
nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIDBFolderInfo> folderInfo;
rv = aDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
NS_ENSURE_SUCCESS(rv, rv);
uint64_t folderSize;
uint32_t folderDate;
int32_t numUnreadMessages;
*aResult = false;
folderInfo->GetNumUnreadMessages(&numUnreadMessages);
folderInfo->GetFolderSize(&folderSize);
folderInfo->GetFolderDate(&folderDate);
int64_t fileSize = 0;
uint32_t actualFolderTimeStamp = 0;
GetMailboxModProperties(aFolder, &fileSize, &actualFolderTimeStamp);
if (folderSize == fileSize && numUnreadMessages >= 0)
{
if (!folderSize)
{
*aResult = true;
return NS_OK;
}
if (!gGotGlobalPrefs)
{
nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (pPrefBranch)
{
rv = pPrefBranch->GetIntPref("mail.db_timestamp_leeway", &gTimeStampLeeway);
gGotGlobalPrefs = true;
}
}
// if those values are ok, check time stamp
if (gTimeStampLeeway == 0)
*aResult = folderDate == actualFolderTimeStamp;
else
*aResult = std::abs((int32_t) (actualFolderTimeStamp - folderDate)) <= gTimeStampLeeway;
}
return NS_OK;
}
NS_IMETHODIMP nsMimeHtmlDisplayEmitter::WriteHTMLHeaders(const nsACString &name)
{
// if we aren't broadcasting headers OR printing...just do whatever
// our base class does...
if (mFormat == nsMimeOutput::nsMimeMessagePrintOutput)
{
return nsMimeBaseEmitter::WriteHTMLHeaders(name);
}
else if (!BroadCastHeadersAndAttachments() || !mDocHeader)
{
// This needs to be here to correct the output format if we are
// not going to broadcast headers to the XUL document.
if (mFormat == nsMimeOutput::nsMimeMessageBodyDisplay)
mFormat = nsMimeOutput::nsMimeMessagePrintOutput;
return nsMimeBaseEmitter::WriteHTMLHeaders(name);
}
else
mFirstHeaders = false;
bool bFromNewsgroups = false;
for (int32_t j=0; j < mHeaderArray->Count(); j++)
{
headerInfoType *headerInfo = (headerInfoType *)mHeaderArray->ElementAt(j);
if (!(headerInfo && headerInfo->name && *headerInfo->name))
continue;
if (!PL_strcasecmp("Newsgroups", headerInfo->name))
{
bFromNewsgroups = true;
break;
}
}
// try to get a header sink if there is one....
nsCOMPtr<nsIMsgHeaderSink> headerSink;
nsresult rv = GetHeaderSink(getter_AddRefs(headerSink));
if (headerSink)
{
int32_t viewMode = 0;
nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
if (pPrefBranch)
rv = pPrefBranch->GetIntPref("mail.show_headers", &viewMode);
rv = BroadcastHeaders(headerSink, viewMode, bFromNewsgroups);
} // if header Sink
return NS_OK;
}
NS_INTERFACE_MAP_END
nsMimeBaseEmitter::nsMimeBaseEmitter()
{
// Initialize data output vars...
mFirstHeaders = true;
mBufferMgr = nsnull;
mTotalWritten = 0;
mTotalRead = 0;
mInputStream = nsnull;
mOutStream = nsnull;
mOutListener = nsnull;
// Display output control vars...
mDocHeader = false;
m_stringBundle = nsnull;
mURL = nsnull;
mHeaderDisplayType = nsMimeHeaderDisplayTypes::NormalHeaders;
// Setup array for attachments
mAttachCount = 0;
mAttachArray = new nsVoidArray();
mCurrentAttachment = nsnull;
// Header cache...
mHeaderArray = new nsVoidArray();
// Embedded Header Cache...
mEmbeddedHeaderArray = nsnull;
// HTML Header Data...
// mHTMLHeaders = "";
// mCharset = "";
// Init the body...
mBodyStarted = false;
// mBody = "";
// This is needed for conversion of I18N Strings...
mUnicodeConverter = do_GetService(NS_MIME_CONVERTER_CONTRACTID);
if (!gMimeEmitterLogModule)
gMimeEmitterLogModule = PR_NewLogModule("MIME");
// Do prefs last since we can live without this if it fails...
nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (pPrefBranch)
pPrefBranch->GetIntPref("mail.show_headers", &mHeaderDisplayType);
}
NS_IMETHODIMP
nsPop3Sink::IncorporateBegin(const char* uidlString,
nsIURI* aURL,
uint32_t flags,
void** closure)
{
#ifdef DEBUG
printf("Incorporate message begin:\n");
if (uidlString)
printf("uidl string: %s\n", uidlString);
#endif
nsCOMPtr<nsIFile> path;
m_folder->GetFilePath(getter_AddRefs(path));
nsresult rv;
nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
if (pPrefBranch)
{
nsCOMPtr<nsIMsgIncomingServer> server;
m_folder->GetServer(getter_AddRefs(server));
nsCString plugStoreContract;
server->GetCharValue("storeContractID", plugStoreContract);
// Maildir doesn't care about quaranting, but other stores besides berkeley
// mailbox might. We should probably make this an attribute on the pluggable
// store, though.
if (plugStoreContract.Equals(
NS_LITERAL_CSTRING("@mozilla.org/msgstore/berkeleystore;1")))
pPrefBranch->GetBoolPref("mailnews.downloadToTempFile", &m_downloadingToTempFile);
}
nsCOMPtr<nsIMsgDBHdr> newHdr;
nsCOMPtr<nsIMsgIncomingServer> server = do_QueryInterface(m_popServer);
if (!server)
return NS_ERROR_UNEXPECTED;
if (m_downloadingToTempFile)
{
// need to create an nsIOFileStream from a temp file...
nsCOMPtr<nsIFile> tmpDownloadFile;
rv = GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR,
"newmsg",
getter_AddRefs(tmpDownloadFile));
NS_ASSERTION(NS_SUCCEEDED(rv),
"writing tmp pop3 download file: failed to append filename");
if (NS_FAILED(rv))
return rv;
if (!m_tmpDownloadFile)
{
//need a unique tmp file to prevent dataloss in multiuser environment
rv = tmpDownloadFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
NS_ENSURE_SUCCESS(rv, rv);
m_tmpDownloadFile = do_QueryInterface(tmpDownloadFile, &rv);
}
if (NS_SUCCEEDED(rv))
{
rv = MsgGetFileStream(m_tmpDownloadFile, getter_AddRefs(m_outFileStream));
NS_ENSURE_SUCCESS(rv, rv);
}
}
else
{
rv = server->GetMsgStore(getter_AddRefs(m_msgStore));
bool reusable;
NS_ENSURE_SUCCESS(rv, rv);
m_msgStore->GetNewMsgOutputStream(m_folder, getter_AddRefs(newHdr),
&reusable, getter_AddRefs(m_outFileStream));
}
// The following (!m_outFileStream etc) was added to make sure that we don't
// write somewhere where for some reason or another we can't write to and
// lose the messages. See bug 62480
if (!m_outFileStream)
return NS_ERROR_OUT_OF_MEMORY;
nsCOMPtr<nsISeekableStream> seekableOutStream = do_QueryInterface(m_outFileStream);
// create a new mail parser
if (!m_newMailParser)
m_newMailParser = new nsParseNewMailState;
NS_ENSURE_TRUE(m_newMailParser, NS_ERROR_OUT_OF_MEMORY);
if (m_uidlDownload)
m_newMailParser->DisableFilters();
nsCOMPtr <nsIMsgFolder> serverFolder;
rv = GetServerFolder(getter_AddRefs(serverFolder));
if (NS_FAILED(rv)) return rv;
rv = m_newMailParser->Init(serverFolder, m_folder,
m_window, newHdr, m_outFileStream);
// If we failed to initialize the parser, then just don't use it!!!
// We can still continue without one.
if (NS_FAILED(rv))
{
m_newMailParser = nullptr;
rv = NS_OK;
}
if (closure)
*closure = (void*) this;
nsCString outputString(GetDummyEnvelope());
rv = WriteLineToMailbox(outputString);
NS_ENSURE_SUCCESS(rv, rv);
// Write out account-key before UIDL so the code that looks for
// UIDL will find the account first and know it can stop looking
// once it finds the UIDL line.
if (!m_accountKey.IsEmpty())
{
outputString.AssignLiteral(HEADER_X_MOZILLA_ACCOUNT_KEY ": ");
outputString.Append(m_accountKey);
outputString.AppendLiteral(MSG_LINEBREAK);
rv = WriteLineToMailbox(outputString);
NS_ENSURE_SUCCESS(rv, rv);
}
if (uidlString)
{
outputString.AssignLiteral("X-UIDL: ");
outputString.Append(uidlString);
outputString.AppendLiteral(MSG_LINEBREAK);
rv = WriteLineToMailbox(outputString);
NS_ENSURE_SUCCESS(rv, rv);
}
// WriteLineToMailbox("X-Mozilla-Status: 8000" MSG_LINEBREAK);
char *statusLine = PR_smprintf(X_MOZILLA_STATUS_FORMAT MSG_LINEBREAK, flags);
outputString.Assign(statusLine);
rv = WriteLineToMailbox(outputString);
PR_smprintf_free(statusLine);
NS_ENSURE_SUCCESS(rv, rv);
rv = WriteLineToMailbox(NS_LITERAL_CSTRING("X-Mozilla-Status2: 00000000" MSG_LINEBREAK));
NS_ENSURE_SUCCESS(rv, rv);
// leave space for 60 bytes worth of keys/tags
rv = WriteLineToMailbox(NS_LITERAL_CSTRING(X_MOZILLA_KEYWORDS));
return NS_OK;
}
nsresult nsMimeHtmlDisplayEmitter::BroadcastHeaders(nsIMsgHeaderSink * aHeaderSink, int32_t aHeaderMode, bool aFromNewsgroup)
{
// two string enumerators to pass out to the header sink
nsRefPtr<nsMimeStringEnumerator> headerNameEnumerator = new nsMimeStringEnumerator();
NS_ENSURE_TRUE(headerNameEnumerator, NS_ERROR_OUT_OF_MEMORY);
nsRefPtr<nsMimeStringEnumerator> headerValueEnumerator = new nsMimeStringEnumerator();
NS_ENSURE_TRUE(headerValueEnumerator, NS_ERROR_OUT_OF_MEMORY);
nsCString extraExpandedHeaders;
nsTArray<nsCString> extraExpandedHeadersArray;
nsAutoCString convertedDateString;
nsresult rv;
nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
if (pPrefBranch)
{
pPrefBranch->GetCharPref("mailnews.headers.extraExpandedHeaders", getter_Copies(extraExpandedHeaders));
// todo - should make this upper case
if (!extraExpandedHeaders.IsEmpty())
{
ToLowerCase(extraExpandedHeaders);
ParseString(extraExpandedHeaders, ' ', extraExpandedHeadersArray);
}
}
for (int32_t i=0; i<mHeaderArray->Count(); i++)
{
headerInfoType * headerInfo = (headerInfoType *) mHeaderArray->ElementAt(i);
if ( (!headerInfo) || (!headerInfo->name) || (!(*headerInfo->name)) || (!headerInfo->value) || (!(*headerInfo->value)))
continue;
const char * headerValue = headerInfo->value;
// optimization: if we aren't in view all header view mode, we only show a small set of the total # of headers.
// don't waste time sending those out to the UI since the UI is going to ignore them anyway.
if (aHeaderMode != VIEW_ALL_HEADERS && (mFormat != nsMimeOutput::nsMimeMessageFilterSniffer))
{
nsDependentCString headerStr(headerInfo->name);
if (PL_strcasecmp("to", headerInfo->name) && PL_strcasecmp("from", headerInfo->name) &&
PL_strcasecmp("cc", headerInfo->name) && PL_strcasecmp("newsgroups", headerInfo->name) &&
PL_strcasecmp("bcc", headerInfo->name) && PL_strcasecmp("followup-to", headerInfo->name) &&
PL_strcasecmp("reply-to", headerInfo->name) && PL_strcasecmp("subject", headerInfo->name) &&
PL_strcasecmp("organization", headerInfo->name) && PL_strcasecmp("user-agent", headerInfo->name) &&
PL_strcasecmp("content-base", headerInfo->name) && PL_strcasecmp("sender", headerInfo->name) &&
PL_strcasecmp("date", headerInfo->name) && PL_strcasecmp("x-mailer", headerInfo->name) &&
PL_strcasecmp("content-type", headerInfo->name) && PL_strcasecmp("message-id", headerInfo->name) &&
PL_strcasecmp("x-newsreader", headerInfo->name) && PL_strcasecmp("x-mimeole", headerInfo->name) &&
PL_strcasecmp("references", headerInfo->name) && PL_strcasecmp("in-reply-to", headerInfo->name) &&
PL_strcasecmp("list-post", headerInfo->name) && PL_strcasecmp("delivered-to", headerInfo->name) &&
// make headerStr lower case because IndexOf is case-sensitive
(!extraExpandedHeadersArray.Length() || (ToLowerCase(headerStr),
extraExpandedHeadersArray.IndexOf(headerStr) ==
extraExpandedHeadersArray.NoIndex)))
continue;
}
headerNameEnumerator->Append(headerInfo->name);
headerValueEnumerator->Append(headerValue);
// Add a localized version of the date header if we encounter it.
if (!PL_strcasecmp("Date", headerInfo->name))
{
headerNameEnumerator->Append("X-Mozilla-LocalizedDate");
GenerateDateString(headerValue, convertedDateString, false);
headerValueEnumerator->Append(convertedDateString);
}
}
aHeaderSink->ProcessHeaders(headerNameEnumerator, headerValueEnumerator, aFromNewsgroup);
return rv;
}
//
// Given a content-type and some info about the contents of the document,
// decide what encoding it should have.
//
int
nsMsgAttachmentHandler::PickEncoding(const char *charset, nsIMsgSend *mime_delivery_state)
{
nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
bool needsB64 = false;
bool forceB64 = false;
if (m_already_encoded_p)
goto DONE;
AnalyzeSnarfedFile();
/* Allow users to override our percentage-wise guess on whether
the file is text or binary */
if (pPrefBranch)
pPrefBranch->GetBoolPref ("mail.file_attach_binary", &forceB64);
if (!mMainBody && (forceB64 || mime_type_requires_b64_p (m_type.get()) ||
m_have_cr+m_have_lf+m_have_crlf != 1 || m_current_column != 0))
{
/* If the content-type is "image/" or something else known to be binary
or several flavors of newlines are present or last line is incomplete,
always use base64 (so that we don't get confused by newline
conversions.)
*/
needsB64 = true;
}
else
{
/* Otherwise, we need to pick an encoding based on the contents of
the document.
*/
bool encode_p;
bool force_p = false;
/*
force quoted-printable if the sender does not allow
conversion to 7bit
*/
if (mCompFields) {
if (mCompFields->GetForceMsgEncoding())
force_p = true;
}
else if (mime_delivery_state) {
if (((nsMsgComposeAndSend *)mime_delivery_state)->mCompFields->GetForceMsgEncoding())
force_p = true;
}
if (force_p || (m_max_column > 900))
encode_p = true;
else if (UseQuotedPrintable() && m_unprintable_count)
encode_p = true;
else if (m_null_count) /* If there are nulls, we must always encode,
because sendmail will blow up. */
encode_p = true;
else
encode_p = false;
/* MIME requires a special case that these types never be encoded.
*/
if (StringBeginsWith(m_type, NS_LITERAL_CSTRING("message"),
nsCaseInsensitiveCStringComparator()) ||
StringBeginsWith(m_type, NS_LITERAL_CSTRING("multipart"),
nsCaseInsensitiveCStringComparator()))
{
encode_p = false;
if (m_desiredType.LowerCaseEqualsLiteral(TEXT_PLAIN))
m_desiredType.Truncate();
}
// If the Mail charset is multibyte, we force it to use Base64 for attachments.
if ((!mMainBody && charset && nsMsgI18Nmultibyte_charset(charset)) &&
(m_type.LowerCaseEqualsLiteral(TEXT_HTML) ||
m_type.LowerCaseEqualsLiteral(TEXT_MDL) ||
m_type.LowerCaseEqualsLiteral(TEXT_PLAIN) ||
m_type.LowerCaseEqualsLiteral(TEXT_RICHTEXT) ||
m_type.LowerCaseEqualsLiteral(TEXT_ENRICHED) ||
m_type.LowerCaseEqualsLiteral(TEXT_VCARD) ||
m_type.LowerCaseEqualsLiteral(APPLICATION_DIRECTORY) || /* text/x-vcard synonym */
m_type.LowerCaseEqualsLiteral(TEXT_CSS) ||
m_type.LowerCaseEqualsLiteral(TEXT_JSSS)))
needsB64 = true;
else if (charset && nsMsgI18Nstateful_charset(charset))
m_encoding = ENCODING_7BIT;
else if (encode_p &&
m_unprintable_count > (m_size / 10))
/* If the document contains more than 10% unprintable characters,
then that seems like a good candidate for base64 instead of
quoted-printable.
*/
needsB64 = true;
else if (encode_p)
m_encoding = ENCODING_QUOTED_PRINTABLE;
else if (m_highbit_count > 0)
m_encoding = ENCODING_8BIT;
else
m_encoding = ENCODING_7BIT;
}
// always base64 binary data.
if (needsB64)
m_encoding = ENCODING_BASE64;
/* Now that we've picked an encoding, initialize the filter.
*/
NS_ASSERTION(!m_encoder_data, "not-null m_encoder_data");
if (m_encoding.LowerCaseEqualsLiteral(ENCODING_BASE64))
{
m_encoder_data = MIME_B64EncoderInit(mime_encoder_output_fn,
mime_delivery_state);
if (!m_encoder_data) return NS_ERROR_OUT_OF_MEMORY;
}
else if (m_encoding.LowerCaseEqualsLiteral(ENCODING_QUOTED_PRINTABLE))
{
m_encoder_data = MIME_QPEncoderInit(mime_encoder_output_fn,
mime_delivery_state);
if (!m_encoder_data) return NS_ERROR_OUT_OF_MEMORY;
}
else
{
m_encoder_data = 0;
}
/* Do some cleanup for documents with unknown content type.
There are two issues: how they look to MIME users, and how they look to
non-MIME users.
If the user attaches a "README" file, which has unknown type because it
has no extension, we still need to send it with no encoding, so that it
is readable to non-MIME users.
But if the user attaches some random binary file, then base64 encoding
will have been chosen for it (above), and in this case, it won't be
immediately readable by non-MIME users. However, if we type it as
text/plain instead of application/octet-stream, it will show up inline
in a MIME viewer, which will probably be ugly, and may possibly have
bad charset things happen as well.
So, the heuristic we use is, if the type is unknown, then the type is
set to application/octet-stream for data which needs base64 (binary data)
and is set to text/plain for data which didn't need base64 (unencoded or
lightly encoded data.)
*/
DONE:
if (m_type.IsEmpty() || m_type.LowerCaseEqualsLiteral(UNKNOWN_CONTENT_TYPE))
{
if (m_already_encoded_p)
m_type = APPLICATION_OCTET_STREAM;
else if (m_encoding.LowerCaseEqualsLiteral(ENCODING_BASE64) ||
m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE))
m_type = APPLICATION_OCTET_STREAM;
else
m_type = TEXT_PLAIN;
}
return 0;
}
nsresult
nsMsgAttachmentHandler::UrlExit(nsresult status, const PRUnichar* aMsg)
{
NS_ASSERTION(m_mime_delivery_state != nsnull, "not-null m_mime_delivery_state");
// Close the file, but don't delete the disk file (or the file spec.)
if (mOutFile)
{
mOutFile->Close();
mOutFile = nsnull;
}
// this silliness is because Windows nsILocalFile caches its file size
// so if an output stream writes to it, it will still return the original
// cached size.
if (mTmpFile)
{
nsCOMPtr <nsIFile> tmpFile;
mTmpFile->Clone(getter_AddRefs(tmpFile));
mTmpFile = do_QueryInterface(tmpFile);
}
mRequest = nsnull;
// First things first, we are now going to see if this is an HTML
// Doc and if it is, we need to see if we can determine the charset
// for this part by sniffing the HTML file.
// This is needed only when the charset is not set already.
// (e.g. a charset may be specified in HTTP header)
//
if (!m_type.IsEmpty() && m_charset.IsEmpty() &&
m_type.LowerCaseEqualsLiteral(TEXT_HTML))
m_charset = nsMsgI18NParseMetaCharset(mTmpFile);
nsresult mimeDeliveryStatus;
m_mime_delivery_state->GetStatus(&mimeDeliveryStatus);
if (mimeDeliveryStatus == NS_ERROR_ABORT)
status = NS_ERROR_ABORT;
if (NS_FAILED(status) && status != NS_ERROR_ABORT && NS_SUCCEEDED(mimeDeliveryStatus))
{
// At this point, we should probably ask a question to the user
// if we should continue without this attachment.
//
bool keepOnGoing = true;
nsCString turl;
nsString msg;
PRUnichar *printfString = nsnull;
nsresult rv;
nsCOMPtr<nsIStringBundleService> bundleService(do_GetService("@mozilla.org/intl/stringbundle;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
nsMsgDeliverMode mode = nsIMsgSend::nsMsgDeliverNow;
m_mime_delivery_state->GetDeliveryMode(&mode);
if (mode == nsIMsgSend::nsMsgSaveAsDraft || mode == nsIMsgSend::nsMsgSaveAsTemplate)
bundle->GetStringFromID(NS_MSG_FAILURE_ON_OBJ_EMBED_WHILE_SAVING, getter_Copies(msg));
else
bundle->GetStringFromID(NS_MSG_FAILURE_ON_OBJ_EMBED_WHILE_SENDING, getter_Copies(msg));
if (!m_realName.IsEmpty())
printfString = nsTextFormatter::smprintf(msg.get(), m_realName.get());
else if (NS_SUCCEEDED(mURL->GetSpec(turl)) && !turl.IsEmpty())
{
nsCAutoString unescapedUrl;
MsgUnescapeString(turl, 0, unescapedUrl);
if (unescapedUrl.IsEmpty())
printfString = nsTextFormatter::smprintf(msg.get(), turl.get());
else
printfString = nsTextFormatter::smprintf(msg.get(), unescapedUrl.get());
}
else
printfString = nsTextFormatter::smprintf(msg.get(), "?");
nsCOMPtr<nsIPrompt> aPrompt;
if (m_mime_delivery_state)
m_mime_delivery_state->GetDefaultPrompt(getter_AddRefs(aPrompt));
nsMsgAskBooleanQuestionByString(aPrompt, printfString, &keepOnGoing);
PR_FREEIF(printfString);
if (keepOnGoing)
{
status = 0;
m_bogus_attachment = true; //That will cause this attachment to be ignored.
}
else
{
status = NS_ERROR_ABORT;
m_mime_delivery_state->SetStatus(status);
nsresult ignoreMe;
m_mime_delivery_state->Fail(status, nsnull, &ignoreMe);
m_mime_delivery_state->NotifyListenerOnStopSending(nsnull, status, 0, nsnull);
SetMimeDeliveryState(nsnull);
return status;
}
}
m_done = true;
//
// Ok, now that we have the file here on disk, we need to see if there was
// a need to do conversion to plain text...if so, the magic happens here,
// otherwise, just move on to other attachments...
//
if (NS_SUCCEEDED(status) && !m_type.LowerCaseEqualsLiteral(TEXT_PLAIN) &&
m_desiredType.LowerCaseEqualsLiteral(TEXT_PLAIN))
{
//
// Conversion to plain text desired.
//
PRInt32 width = 72;
nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (pPrefBranch)
pPrefBranch->GetIntPref("mailnews.wraplength", &width);
// Let sanity reign!
if (width == 0)
width = 72;
else if (width < 10)
width = 10;
else if (width > 30000)
width = 30000;
//
// Now use the converter service here to do the right
// thing and convert this data to plain text for us!
//
nsAutoString conData;
if (NS_SUCCEEDED(LoadDataFromFile(mTmpFile, conData, true)))
{
if (NS_SUCCEEDED(ConvertBufToPlainText(conData, UseFormatFlowed(m_charset.get()))))
{
if (mDeleteFile)
mTmpFile->Remove(false);
nsCOMPtr<nsIOutputStream> outputStream;
nsresult rv = NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), mTmpFile, PR_WRONLY | PR_CREATE_FILE, 00600);
if (NS_SUCCEEDED(rv))
{
nsCAutoString tData;
if (NS_FAILED(ConvertFromUnicode(m_charset.get(), conData, tData)))
LossyCopyUTF16toASCII(conData, tData);
if (!tData.IsEmpty())
{
PRUint32 bytesWritten;
(void) outputStream->Write(tData.get(), tData.Length(), &bytesWritten);
}
outputStream->Close();
// this silliness is because Windows nsILocalFile caches its file size
// so if an output stream writes to it, it will still return the original
// cached size.
if (mTmpFile)
{
nsCOMPtr <nsIFile> tmpFile;
mTmpFile->Clone(getter_AddRefs(tmpFile));
mTmpFile = do_QueryInterface(tmpFile);
}
}
}
}
m_type = m_desiredType;
m_desiredType.Truncate();
m_encoding.Truncate();
}
PRUint32 pendingAttachmentCount = 0;
m_mime_delivery_state->GetPendingAttachmentCount(&pendingAttachmentCount);
NS_ASSERTION (pendingAttachmentCount > 0, "no more pending attachment");
m_mime_delivery_state->SetPendingAttachmentCount(pendingAttachmentCount - 1);
bool processAttachmentsSynchronously = false;
m_mime_delivery_state->GetProcessAttachmentsSynchronously(&processAttachmentsSynchronously);
if (NS_SUCCEEDED(status) && processAttachmentsSynchronously)
{
/* Find the next attachment which has not yet been loaded,
if any, and start it going.
*/
PRUint32 i;
nsMsgAttachmentHandler *next = 0;
nsMsgAttachmentHandler *attachments = nsnull;
PRUint32 attachmentCount = 0;
m_mime_delivery_state->GetAttachmentCount(&attachmentCount);
if (attachmentCount)
m_mime_delivery_state->GetAttachmentHandlers(&attachments);
for (i = 0; i < attachmentCount; i++)
{
if (!attachments[i].m_done)
{
next = &attachments[i];
//
// rhp: We need to get a little more understanding to failed URL
// requests. So, at this point if most of next is NULL, then we
// should just mark it fetched and move on! We probably ignored
// this earlier on in the send process.
//
if ( (!next->mURL) && (next->m_uri.IsEmpty()) )
{
attachments[i].m_done = true;
m_mime_delivery_state->GetPendingAttachmentCount(&pendingAttachmentCount);
m_mime_delivery_state->SetPendingAttachmentCount(pendingAttachmentCount - 1);
next->mPartUserOmissionOverride = true;
next = nsnull;
continue;
}
break;
}
}
if (next)
{
int status = next->SnarfAttachment(mCompFields);
if (NS_FAILED(status))
{
nsresult ignoreMe;
m_mime_delivery_state->Fail(status, nsnull, &ignoreMe);
m_mime_delivery_state->NotifyListenerOnStopSending(nsnull, status, 0, nsnull);
SetMimeDeliveryState(nsnull);
return NS_ERROR_UNEXPECTED;
}
}
}
m_mime_delivery_state->GetPendingAttachmentCount(&pendingAttachmentCount);
if (pendingAttachmentCount == 0)
{
// If this is the last attachment, then either complete the
// delivery (if successful) or report the error by calling
// the exit routine and terminating the delivery.
if (NS_FAILED(status))
{
nsresult ignoreMe;
m_mime_delivery_state->Fail(status, aMsg, &ignoreMe);
m_mime_delivery_state->NotifyListenerOnStopSending(nsnull, status, aMsg, nsnull);
SetMimeDeliveryState(nsnull);
return NS_ERROR_UNEXPECTED;
}
else
{
status = m_mime_delivery_state->GatherMimeAttachments ();
if (NS_FAILED(status))
{
nsresult ignoreMe;
m_mime_delivery_state->Fail(status, aMsg, &ignoreMe);
m_mime_delivery_state->NotifyListenerOnStopSending(nsnull, status, aMsg, nsnull);
SetMimeDeliveryState(nsnull);
return NS_ERROR_UNEXPECTED;
}
}
}
else
{
// If this is not the last attachment, but it got an error,
// then report that error and continue
if (NS_FAILED(status))
{
nsresult ignoreMe;
m_mime_delivery_state->Fail(status, aMsg, &ignoreMe);
}
}
SetMimeDeliveryState(nsnull);
return NS_OK;
}
