NS_IMETHODIMP nsMsgMaildirStore::GetNewMsgOutputStream(nsIMsgFolder *aFolder, nsIMsgDBHdr **aNewMsgHdr, bool *aReusable, nsIOutputStream **aResult) { NS_ENSURE_ARG_POINTER(aFolder); NS_ENSURE_ARG_POINTER(aNewMsgHdr); NS_ENSURE_ARG_POINTER(aReusable); NS_ENSURE_ARG_POINTER(aResult); *aReusable = false; // message per file nsCOMPtr<nsIMsgDatabase> db; aFolder->GetMsgDatabase(getter_AddRefs(db)); if (!db) NS_ERROR("no db"); nsresult rv; if (!*aNewMsgHdr) { rv = db->CreateNewHdr(nsMsgKey_None, aNewMsgHdr); NS_ENSURE_SUCCESS(rv, rv); } (*aNewMsgHdr)->SetMessageOffset(0); // path to the message download folder nsCOMPtr<nsIFile> newFile; rv = aFolder->GetFilePath(getter_AddRefs(newFile)); NS_ENSURE_SUCCESS(rv, rv); newFile->Append(NS_LITERAL_STRING("tmp")); // let's check if the folder exists bool exists; newFile->Exists(&exists); if (!exists) { PR_LOG(MailDirLog, PR_LOG_ALWAYS, ("GetNewMsgOutputStream - tmp subfolder does not exist!!\n")); rv = newFile->Create(nsIFile::DIRECTORY_TYPE, 0755); NS_ENSURE_SUCCESS(rv, rv); } // generate new file name nsAutoCString newName; newName.AppendInt(static_cast<int64_t>(PR_Now())); newFile->AppendNative(newName); // CreateUnique, in case we get more than one message per millisecond :-) newFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600); newFile->GetNativeLeafName(newName); // save the file name in the message header - otherwise no way to retrieve it (*aNewMsgHdr)->SetStringProperty("storeToken", newName.get()); return MsgNewBufferedFileOutputStream(aResult, newFile, PR_WRONLY | PR_CREATE_FILE, 00600); }
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 nsMsgSaveAsListener::SetupMsgWriteStream(nsIFile *aFile, bool addDummyEnvelope) { // If the file already exists, delete it, but do this before // getting the outputstream. // Due to bug 328027, the nsSaveMsgListener created in // nsMessenger::SaveAs now opens the stream on the nsIFile // object, thus creating an empty file. Actual save operations for // IMAP and NNTP use this nsMsgSaveAsListener here, though, so we // have to close the stream before deleting the file, else data // would still be written happily into a now non-existing file. // (Windows doesn't care, btw, just unixoids do...) aFile->Remove(false); nsCOMPtr <nsILocalFile> localFile = do_QueryInterface(aFile); nsresult rv = MsgNewBufferedFileOutputStream(getter_AddRefs(m_outputStream), localFile, -1, 00600); NS_ENSURE_SUCCESS(rv, rv); if (m_outputStream && addDummyEnvelope) { nsCAutoString result; PRUint32 writeCount; time_t now = time((time_t*) 0); char *ct = ctime(&now); // Remove the ending new-line character. ct[24] = '\0'; result = "From - "; result += ct; result += MSG_LINEBREAK; m_outputStream->Write(result.get(), result.Length(), &writeCount); result = "X-Mozilla-Status: 0001"; result += MSG_LINEBREAK; result += "X-Mozilla-Status2: 00000000"; result += MSG_LINEBREAK; m_outputStream->Write(result.get(), result.Length(), &writeCount); } return rv; }
NS_IMETHODIMP nsMsgFilterList::GetLogStream(nsIOutputStream **aLogStream) { NS_ENSURE_ARG_POINTER(aLogStream); nsresult rv; if (!m_logStream) { nsCOMPtr <nsIFile> logFile; rv = GetLogFile(getter_AddRefs(logFile)); NS_ENSURE_SUCCESS(rv,rv); // append to the end of the log file rv = MsgNewBufferedFileOutputStream(getter_AddRefs(m_logStream), logFile, PR_CREATE_FILE | PR_WRONLY | PR_APPEND, 0600); NS_ENSURE_SUCCESS(rv,rv); if (!m_logStream) return NS_ERROR_FAILURE; int64_t fileSize; rv = logFile->GetFileSize(&fileSize); NS_ENSURE_SUCCESS(rv, rv); // write the header at the start if (fileSize == 0) { uint32_t writeCount; rv = m_logStream->Write(LOG_HEADER, LOG_HEADER_LEN, &writeCount); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(writeCount == LOG_HEADER_LEN, "failed to write out log header"); } } NS_ADDREF(*aLogStream = m_logStream); return NS_OK; }
NS_IMETHODIMP nsSpamSettings::GetLogStream(nsIOutputStream **aLogStream) { NS_ENSURE_ARG_POINTER(aLogStream); nsresult rv; if (!mLogStream) { nsCOMPtr <nsILocalFile> logFile = do_QueryInterface(mLogFile, &rv); NS_ENSURE_SUCCESS(rv,rv); // append to the end of the log file rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mLogStream), logFile, PR_CREATE_FILE | PR_WRONLY | PR_APPEND, 0600); NS_ENSURE_SUCCESS(rv, rv); PRInt64 fileSize; rv = logFile->GetFileSize(&fileSize); NS_ENSURE_SUCCESS(rv, rv); PRUint32 fileLen; LL_L2UI(fileLen, fileSize); // write the header at the start if (fileLen == 0) { PRUint32 writeCount; rv = mLogStream->Write(LOG_HEADER, LOG_HEADER_LEN, &writeCount); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(writeCount == LOG_HEADER_LEN, "failed to write out log header"); } } NS_ADDREF(*aLogStream = mLogStream); return NS_OK; }
bool CMapiMessage::CopyMsgAttachToFile(LPATTACH lpAttach, /*out*/ nsIFile **tmp_file) { bool bResult = true; LPMESSAGE lpMsg; HRESULT hr = lpAttach->OpenProperty(PR_ATTACH_DATA_OBJ, &IID_IMessage, 0, 0, reinterpret_cast<LPUNKNOWN *>(&lpMsg)); NS_ENSURE_SUCCESS(hr, false); if (!GetTmpFile(tmp_file)) return false; nsCOMPtr<nsIOutputStream> destOutputStream; nsresult rv = MsgNewBufferedFileOutputStream(getter_AddRefs(destOutputStream), *tmp_file, -1, 0600); if (NS_SUCCEEDED(rv)) rv = nsOutlookMail::ImportMessage(lpMsg, destOutputStream, nsIMsgSend::nsMsgSaveAsDraft); if (NS_FAILED(rv)) { (*tmp_file)->Remove(false); (*tmp_file)->Release(); *tmp_file = 0; } return NS_SUCCEEDED(rv); }
int MimePartBufferWrite (MimePartBufferData *data, const char *buf, PRInt32 size) { NS_ASSERTION(data && buf && size > 0, "MimePartBufferWrite: Bad param"); if (!data || !buf || size <= 0) return -1; /* If we don't yet have a buffer (either memory or file) try and make a memory buffer. */ if (!data->part_buffer && !data->file_buffer) { int target_size = TARGET_MEMORY_BUFFER_SIZE; while (target_size > 0) { data->part_buffer = (char *) PR_MALLOC(target_size); if (data->part_buffer) break; /* got it! */ target_size -= TARGET_MEMORY_BUFFER_QUANTUM; /* decrease it and try again */ } if (data->part_buffer) data->part_buffer_size = target_size; else data->part_buffer_size = 0; data->part_buffer_fp = 0; } /* Ok, if at this point we still don't have either kind of buffer, try and make a file buffer. */ if (!data->part_buffer && !data->file_buffer) { nsCOMPtr <nsIFile> tmpFile; nsresult rv = nsMsgCreateTempFile("nsma", getter_AddRefs(tmpFile)); NS_ENSURE_SUCCESS(rv, MIME_UNABLE_TO_OPEN_TMP_FILE); data->file_buffer = do_QueryInterface(tmpFile); rv = MsgNewBufferedFileOutputStream(getter_AddRefs(data->output_file_stream), data->file_buffer, PR_WRONLY | PR_CREATE_FILE, 00600); NS_ENSURE_SUCCESS(rv, rv); } NS_ASSERTION(data->part_buffer || data->output_file_stream, "no part_buffer or file_stream"); /* If this buf will fit in the memory buffer, put it there. */ if (data->part_buffer && data->part_buffer_fp + size < data->part_buffer_size) { memcpy(data->part_buffer + data->part_buffer_fp, buf, size); data->part_buffer_fp += size; } /* Otherwise it won't fit; write it to the file instead. */ else { /* If the file isn't open yet, open it, and dump the memory buffer to it. */ if (!data->output_file_stream) { nsresult rv; if (!data->file_buffer) { nsCOMPtr <nsIFile> tmpFile; rv = nsMsgCreateTempFile("nsma", getter_AddRefs(tmpFile)); NS_ENSURE_SUCCESS(rv, MIME_UNABLE_TO_OPEN_TMP_FILE); data->file_buffer = do_QueryInterface(tmpFile); } rv = MsgNewBufferedFileOutputStream(getter_AddRefs(data->output_file_stream), data->file_buffer, PR_WRONLY | PR_CREATE_FILE, 00600); NS_ENSURE_SUCCESS(rv, MIME_UNABLE_TO_OPEN_TMP_FILE); if (data->part_buffer && data->part_buffer_fp) { PRUint32 bytesWritten; nsresult rv = data->output_file_stream->Write(data->part_buffer, data->part_buffer_fp, &bytesWritten); NS_ENSURE_SUCCESS(rv, rv); } PR_FREEIF(data->part_buffer); data->part_buffer_fp = 0; data->part_buffer_size = 0; } /* Dump this buf to the file. */ PRUint32 bytesWritten; nsresult rv = data->output_file_stream->Write (buf, size, &bytesWritten); if (NS_FAILED(rv) || (PRInt32) bytesWritten < size) return MIME_OUT_OF_MEMORY; } return 0; }
NS_IMETHODIMP nsAppleMailImportMail::ImportMailbox(nsIImportMailboxDescriptor *aMailbox, nsIFile *aDestination, PRUnichar **aErrorLog, PRUnichar **aSuccessLog, bool *aFatalError) { nsAutoString errorLog, successLog; // reset progress mProgress = 0; nsAutoString mailboxName; aMailbox->GetDisplayName(getter_Copies(mailboxName)); nsCOMPtr<nsILocalFile> mboxFolder; nsresult rv = aMailbox->GetFile(getter_AddRefs(mboxFolder)); if (NS_FAILED(rv) || !mboxFolder) { ReportStatus(APPLEMAILIMPORT_MAILBOX_CONVERTERROR, mailboxName, errorLog); SetLogs(successLog, errorLog, aSuccessLog, aErrorLog); return NS_ERROR_FAILURE; } // if we're an account mailbox, nothing do. if we're a real mbox // then we've got some messages to import! PRUint32 mailboxIdentifier; aMailbox->GetIdentifier(&mailboxIdentifier); if (mailboxIdentifier != kAccountMailboxID) { // move to the .mbox's Messages folder nsCOMPtr<nsIFile> messagesFolder; mboxFolder->Clone(getter_AddRefs(messagesFolder)); rv = messagesFolder->Append(NS_LITERAL_STRING("Messages")); if (NS_FAILED(rv)) { // even if there are no messages, it might still be a valid mailbox, or even // a parent for other mailboxes. // // just indicate that we're done, using the same number that we used to estimate // number of messages earlier. PRUint32 finalSize; aMailbox->GetSize(&finalSize); mProgress = finalSize; // report that we successfully imported this mailbox ReportStatus(APPLEMAILIMPORT_MAILBOX_SUCCESS, mailboxName, successLog); SetLogs(successLog, errorLog, aSuccessLog, aErrorLog); return NS_OK; } // let's import the messages! nsCOMPtr<nsISimpleEnumerator> directoryEnumerator; rv = messagesFolder->GetDirectoryEntries(getter_AddRefs(directoryEnumerator)); if (NS_FAILED(rv)) { ReportStatus(APPLEMAILIMPORT_MAILBOX_CONVERTERROR, mailboxName, errorLog); SetLogs(successLog, errorLog, aSuccessLog, aErrorLog); return NS_ERROR_FAILURE; } // prepare an outstream to the destination file nsCOMPtr<nsIOutputStream> outStream; rv = MsgNewBufferedFileOutputStream(getter_AddRefs(outStream), aDestination); if (!outStream || NS_FAILED(rv)) { ReportStatus(APPLEMAILIMPORT_MAILBOX_CONVERTERROR, mailboxName, errorLog); SetLogs(successLog, errorLog, aSuccessLog, aErrorLog); return NS_ERROR_FAILURE; } bool hasMore = false; while (NS_SUCCEEDED(directoryEnumerator->HasMoreElements(&hasMore)) && hasMore) { // get the next file entry nsCOMPtr<nsILocalFile> currentEntry; { nsCOMPtr<nsISupports> rawSupports; directoryEnumerator->GetNext(getter_AddRefs(rawSupports)); if (!rawSupports) continue; currentEntry = do_QueryInterface(rawSupports); if (!currentEntry) continue; } // make sure it's an .emlx file bool isFile = false; currentEntry->IsFile(&isFile); if (!isFile) continue; nsAutoString leafName; currentEntry->GetLeafName(leafName); if (!StringEndsWith(leafName, NS_LITERAL_STRING(".emlx"))) continue; // add the data to the mbox stream if (NS_SUCCEEDED(nsEmlxHelperUtils::AddEmlxMessageToStream(currentEntry, outStream))) mProgress++; } } // just indicate that we're done, using the same number that we used to estimate // number of messages earlier. PRUint32 finalSize; aMailbox->GetSize(&finalSize); mProgress = finalSize; // report that we successfully imported this mailbox ReportStatus(APPLEMAILIMPORT_MAILBOX_SUCCESS, mailboxName, successLog); SetLogs(successLog, errorLog, aSuccessLog, aErrorLog); return NS_OK; }
nsresult nsAbManager::ExportDirectoryToLDIF(nsIAbDirectory *aDirectory, nsILocalFile *aLocalFile) { nsCOMPtr <nsISimpleEnumerator> cardsEnumerator; nsCOMPtr <nsIAbCard> card; nsresult rv; nsCOMPtr <nsIOutputStream> outputStream; rv = MsgNewBufferedFileOutputStream(getter_AddRefs(outputStream), aLocalFile, PR_CREATE_FILE | PR_WRONLY | PR_TRUNCATE, 0664); // the desired file may be read only if (NS_FAILED(rv)) return rv; // Get the default attribute map for ldap. We use the default attribute // map rather than one for a specific server because if people want an // ldif export using a servers specific schema, then they can use ldapsearch nsCOMPtr<nsIAbLDAPAttributeMapService> mapSrv = do_GetService("@mozilla.org/addressbook/ldap-attribute-map-service;1", &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIAbLDAPAttributeMap> attrMap; rv = mapSrv->GetMapForPrefBranch(NS_LITERAL_CSTRING("ldap_2.servers.default.attrmap"), getter_AddRefs(attrMap)); NS_ENSURE_SUCCESS(rv, rv); PRUint32 i; PRUint32 writeCount; PRUint32 length; rv = aDirectory->GetChildCards(getter_AddRefs(cardsEnumerator)); if (NS_SUCCEEDED(rv) && cardsEnumerator) { nsCOMPtr<nsISupports> item; bool more; while (NS_SUCCEEDED(cardsEnumerator->HasMoreElements(&more)) && more) { rv = cardsEnumerator->GetNext(getter_AddRefs(item)); if (NS_SUCCEEDED(rv)) { nsCOMPtr <nsIAbCard> card = do_QueryInterface(item, &rv); NS_ENSURE_SUCCESS(rv,rv); bool isMailList; rv = card->GetIsMailList(&isMailList); NS_ENSURE_SUCCESS(rv,rv); if (isMailList) { nsCString mailListCStr; rv = AppendLDIFForMailList(card, attrMap, mailListCStr); NS_ENSURE_SUCCESS(rv,rv); length = mailListCStr.Length(); rv = outputStream->Write(mailListCStr.get(), length, &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (length != writeCount) return NS_ERROR_FAILURE; } else { nsString value; nsCString valueCStr; rv = AppendBasicLDIFForCard(card, attrMap, valueCStr); NS_ENSURE_SUCCESS(rv,rv); length = valueCStr.Length(); rv = outputStream->Write(valueCStr.get(), length, &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (length != writeCount) return NS_ERROR_FAILURE; valueCStr.Truncate(); nsCAutoString ldapAttribute; for (i = 0; i < NS_ARRAY_LENGTH(EXPORT_ATTRIBUTES_TABLE); i++) { if (NS_SUCCEEDED(attrMap->GetFirstAttribute(nsDependentCString(EXPORT_ATTRIBUTES_TABLE[i].abPropertyName), ldapAttribute)) && !ldapAttribute.IsEmpty()) { rv = card->GetPropertyAsAString(EXPORT_ATTRIBUTES_TABLE[i].abPropertyName, value); if (NS_FAILED(rv)) value.Truncate(); if (!PL_strcmp(EXPORT_ATTRIBUTES_TABLE[i].abPropertyName, kPreferMailFormatProperty)) { if (value.EqualsLiteral("html")) value.AssignLiteral("true"); else if (value.EqualsLiteral("plaintext")) value.AssignLiteral("false"); else value.Truncate(); // unknown. } if (!value.IsEmpty()) { rv = AppendProperty(ldapAttribute.get(), value.get(), valueCStr); NS_ENSURE_SUCCESS(rv,rv); valueCStr += MSG_LINEBREAK; } else valueCStr.Truncate(); length = valueCStr.Length(); if (length) { rv = outputStream->Write(valueCStr.get(), length, &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (length != writeCount) return NS_ERROR_FAILURE; } valueCStr.Truncate(); } else { // something we don't support yet // ldif doesn't export multiple addresses } } // write out the linebreak that separates the cards rv = outputStream->Write(MSG_LINEBREAK, MSG_LINEBREAK_LEN, &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (MSG_LINEBREAK_LEN != writeCount) return NS_ERROR_FAILURE; } } } } rv = outputStream->Flush(); NS_ENSURE_SUCCESS(rv,rv); rv = outputStream->Close(); NS_ENSURE_SUCCESS(rv,rv); return NS_OK; }
nsresult nsAbManager::ExportDirectoryToDelimitedText(nsIAbDirectory *aDirectory, const char *aDelim, PRUint32 aDelimLen, nsILocalFile *aLocalFile) { nsCOMPtr <nsISimpleEnumerator> cardsEnumerator; nsCOMPtr <nsIAbCard> card; nsresult rv; nsCOMPtr <nsIOutputStream> outputStream; rv = MsgNewBufferedFileOutputStream(getter_AddRefs(outputStream), aLocalFile, PR_CREATE_FILE | PR_WRONLY | PR_TRUNCATE, 0664); // the desired file may be read only if (NS_FAILED(rv)) return rv; PRUint32 i; PRUint32 writeCount; PRUint32 length; nsCOMPtr<nsIStringBundleService> bundleService = do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIStringBundle> bundle; rv = bundleService->CreateBundle("chrome://messenger/locale/importMsgs.properties", getter_AddRefs(bundle)); NS_ENSURE_SUCCESS(rv, rv); nsCString revisedName; nsString columnName; for (i = 0; i < NS_ARRAY_LENGTH(EXPORT_ATTRIBUTES_TABLE); i++) { if (EXPORT_ATTRIBUTES_TABLE[i].plainTextStringID != 0) { // We don't need to truncate the string here as getter_Copies will // do that for us. if (NS_FAILED(bundle->GetStringFromID(EXPORT_ATTRIBUTES_TABLE[i].plainTextStringID, getter_Copies(columnName)))) columnName.AppendInt(EXPORT_ATTRIBUTES_TABLE[i].plainTextStringID); rv = nsMsgI18NConvertFromUnicode(nsMsgI18NFileSystemCharset(), columnName, revisedName); NS_ENSURE_SUCCESS(rv,rv); rv = outputStream->Write(revisedName.get(), revisedName.Length(), &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (revisedName.Length() != writeCount) return NS_ERROR_FAILURE; if (i < NS_ARRAY_LENGTH(EXPORT_ATTRIBUTES_TABLE) - 1) { rv = outputStream->Write(aDelim, aDelimLen, &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (aDelimLen != writeCount) return NS_ERROR_FAILURE; } } } rv = outputStream->Write(MSG_LINEBREAK, MSG_LINEBREAK_LEN, &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (MSG_LINEBREAK_LEN != writeCount) return NS_ERROR_FAILURE; rv = aDirectory->GetChildCards(getter_AddRefs(cardsEnumerator)); if (NS_SUCCEEDED(rv) && cardsEnumerator) { nsCOMPtr<nsISupports> item; bool more; while (NS_SUCCEEDED(cardsEnumerator->HasMoreElements(&more)) && more) { rv = cardsEnumerator->GetNext(getter_AddRefs(item)); if (NS_SUCCEEDED(rv)) { nsCOMPtr <nsIAbCard> card = do_QueryInterface(item, &rv); NS_ENSURE_SUCCESS(rv,rv); bool isMailList; rv = card->GetIsMailList(&isMailList); NS_ENSURE_SUCCESS(rv,rv); if (isMailList) { // .tab, .txt and .csv aren't able to export mailing lists // use LDIF for that. } else { nsString value; nsCString valueCStr; for (i = 0; i < NS_ARRAY_LENGTH(EXPORT_ATTRIBUTES_TABLE); i++) { if (EXPORT_ATTRIBUTES_TABLE[i].plainTextStringID != 0) { rv = card->GetPropertyAsAString(EXPORT_ATTRIBUTES_TABLE[i].abPropertyName, value); if (NS_FAILED(rv)) value.Truncate(); // If a string contains at least one comma, tab or double quote then // we need to quote the entire string. Also if double quote is part // of the string we need to quote the double quote(s) as well. nsAutoString newValue(value); bool needsQuotes = false; if(newValue.FindChar('"') != -1) { needsQuotes = PR_TRUE; PRInt32 match = 0; PRUint32 offset = 0; nsString oldSubstr = NS_LITERAL_STRING("\""); nsString newSubstr = NS_LITERAL_STRING("\"\""); while (offset < newValue.Length()) { match = newValue.Find(oldSubstr, offset); if (match == -1) break; newValue.Replace(offset + match, oldSubstr.Length(), newSubstr); offset += (match + newSubstr.Length()); } } if (!needsQuotes && (newValue.FindChar(',') != -1 || newValue.FindChar('\x09') != -1)) needsQuotes = PR_TRUE; // Make sure we quote if containing CR/LF. if (newValue.FindChar('\r') != -1 || newValue.FindChar('\n') != -1) needsQuotes = PR_TRUE; if (needsQuotes) { newValue.Insert(NS_LITERAL_STRING("\""), 0); newValue.AppendLiteral("\""); } rv = nsMsgI18NConvertFromUnicode(nsMsgI18NFileSystemCharset(), newValue, valueCStr); NS_ENSURE_SUCCESS(rv,rv); if (NS_FAILED(rv)) { NS_ERROR("failed to convert string to system charset. use LDIF"); valueCStr = "?"; } length = valueCStr.Length(); if (length) { rv = outputStream->Write(valueCStr.get(), length, &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (length != writeCount) return NS_ERROR_FAILURE; } valueCStr = ""; } else { // something we don't support for the current export // for example, .tab doesn't export preferred html format continue; // go to next field } if (i < NS_ARRAY_LENGTH(EXPORT_ATTRIBUTES_TABLE) - 1) { rv = outputStream->Write(aDelim, aDelimLen, &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (aDelimLen != writeCount) return NS_ERROR_FAILURE; } } // write out the linebreak that separates the cards rv = outputStream->Write(MSG_LINEBREAK, MSG_LINEBREAK_LEN, &writeCount); NS_ENSURE_SUCCESS(rv,rv); if (MSG_LINEBREAK_LEN != writeCount) return NS_ERROR_FAILURE; } } } } rv = outputStream->Flush(); NS_ENSURE_SUCCESS(rv,rv); rv = outputStream->Close(); NS_ENSURE_SUCCESS(rv,rv); return NS_OK; }
static int MimeMultipartRelated_parse_child_line (MimeObject *obj, const char *line, int32_t length, bool first_line_p) { MimeContainer *cont = (MimeContainer *) obj; MimeMultipartRelated *relobj = (MimeMultipartRelated *) obj; int status; MimeObject *kid; if (obj->options && !obj->options->write_html_p #ifdef MIME_DRAFTS && !obj->options->decompose_file_p #endif /* MIME_DRAFTS */ ) { /* Oh, just go do the normal thing... */ return ((MimeMultipartClass*)&MIME_SUPERCLASS)-> parse_child_line(obj, line, length, first_line_p); } /* Throw it away if this isn't the head object. (Someday, maybe we'll cache it instead.) */ PR_ASSERT(cont->nchildren > 0); if (cont->nchildren <= 0) return -1; kid = cont->children[cont->nchildren-1]; PR_ASSERT(kid); if (!kid) return -1; if (kid != relobj->headobj) return 0; /* Buffer this up (###tw much code duplication from mimemalt.c) */ /* If we don't yet have a buffer (either memory or file) try and make a memory buffer. */ if (!relobj->head_buffer && !relobj->file_buffer) { int target_size = 1024 * 50; /* try for 50k */ while (target_size > 0) { relobj->head_buffer = (char *) PR_MALLOC(target_size); if (relobj->head_buffer) break; /* got it! */ target_size -= (1024 * 5); /* decrease it and try again */ } if (relobj->head_buffer) { relobj->head_buffer_size = target_size; } else { relobj->head_buffer_size = 0; } relobj->head_buffer_fp = 0; } nsresult rv; /* Ok, if at this point we still don't have either kind of buffer, try and make a file buffer. */ if (!relobj->head_buffer && !relobj->file_buffer) { nsCOMPtr <nsIFile> file; rv = nsMsgCreateTempFile("nsma", getter_AddRefs(file)); NS_ENSURE_SUCCESS(rv, rv); relobj->file_buffer = do_QueryInterface(file); rv = MsgNewBufferedFileOutputStream(getter_AddRefs(relobj->output_file_stream), relobj->file_buffer, PR_WRONLY | PR_CREATE_FILE, 00600); NS_ENSURE_SUCCESS(rv, rv); } PR_ASSERT(relobj->head_buffer || relobj->output_file_stream); /* If this line will fit in the memory buffer, put it there. */ if (relobj->head_buffer && relobj->head_buffer_fp + length < relobj->head_buffer_size) { memcpy(relobj->head_buffer + relobj->head_buffer_fp, line, length); relobj->head_buffer_fp += length; } else { /* Otherwise it won't fit; write it to the file instead. */ /* If the file isn't open yet, open it, and dump the memory buffer to it. */ if (!relobj->output_file_stream) { if (!relobj->file_buffer) { nsCOMPtr <nsIFile> file; rv = nsMsgCreateTempFile("nsma", getter_AddRefs(file)); NS_ENSURE_SUCCESS(rv, rv); relobj->file_buffer = do_QueryInterface(file); } nsresult rv = MsgNewBufferedFileOutputStream(getter_AddRefs(relobj->output_file_stream), relobj->file_buffer, PR_WRONLY | PR_CREATE_FILE, 00600); NS_ENSURE_SUCCESS(rv, rv); if (relobj->head_buffer && relobj->head_buffer_fp) { uint32_t bytesWritten; status = relobj->output_file_stream->Write(relobj->head_buffer, relobj->head_buffer_fp, &bytesWritten); if (bytesWritten < relobj->head_buffer_fp) return MIME_UNABLE_TO_OPEN_TMP_FILE; } PR_FREEIF(relobj->head_buffer); relobj->head_buffer_fp = 0; relobj->head_buffer_size = 0; } /* Dump this line to the file. */ uint32_t bytesWritten; rv = relobj->output_file_stream->Write(line, length, &bytesWritten); if ((int32_t) bytesWritten < length || NS_FAILED(rv)) return MIME_UNABLE_TO_OPEN_TMP_FILE; } return 0; }
nsresult nsOutlookMail::ImportMailbox( PRUint32 *pDoneSoFar, bool *pAbort, PRInt32 index, const PRUnichar *pName, nsIFile *pDest, PRInt32 *pMsgCount) { if ((index < 0) || (index >= m_folderList.GetSize())) { IMPORT_LOG0( "*** Bad mailbox identifier, unable to import\n"); *pAbort = PR_TRUE; return( NS_ERROR_FAILURE); } PRInt32 dummyMsgCount = 0; if (pMsgCount) *pMsgCount = 0; else pMsgCount = &dummyMsgCount; CMapiFolder *pFolder = m_folderList.GetItem( index); OpenMessageStore( pFolder); if (!m_lpMdb) { IMPORT_LOG1( "*** Unable to obtain mapi message store for mailbox: %S\n", pName); return( NS_ERROR_FAILURE); } if (pFolder->IsStore()) return( NS_OK); nsresult rv; // now what? CMapiFolderContents contents( m_lpMdb, pFolder->GetCBEntryID(), pFolder->GetEntryID()); BOOL done = FALSE; ULONG cbEid; LPENTRYID lpEid; ULONG oType; LPMESSAGE lpMsg = nsnull; ULONG totalCount; PRFloat64 doneCalc; nsCOMPtr<nsIOutputStream> destOutputStream; rv = MsgNewBufferedFileOutputStream(getter_AddRefs(destOutputStream), pDest, -1, 0600); NS_ENSURE_SUCCESS(rv, rv); while (!done) { if (!contents.GetNext( &cbEid, &lpEid, &oType, &done)) { IMPORT_LOG1( "*** Error iterating mailbox: %S\n", pName); return( NS_ERROR_FAILURE); } totalCount = contents.GetCount(); doneCalc = *pMsgCount; doneCalc /= totalCount; doneCalc *= 1000; if (pDoneSoFar) { *pDoneSoFar = (PRUint32) doneCalc; if (*pDoneSoFar > 1000) *pDoneSoFar = 1000; } if (!done && (oType == MAPI_MESSAGE)) { if (!m_mapi.OpenMdbEntry( m_lpMdb, cbEid, lpEid, (LPUNKNOWN *) &lpMsg)) { IMPORT_LOG1( "*** Error opening messages in mailbox: %S\n", pName); return( NS_ERROR_FAILURE); } // See if it's a drafts folder. Outlook doesn't allow drafts // folder to be configured so it's ok to hard code it here. nsAutoString folderName(pName); nsMsgDeliverMode mode = nsIMsgSend::nsMsgDeliverNow; mode = nsIMsgSend::nsMsgSaveAsDraft; if ( folderName.LowerCaseEqualsLiteral("drafts") ) mode = nsIMsgSend::nsMsgSaveAsDraft; rv = ImportMessage(lpMsg, destOutputStream, mode); if (NS_SUCCEEDED( rv)) // No errors & really imported (*pMsgCount)++; else { IMPORT_LOG1( "*** Error reading message from mailbox: %S\n", pName); } } } return( NS_OK); }
void nsImapOfflineSync::ProcessAppendMsgOperation(nsIMsgOfflineImapOperation *currentOp, PRInt32 opType) { nsCOMPtr <nsIMsgDBHdr> mailHdr; nsMsgKey msgKey; currentOp->GetMessageKey(&msgKey); nsresult rv = m_currentDB->GetMsgHdrForKey(msgKey, getter_AddRefs(mailHdr)); if (NS_SUCCEEDED(rv) && mailHdr) { nsMsgKey messageOffset; PRUint32 messageSize; mailHdr->GetMessageOffset(&messageOffset); mailHdr->GetOfflineMessageSize(&messageSize); nsCOMPtr<nsIFile> tmpFile; if (NS_FAILED(GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR, "nscpmsg.txt", getter_AddRefs(tmpFile)))) return; if (NS_FAILED(tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600))) return; nsCOMPtr <nsIOutputStream> outputStream; rv = MsgNewBufferedFileOutputStream(getter_AddRefs(outputStream), tmpFile, PR_WRONLY | PR_CREATE_FILE, 00600); if (NS_SUCCEEDED(rv) && outputStream) { nsCString moveDestination; currentOp->GetDestinationFolderURI(getter_Copies(moveDestination)); nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv)); nsCOMPtr<nsIRDFResource> res; if (NS_FAILED(rv)) return ; // ### return error code. rv = rdf->GetResource(moveDestination, getter_AddRefs(res)); if (NS_SUCCEEDED(rv)) { nsCOMPtr<nsIMsgFolder> destFolder(do_QueryInterface(res, &rv)); if (NS_SUCCEEDED(rv) && destFolder) { nsCOMPtr <nsIInputStream> offlineStoreInputStream; rv = destFolder->GetOfflineStoreInputStream(getter_AddRefs(offlineStoreInputStream)); if (NS_SUCCEEDED(rv) && offlineStoreInputStream) { nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(offlineStoreInputStream); NS_ASSERTION(seekStream, "non seekable stream - can't read from offline msg"); if (seekStream) { rv = seekStream->Seek(PR_SEEK_SET, messageOffset); if (NS_SUCCEEDED(rv)) { // now, copy the dest folder offline store msg to the temp file PRInt32 inputBufferSize = 10240; char *inputBuffer = nsnull; while (!inputBuffer && (inputBufferSize >= 512)) { inputBuffer = (char *) PR_Malloc(inputBufferSize); if (!inputBuffer) inputBufferSize /= 2; } PRInt32 bytesLeft; PRUint32 bytesRead, bytesWritten; bytesLeft = messageSize; rv = NS_OK; while (bytesLeft > 0 && NS_SUCCEEDED(rv)) { PRInt32 bytesToRead = PR_MIN(inputBufferSize, bytesLeft); rv = offlineStoreInputStream->Read(inputBuffer, bytesToRead, &bytesRead); if (NS_SUCCEEDED(rv) && bytesRead > 0) { rv = outputStream->Write(inputBuffer, bytesRead, &bytesWritten); NS_ASSERTION(bytesWritten == bytesRead, "wrote out correct number of bytes"); } else break; bytesLeft -= bytesRead; } outputStream->Flush(); outputStream->Close(); if (NS_SUCCEEDED(rv)) { m_curTempFile = do_QueryInterface(tmpFile); nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID); if (copyService) rv = copyService->CopyFileMessage(tmpFile, destFolder, /* nsIMsgDBHdr* msgToReplace */ nsnull, PR_TRUE /* isDraftOrTemplate */, 0, // new msg flags - are there interesting flags here? EmptyCString(), /* are there keywords we should get? */ this, m_window); } else tmpFile->Remove(PR_FALSE); } currentOp->SetPlayingBack(PR_TRUE); m_currentOpsToClear.AppendObject(currentOp); m_currentDB->DeleteHeader(mailHdr, nsnull, PR_TRUE, PR_TRUE); } } // want to close in failure case too outputStream->Close(); } } } } }
nsresult nsMsgSendLater::DeliverQueuedLine(char *line, int32_t length) { int32_t flength = length; m_bytesRead += length; // convert existing newline to CRLF // Don't need this because the calling routine is taking care of it. // if (length > 0 && (line[length-1] == '\r' || // (line[length-1] == '\n' && (length < 2 || line[length-2] != '\r')))) // { // line[length-1] = '\r'; // line[length++] = '\n'; // } // // // We are going to check if we are looking at a "From - " line. If so, // then just eat it and return NS_OK // if (!PL_strncasecmp(line, "From - ", 7)) return NS_OK; if (m_inhead) { if (m_headersPosition == 0) { // This line is the first line in a header block. // Remember its position. m_headersPosition = m_position; // Also, since we're now processing the headers, clear out the // slots which we will parse data into, so that the values that // were used the last time around do not persist. // We must do that here, and not in the previous clause of this // `else' (the "I've just seen a `From ' line clause") because // that clause happens before delivery of the previous message is // complete, whereas this clause happens after the previous msg // has been delivered. If we did this up there, then only the // last message in the folder would ever be able to be both // mailed and posted (or fcc'ed.) PR_FREEIF(m_to); PR_FREEIF(m_bcc); PR_FREEIF(m_newsgroups); PR_FREEIF(m_newshost); PR_FREEIF(m_fcc); PR_FREEIF(mIdentityKey); } if (line[0] == '\r' || line[0] == '\n' || line[0] == 0) { // End of headers. Now parse them; open the temp file; // and write the appropriate subset of the headers out. m_inhead = false; nsresult rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mOutFile), mTempFile, -1, 00600); if (NS_FAILED(rv)) return NS_MSG_ERROR_WRITING_FILE; nsresult status = BuildHeaders(); if (NS_FAILED(status)) return status; uint32_t n; rv = mOutFile->Write(m_headers, m_headersFP, &n); if (NS_FAILED(rv) || n != (uint32_t)m_headersFP) return NS_MSG_ERROR_WRITING_FILE; } else { // Otherwise, this line belongs to a header. So append it to the // header data. if (!PL_strncasecmp (line, HEADER_X_MOZILLA_STATUS, PL_strlen(HEADER_X_MOZILLA_STATUS))) // Notice the position of the flags. m_flagsPosition = m_position; else if (m_headersFP == 0) m_flagsPosition = 0; nsresult status = do_grow_headers (length + m_headersFP + 10); if (NS_FAILED(status)) return status; memcpy(m_headers + m_headersFP, line, length); m_headersFP += length; } } else { // This is a body line. Write it to the file. PR_ASSERT(mOutFile); if (mOutFile) { uint32_t wrote; nsresult rv = mOutFile->Write(line, length, &wrote); if (NS_FAILED(rv) || wrote < (uint32_t) length) return NS_MSG_ERROR_WRITING_FILE; } } m_position += flength; return NS_OK; }
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; }
nsresult nsMsgAttachmentHandler::SnarfAttachment(nsMsgCompFields *compFields) { NS_ASSERTION (! m_done, "Already done"); if (!mURL) return SnarfMsgAttachment(compFields); mCompFields = compFields; // First, get as file spec and create the stream for the // temp file where we will save this data nsCOMPtr <nsIFile> tmpFile; nsresult rv = nsMsgCreateTempFile("nsmail.tmp", getter_AddRefs(tmpFile)); NS_ENSURE_SUCCESS(rv, rv); mTmpFile = do_QueryInterface(tmpFile); mDeleteFile = true; 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); } } mTmpFile->Remove(false); mTmpFile = nsnull; return NS_MSG_UNABLE_TO_OPEN_TMP_FILE; } nsCString sourceURISpec; mURL->GetSpec(sourceURISpec); #ifdef XP_MACOSX if (!m_bogus_attachment && StringBeginsWith(sourceURISpec, NS_LITERAL_CSTRING("file://"))) { // Unescape the path (i.e. un-URLify it) before making a FSSpec nsCAutoString filePath; filePath.Adopt(nsMsgGetLocalFileFromURL(sourceURISpec.get())); nsCAutoString unescapedFilePath; MsgUnescapeString(filePath, 0, unescapedFilePath); nsCOMPtr<nsILocalFile> sourceFile; NS_NewNativeLocalFile(unescapedFilePath, true, getter_AddRefs(sourceFile)); if (!sourceFile) return NS_ERROR_FAILURE; // check if it is a bundle. if it is, we'll zip it. // if not, we'll apple encode it (applesingle or appledouble) nsCOMPtr<nsILocalFileMac> macFile(do_QueryInterface(sourceFile)); bool isPackage; macFile->IsPackage(&isPackage); if (isPackage) rv = ConvertToZipFile(macFile); else rv = ConvertToAppleEncoding(sourceURISpec, unescapedFilePath, macFile); NS_ENSURE_SUCCESS(rv, rv); } #endif /* XP_MACOSX */ // // Ok, here we are, we need to fire the URL off and get the data // in the temp file // // Create a fetcher for the URL attachment... nsCOMPtr<nsIURLFetcher> fetcher = do_CreateInstance(NS_URLFETCHER_CONTRACTID, &rv); if (NS_FAILED(rv) || !fetcher) { if (NS_SUCCEEDED(rv)) return NS_ERROR_UNEXPECTED; else return rv; } return fetcher->FireURLRequest(mURL, mTmpFile, mOutFile, FetcherURLDoneCallback, this); }
nsresult nsMailboxProtocol::LoadUrl(nsIURI * aURL, nsISupports * aConsumer) { nsresult rv = NS_OK; // if we were already initialized with a consumer, use it... nsCOMPtr<nsIStreamListener> consumer = do_QueryInterface(aConsumer); if (consumer) m_channelListener = consumer; if (aURL) { m_runningUrl = do_QueryInterface(aURL); if (m_runningUrl) { // find out from the url what action we are supposed to perform... rv = m_runningUrl->GetMailboxAction(&m_mailboxAction); bool convertData = false; // need to check if we're fetching an rfc822 part in order to // quote a message. if (m_mailboxAction == nsIMailboxUrl::ActionFetchMessage) { nsCOMPtr<nsIMsgMailNewsUrl> msgUrl = do_QueryInterface(m_runningUrl, &rv); NS_ENSURE_SUCCESS(rv,rv); nsAutoCString queryStr; rv = msgUrl->GetQuery(queryStr); NS_ENSURE_SUCCESS(rv,rv); // check if this is a filter plugin requesting the message. // in that case, set up a text converter convertData = (queryStr.Find("header=filter") != -1 || queryStr.Find("header=attach") != -1); } else if (m_mailboxAction == nsIMailboxUrl::ActionFetchPart) { // when fetching a part, we need to insert a converter into the listener chain order to // force just the part out of the message. Our channel listener is the consumer we'll // pass in to AsyncConvertData. convertData = true; consumer = m_channelListener; } if (convertData) { nsCOMPtr<nsIStreamConverterService> streamConverter = do_GetService("@mozilla.org/streamConverters;1", &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr <nsIStreamListener> conversionListener; nsCOMPtr<nsIChannel> channel; QueryInterface(NS_GET_IID(nsIChannel), getter_AddRefs(channel)); rv = streamConverter->AsyncConvertData("message/rfc822", "*/*", consumer, channel, getter_AddRefs(m_channelListener)); } if (NS_SUCCEEDED(rv)) { switch (m_mailboxAction) { case nsIMailboxUrl::ActionParseMailbox: // extract the mailbox parser.. rv = m_runningUrl->GetMailboxParser(getter_AddRefs(m_mailboxParser)); m_nextState = MAILBOX_READ_FOLDER; break; case nsIMailboxUrl::ActionSaveMessageToDisk: // ohhh, display message already writes a msg to disk (as part of a hack) // so we can piggy back off of that!! We just need to change m_tempMessageFile // to be the name of our save message to disk file. Since save message to disk // urls are run without a docshell to display the msg into, we won't be trying // to display the message after we write it to disk... { nsCOMPtr<nsIMsgMessageUrl> messageUrl = do_QueryInterface(m_runningUrl, &rv); if (NS_SUCCEEDED(rv)) { messageUrl->GetMessageFile(getter_AddRefs(m_tempMessageFile)); rv = MsgNewBufferedFileOutputStream(getter_AddRefs(m_msgFileOutputStream), m_tempMessageFile, -1, 00600); NS_ENSURE_SUCCESS(rv, rv); bool addDummyEnvelope = false; messageUrl->GetAddDummyEnvelope(&addDummyEnvelope); if (addDummyEnvelope) SetFlag(MAILBOX_MSG_PARSE_FIRST_LINE); else ClearFlag(MAILBOX_MSG_PARSE_FIRST_LINE); } } m_nextState = MAILBOX_READ_MESSAGE; break; case nsIMailboxUrl::ActionCopyMessage: case nsIMailboxUrl::ActionMoveMessage: case nsIMailboxUrl::ActionFetchMessage: ClearFlag(MAILBOX_MSG_PARSE_FIRST_LINE); m_nextState = MAILBOX_READ_MESSAGE; break; case nsIMailboxUrl::ActionFetchPart: m_nextState = MAILBOX_READ_MESSAGE; break; default: break; } } rv = nsMsgProtocol::LoadUrl(aURL, m_channelListener); } // if we received an MAILBOX url... } // if we received a url! return rv; }