/**
* Determines if the content location is a scheme that we're willing to expose
* for unlimited loading of content.
*/
bool
nsMsgContentPolicy::IsExposedProtocol(nsIURI *aContentLocation)
{
nsCAutoString contentScheme;
nsresult rv = aContentLocation->GetScheme(contentScheme);
NS_ENSURE_SUCCESS(rv, false);
// If you are changing this list, you may need to also consider changing the
// list of network.protocol-handler.expose.* prefs in all-thunderbird.js.
if (MsgLowerCaseEqualsLiteral(contentScheme, "mailto") ||
MsgLowerCaseEqualsLiteral(contentScheme, "news") ||
MsgLowerCaseEqualsLiteral(contentScheme, "snews") ||
MsgLowerCaseEqualsLiteral(contentScheme, "nntp") ||
MsgLowerCaseEqualsLiteral(contentScheme, "imap") ||
MsgLowerCaseEqualsLiteral(contentScheme, "addbook") ||
MsgLowerCaseEqualsLiteral(contentScheme, "pop") ||
MsgLowerCaseEqualsLiteral(contentScheme, "mailbox") ||
MsgLowerCaseEqualsLiteral(contentScheme, "about"))
return true;
bool isData;
bool isChrome;
bool isRes;
rv = aContentLocation->SchemeIs("chrome", &isChrome);
rv |= aContentLocation->SchemeIs("resource", &isRes);
rv |= aContentLocation->SchemeIs("data", &isData);
NS_ENSURE_SUCCESS(rv, false);
return isChrome || isRes || isData;
}
// end of all #Settings arcs
nsresult
nsMsgAccountManagerDataSource::createSettingsResources(nsIRDFResource *aSource,
nsCOMArray<nsIRDFResource> *aNodeArray)
{
// If this isn't a server, just return.
if (aSource == kNC_PageTitleSMTP)
return NS_OK;
nsCOMPtr<nsIMsgIncomingServer> server;
getServerForFolderNode(aSource, getter_AddRefs(server));
if (server) {
bool hasIdentities;
nsresult rv = serverHasIdentities(server, &hasIdentities);
if (hasIdentities) {
aNodeArray->AppendObject(kNC_PageTitleServer);
aNodeArray->AppendObject(kNC_PageTitleCopies);
aNodeArray->AppendObject(kNC_PageTitleAddressing);
}
// Junk settings apply for all server types except for news and rss.
nsCString serverType;
server->GetType(serverType);
if (!MsgLowerCaseEqualsLiteral(serverType, "nntp") &&
!MsgLowerCaseEqualsLiteral(serverType, "rss"))
aNodeArray->AppendObject(kNC_PageTitleJunk);
// Check the offline capability before adding
// offline item
int32_t offlineSupportLevel = 0;
rv = server->GetOfflineSupportLevel(&offlineSupportLevel);
NS_ENSURE_SUCCESS(rv,rv);
bool supportsDiskSpace;
rv = server->GetSupportsDiskSpace(&supportsDiskSpace);
NS_ENSURE_SUCCESS(rv,rv);
// currently there is no offline without diskspace
if (offlineSupportLevel >= OFFLINE_SUPPORT_LEVEL_REGULAR)
aNodeArray->AppendObject(kNC_PageTitleSynchronization);
else if (supportsDiskSpace)
aNodeArray->AppendObject(kNC_PageTitleDiskSpace);
if (hasIdentities) {
// extensions come after the default panels
rv = appendGenericSettingsResources(server, aNodeArray);
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to add generic panels");
}
}
return NS_OK;
}
nsresult
nsImapMoveCopyMsgTxn::Init(nsIMsgFolder* srcFolder, nsTArray<nsMsgKey>* srcKeyArray,
const char* srcMsgIdString, nsIMsgFolder* dstFolder,
bool idsAreUids, bool isMove)
{
m_srcMsgIdString = srcMsgIdString;
m_idsAreUids = idsAreUids;
m_isMove = isMove;
m_srcFolder = do_GetWeakReference(srcFolder);
m_dstFolder = do_GetWeakReference(dstFolder);
m_srcKeyArray = *srcKeyArray;
m_dupKeyArray = *srcKeyArray;
nsCString uri;
nsresult rv = srcFolder->GetURI(uri);
nsCString protocolType(uri);
protocolType.SetLength(protocolType.FindChar(':'));
nsCOMPtr<nsIMsgDatabase> srcDB;
rv = srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
NS_ENSURE_SUCCESS(rv, rv);
uint32_t i, count = m_srcKeyArray.Length();
nsCOMPtr<nsIMsgDBHdr> srcHdr;
nsCOMPtr<nsIMsgDBHdr> copySrcHdr;
nsCString messageId;
for (i = 0; i < count; i++)
{
nsMsgKey pseudoKey;
rv = srcDB->GetMsgHdrForKey(m_srcKeyArray[i],
getter_AddRefs(srcHdr));
if (NS_SUCCEEDED(rv))
{
// ** jt -- only do this for mailbox protocol
if (MsgLowerCaseEqualsLiteral(protocolType, "mailbox"))
{
m_srcIsPop3 = true;
uint32_t msgSize;
rv = srcHdr->GetMessageSize(&msgSize);
if (NS_SUCCEEDED(rv))
m_srcSizeArray.AppendElement(msgSize);
if (isMove)
{
srcDB->GetNextPseudoMsgKey(&pseudoKey);
pseudoKey--;
m_dupKeyArray[i] = pseudoKey;
rv = srcDB->CopyHdrFromExistingHdr(pseudoKey, srcHdr, false,
getter_AddRefs(copySrcHdr));
if (NS_SUCCEEDED(rv))
m_srcHdrs.AppendObject(copySrcHdr);
}
}
srcHdr->GetMessageId(getter_Copies(messageId));
m_srcMessageIds.AppendElement(messageId);
}
}
return nsMsgTxn::Init();
}
/* void onStartRequest (in nsIRequest request, in nsISupports ctxt); */
NS_IMETHODIMP nsURLFetcherStreamConsumer::OnStartRequest(nsIRequest *aRequest, nsISupports *ctxt)
{
if (!mURLFetcher || !mURLFetcher->mOutStream)
return NS_ERROR_FAILURE;
/* In case of multipart/x-mixed-replace, we need to erase the output file content */
if (MsgLowerCaseEqualsLiteral(mURLFetcher->mConverterContentType, MULTIPART_MIXED_REPLACE))
{
nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(mURLFetcher->mOutStream);
if (seekStream)
seekStream->Seek(nsISeekableStream::NS_SEEK_SET, 0);
mURLFetcher->mTotalWritten = 0;
}
return NS_OK;
}
NS_IMETHODIMP
nsURLFetcher::OnStopRequest(nsIRequest *request, nsISupports * ctxt, nsresult aStatus)
{
// it's possible we could get in here from the channel calling us with an OnStopRequest and from our
// onStatusChange method (in the case of an error). So we should protect against this to make sure we
// don't process the on stop request twice...
if (mOnStopRequestProcessed)
return NS_OK;
mOnStopRequestProcessed = true;
/* first, call our converter or consumer */
if (mConverter)
(void) mConverter->OnStopRequest(request, ctxt, aStatus);
if (mTagData)
mTagData->mRequest = nullptr;
//
// Now complete the stream!
//
mStillRunning = false;
// time to close the output stream...
if (mOutStream)
{
mOutStream->Close();
mOutStream = nullptr;
/* In case of multipart/x-mixed-replace, we need to truncate the file to the current part size */
if (MsgLowerCaseEqualsLiteral(mConverterContentType, MULTIPART_MIXED_REPLACE))
{
mLocalFile->SetFileSize(mTotalWritten);
}
}
// Now if there is a callback, we need to call it...
if (mCallback)
mCallback (aStatus, mContentType, mCharset, mTotalWritten, nullptr, mTagData);
// Time to return...
return NS_OK;
}
nsresult
nsLocalMoveCopyMsgTxn::Init(nsIMsgFolder* srcFolder, nsIMsgFolder* dstFolder,
bool isMove)
{
nsresult rv;
rv = SetSrcFolder(srcFolder);
NS_ENSURE_SUCCESS(rv, rv);
rv = SetDstFolder(dstFolder);
NS_ENSURE_SUCCESS(rv, rv);
m_isMove = isMove;
mUndoFolderListener = nullptr;
nsCString protocolType;
rv = srcFolder->GetURI(protocolType);
protocolType.SetLength(protocolType.FindChar(':'));
if (MsgLowerCaseEqualsLiteral(protocolType, "imap"))
m_srcIsImap4 = true;
return nsMsgTxn::Init();
}
int
MimeHeaders_write_all_headers (MimeHeaders *hdrs, MimeDisplayOptions *opt, bool attachment)
{
int status = 0;
int i;
bool wrote_any_p = false;
NS_ASSERTION(hdrs, "1.1 <*****@*****.**> 19 Mar 1999 12:00");
if (!hdrs)
return -1;
/* One shouldn't be trying to read headers when one hasn't finished
parsing them yet... but this can happen if the message ended
prematurely, and has no body at all (as opposed to a null body,
which is more normal.) So, if we try to read from the headers,
let's assume that the headers are now finished. If they aren't
in fact finished, then a later attempt to write to them will assert.
*/
if (!hdrs->done_p)
{
hdrs->done_p = true;
status = MimeHeaders_build_heads_list(hdrs);
if (status < 0) return 0;
}
char *charset = nullptr;
if (opt->format_out == nsMimeOutput::nsMimeMessageSaveAs)
{
if (opt->override_charset)
charset = PL_strdup(opt->default_charset);
else
{
char *contentType = MimeHeaders_get(hdrs, HEADER_CONTENT_TYPE, false, false);
if (contentType)
charset = MimeHeaders_get_parameter(contentType, HEADER_PARM_CHARSET, nullptr, nullptr);
PR_FREEIF(contentType);
}
}
for (i = 0; i < hdrs->heads_size; i++)
{
char *head = hdrs->heads[i];
char *end = (i == hdrs->heads_size-1
? hdrs->all_headers + hdrs->all_headers_fp
: hdrs->heads[i+1]);
char *colon, *ocolon;
char *contents = end;
/* Hack for BSD Mailbox delimiter. */
if (i == 0 && head[0] == 'F' && !strncmp(head, "From ", 5))
{
/* For now, we don't really want this header to be output so
we are going to just continue */
continue;
/* colon = head + 4; contents = colon + 1; */
}
else
{
/* Find the colon. */
for (colon = head; colon < end && *colon != ':'; colon++)
;
/* Back up over whitespace before the colon. */
ocolon = colon;
for (; colon > head && IS_SPACE(colon[-1]); colon--)
;
contents = ocolon + 1;
}
/* Skip over whitespace after colon. */
while (contents < end && IS_SPACE(*contents))
contents++;
/* Take off trailing whitespace... */
while (end > contents && IS_SPACE(end[-1]))
end--;
nsCAutoString name(Substring(head, colon));
nsCAutoString hdr_value;
if ( (end - contents) > 0 )
{
hdr_value = Substring(contents, end);
}
// MW Fixme: more?
bool convert_charset_only =
MsgLowerCaseEqualsLiteral(name, "to") || MsgLowerCaseEqualsLiteral(name, "from") ||
MsgLowerCaseEqualsLiteral(name, "cc") || MsgLowerCaseEqualsLiteral(name, "bcc") ||
MsgLowerCaseEqualsLiteral(name, "reply-to") || MsgLowerCaseEqualsLiteral(name, "sender");
MimeHeaders_convert_header_value(opt, hdr_value, convert_charset_only);
// if we're saving as html, we need to convert headers from utf8 to message charset, if any
if (opt->format_out == nsMimeOutput::nsMimeMessageSaveAs && charset)
{
nsCAutoString convertedStr;
if (NS_SUCCEEDED(ConvertFromUnicode(charset, NS_ConvertUTF8toUTF16(hdr_value),
convertedStr)))
{
hdr_value = convertedStr;
}
}
if (attachment)
status = mimeEmitterAddAttachmentField(opt, name.get(), hdr_value.get());
else
status = mimeEmitterAddHeaderField(opt, name.get(), hdr_value.get());
if (status < 0) return status;
if (!wrote_any_p)
wrote_any_p = (status > 0);
}
mimeEmitterAddAllHeaders(opt, hdrs->all_headers, hdrs->all_headers_fp);
PR_FREEIF(charset);
return 1;
}
