Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-14 20:22:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix more mime header decoder callers, cleanup string fu: bug 65277 r=ducarroz r=nhotta sr=bienvenu

Browse Source
This commit is contained in:
jgmyers%netscape.com 2001-04-05 23:00:38 +00:00
parent a40bbf8ab9
commit 6b80312012
11 changed files with 241 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
mailnews/base/search/public/nsIMsgSearchTerm.idl
View File

@ -31,7 +31,7 @@ interface nsIMsgSearchScopeTerm;
native nsCStringRef(nsCString&);
[scriptable, uuid(52db94d7-71c8-46c9-9692-91ff880a8cb7)]
[scriptable, uuid(cc7795ce-1dd1-11b2-9ad2-dfa3c0b6ee09)]
interface nsIMsgSearchTerm : nsISupports {
attribute nsMsgSearchAttribValue attrib;
attribute nsMsgSearchOpValue op;
@ -40,9 +40,8 @@ interface nsIMsgSearchTerm : nsISupports {
attribute boolean booleanAnd;
attribute string arbitraryHeader;
boolean matchRfc822String(in string aString, in string charset);
boolean matchRfc2047String(in string aString, in string charset);
boolean matchString(in string aString, in string charset);
boolean matchRfc822String(in string aString, in string charset, in boolean charsetOverride);
boolean matchRfc2047String(in string aString, in string charset, in boolean charsetOverride);
boolean matchDate(in PRTime aTime);
boolean matchStatus(in unsigned long aStatus);
boolean matchPriority(in nsMsgPriorityValue priority);
@ -63,6 +62,7 @@ interface nsIMsgSearchTerm : nsISupports {
in unsigned long offset,
in unsigned long length,
in string charset,
in boolean charsetOverride,
in nsIMsgDBHdr msg,
in nsIMsgDatabase db,
//[array, size_is(headerLength)] in string headers,

3
mailnews/base/search/public/nsMsgSearchTerm.h
View File

@ -66,7 +66,6 @@ public:
// PRUint32 headersSize, /* size of the NULL terminated list of headers */
// PRBool ForFilters /* true if we are filtering */,
// PRBool *pResult);
// nsresult MatchString (nsCString *, const char *charset, PRBool body, PRBool *result);
// nsresult MatchDate (PRTime, PRBool *result);
// nsresult MatchStatus (PRUint32, PRBool *result);
// nsresult MatchPriority (nsMsgPriorityValue, PRBool *result);
@ -95,6 +94,8 @@ public:
nsCString m_arbitraryHeader; // user specified string for the name of the arbitrary header to be used in the search
// only has a value when m_attribute = attribOtherHeader!!!!
protected:
nsresult MatchString (const char *stringToMatch, const char *charset,
PRBool *pResult);
nsresult OutputValue(nsCString &outputStr);
nsMsgSearchAttribValue ParseAttribute(char *inStream);
nsMsgSearchOpValue ParseOperator(char *inStream);

15
mailnews/base/search/src/nsMsgLocalSearch.cpp
View File

@ -516,6 +516,7 @@ nsresult nsMsgSearchOfflineMail::MatchTerms(nsIMsgDBHdr *msgToMatch,
nsXPIDLCString matchString;
nsXPIDLCString msgCharset;
const char *charset;
PRBool charsetOverride = PR_FALSE; /* XXX BUG 68706 */
PRUint32 msgFlags;
PRBool result;
@ -554,12 +555,12 @@ nsresult nsMsgSearchOfflineMail::MatchTerms(nsIMsgDBHdr *msgToMatch,
{
case nsMsgSearchAttrib::Sender:
msgToMatch->GetAuthor(getter_Copies(matchString));
err = pTerm->MatchRfc822String (matchString, charset, &result);
err = pTerm->MatchRfc822String (matchString, charset, charsetOverride, &result);
break;
case nsMsgSearchAttrib::Subject:
{
msgToMatch->GetSubject(getter_Copies(matchString) /* , PR_TRUE */);
err = pTerm->MatchRfc2047String (matchString, charset, &result);
err = pTerm->MatchRfc2047String (matchString, charset, charsetOverride, &result);
}
break;
case nsMsgSearchAttrib::ToOrCC:
@ -567,11 +568,11 @@ nsresult nsMsgSearchOfflineMail::MatchTerms(nsIMsgDBHdr *msgToMatch,
PRBool boolKeepGoing;
pTerm->GetMatchAllBeforeDeciding(&boolKeepGoing);
msgToMatch->GetRecipients(getter_Copies(recipients));
err = pTerm->MatchRfc822String (recipients, charset, &result);
err = pTerm->MatchRfc822String (recipients, charset, charsetOverride, &result);
if (boolKeepGoing == result)
{
msgToMatch->GetCcList(getter_Copies(ccList));
err = pTerm->MatchRfc822String (ccList, charset, &result);
err = pTerm->MatchRfc822String (ccList, charset, charsetOverride, &result);
}
}
break;
@ -610,11 +611,11 @@ nsresult nsMsgSearchOfflineMail::MatchTerms(nsIMsgDBHdr *msgToMatch,
break;
case nsMsgSearchAttrib::To:
msgToMatch->GetRecipients(getter_Copies(recipients));
err = pTerm->MatchRfc822String(nsCAutoString(recipients), charset, &result);
err = pTerm->MatchRfc822String(nsCAutoString(recipients), charset, charsetOverride, &result);
break;
case nsMsgSearchAttrib::CC:
msgToMatch->GetCcList(getter_Copies(ccList));
err = pTerm->MatchRfc822String (nsCAutoString(ccList), charset, &result);
err = pTerm->MatchRfc822String (nsCAutoString(ccList), charset, charsetOverride, &result);
break;
case nsMsgSearchAttrib::AgeInDays:
{
@ -629,7 +630,7 @@ nsresult nsMsgSearchOfflineMail::MatchTerms(nsIMsgDBHdr *msgToMatch,
msgToMatch->GetLineCount(&lineCount);
nsMsgKey messageKey;
msgToMatch->GetMessageKey(&messageKey);
err = pTerm->MatchArbitraryHeader (scope, messageKey, lineCount,charset,
err = pTerm->MatchArbitraryHeader (scope, messageKey, lineCount,charset, charsetOverride,
msgToMatch, db, headers, headerSize, Filtering, &result);
}
break;

35
mailnews/base/search/src/nsMsgSearchTerm.cpp
View File

@ -37,6 +37,8 @@
#include "nsMsgSearchNews.h"
#include "nsMsgSearchValue.h"
#include "nsMsgI18N.h"
#include "nsIMimeConverter.h"
#include "nsMsgMimeCID.h"
//---------------------------------------------------------------------------
// nsMsgSearchTerm specifies one criterion, e.g. name contains phil
@ -600,6 +602,7 @@ nsresult nsMsgSearchTerm::MatchArbitraryHeader (nsIMsgSearchScopeTerm *scope,
PRUint32 offset,
PRUint32 length /* in lines*/,
const char *charset,
PRBool charsetOverride,
nsIMsgDBHdr *msg,
nsIMsgDatabase* db,
const char * headers,
@ -651,7 +654,7 @@ nsresult nsMsgSearchTerm::MatchArbitraryHeader (nsIMsgSearchScopeTerm *scope,
if (headerValue < buf_end && *headerValue) // make sure buf has info besides just the header
{
PRBool result2;
err = MatchRfc2047String(headerValue, charset, &result2); // match value with the other info...
err = MatchRfc2047String(headerValue, charset, charsetOverride, &result2); // match value with the other info...
if (result != result2) // if we found a match
{
searchingHeaders = PR_FALSE; // then stop examining the headers
@ -757,26 +760,24 @@ nsresult nsMsgSearchTerm::MatchBody (nsIMsgSearchScopeTerm *scope, PRUint32 offs
// *pResult is PR_FALSE when strings don't match, PR_TRUE if they do.
nsresult nsMsgSearchTerm::MatchRfc2047String (const char *rfc2047string,
const char *charset,
PRBool charsetOverride,
PRBool *pResult)
{
static NS_DEFINE_CID(kCMimeConverterCID, NS_MIME_CONVERTER_CID);
if (!pResult || !rfc2047string)
return NS_ERROR_NULL_POINTER;
PRBool mimedecode = PR_FALSE;
nsString decodedString, encodedString, cs;
const char *stringToMatch;
encodedString.AssignWithConversion(rfc2047string, -1);
nsresult res = nsMsgI18NDecodeMimePartIIStr(encodedString, cs, decodedString, PR_FALSE);
nsCOMPtr<nsIMimeConverter> mimeConverter = do_GetService(kCMimeConverterCID);
char *stringToMatch = 0;
nsresult res = mimeConverter->DecodeMimeHeader(rfc2047string,
&stringToMatch,
charset, charsetOverride);
if (NS_SUCCEEDED(res)) {
stringToMatch = decodedString.ToNewUTF8String();
mimedecode = PR_TRUE;
charset = nsnull;
}
else
stringToMatch = rfc2047string; // Try to match anyway
res = MatchString(stringToMatch ? stringToMatch : rfc2047string,
nsnull, pResult);
res = MatchString(stringToMatch, charset, pResult);
PR_FREEIF(stringToMatch);
return res;
}
@ -897,7 +898,7 @@ nsresult nsMsgSearchTerm::GetMatchAllBeforeDeciding (PRBool *aResult)
}
nsresult nsMsgSearchTerm::MatchRfc822String (const char *string, const char *charset, PRBool *pResult)
nsresult nsMsgSearchTerm::MatchRfc822String (const char *string, const char *charset, PRBool charsetOverride, PRBool *pResult)
{
if (!pResult)
return NS_ERROR_NULL_POINTER;
@ -934,9 +935,9 @@ nsresult nsMsgSearchTerm::MatchRfc822String (const char *string, const char *cha
PRInt32 addressPos = 0;
for (PRUint32 i = 0; i < count && result == boolContinueLoop; i++)
{
err = MatchRfc2047String (walkNames, charset, &result);
err = MatchRfc2047String (walkNames, charset, charsetOverride, &result);
if (boolContinueLoop == result)
err = MatchRfc2047String (walkAddresses, charset, &result);
err = MatchRfc2047String (walkAddresses, charset, charsetOverride, &result);
namePos += walkNames.Length() + 1;
addressPos += walkAddresses.Length() + 1;

15
mailnews/base/util/nsMsgI18N.cpp
View File

@ -399,21 +399,6 @@ char * nsMsgI18NEncodeMimePartIIStr(const char *header, const char *charset, PRB
return NS_SUCCEEDED(res) ? encodedString : nsnull;
}
// MIME decoder
nsresult nsMsgI18NDecodeMimePartIIStr(const nsString& header, nsString& charset, nsString& decodedString, PRBool eatContinuations)
{
nsIMimeConverter *converter;
nsresult res = nsComponentManager::CreateInstance(kCMimeConverterCID, nsnull,
NS_GET_IID(nsIMimeConverter), (void **)&converter);
if (NS_SUCCEEDED(res) && nsnull != converter) {
nsXPIDLString decodedUnichar;
res = converter->DecodeMimePartIIStr(header, charset, getter_Copies(decodedUnichar), eatContinuations);
decodedString = (const PRUnichar*)decodedUnichar;
NS_RELEASE(converter);
}
return res;
}
// Get a default mail character set.
char * nsMsgI18NGetDefaultMailCharset()
{

12
mailnews/base/util/nsMsgI18N.h
View File

@ -154,18 +154,6 @@ NS_MSG_BASE nsresult ConvertToUnicode(const nsString& aCharset,
const char* inCString,
nsString& outString);
/**
* If a header is MIME encoded then decode a header and sets a charset name.
*
* @param header [IN] A header to decode.
* @param charset [IN/OUT] Input charset to be used for conversion when no charset available in the header.
* Output charset to be set from the encoded charset name.
* @param decodedString [OUT] Decoded unicode string.
* @param eatContinuations [IN]
* @return nsresult.
*/
NS_MSG_BASE nsresult nsMsgI18NDecodeMimePartIIStr(const nsString& header, nsString& charset, nsString& decodedString, PRBool eatContinuations=PR_TRUE);
/**
* Parse for META charset.
*

204
mailnews/compose/src/nsMsgCompose.cpp
View File

@ -72,6 +72,7 @@
#include "nsIMsgMailSession.h"
#include "nsMsgBaseCID.h"
#include "nsIPrompt.h"
#include "nsMsgMimeCID.h"
#include "nsMsgComposeService.h"
#include "nsMsgUtils.h"
@ -80,6 +81,7 @@
static NS_DEFINE_CID(kHeaderParserCID, NS_MSGHEADERPARSER_CID);
static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
static NS_DEFINE_CID(kCMimeConverterCID, NS_MIME_CONVERTER_CID);
static PRInt32 GetReplyOnTop()
{
@ -96,7 +98,7 @@ static nsresult RemoveDuplicateAddresses(const char * addresses, const char * an
nsCOMPtr<nsIMsgHeaderParser> parser (do_GetService(kHeaderParserCID));
if (parser)
rv= parser->RemoveDuplicateAddresses(msgCompHeaderInternalCharset(), addresses, anothersAddresses, removeAliasesToMe, newAddress);
rv= parser->RemoveDuplicateAddresses("UTF-8", addresses, anothersAddresses, removeAliasesToMe, newAddress);
else
rv = NS_ERROR_FAILURE;
@ -261,7 +263,7 @@ nsresult nsMsgCompose::ConvertAndLoadComposeWindow(nsIEditorShell *aEditorShell,
aEditorShell->InsertAsCitedQuotation(aBuf.GetUnicode(),
mCiteReference.GetUnicode(),
PR_TRUE,
NS_ConvertASCIItoUCS2("UTF-8").GetUnicode(),
NS_LITERAL_STRING("UTF-8").get(),
getter_AddRefs(nodeInserted));
else
aEditorShell->InsertAsQuotation(aBuf.GetUnicode(),
@ -892,7 +894,7 @@ nsresult nsMsgCompose::CreateMessage(const char * originalMsgURI,
if (replyTo && *(const char *)replyTo)
{
if (replyToStr.Length() > 0)
replyToStr.AppendWithConversion(',');
replyToStr.Append(PRUnichar(','));
replyToStr.AppendWithConversion(replyTo);
}
@ -909,7 +911,7 @@ nsresult nsMsgCompose::CreateMessage(const char * originalMsgURI,
nsXPIDLCString email;
m_identity->GetEmail(getter_Copies(email));
if (bccStr.Length() > 0)
bccStr.AppendWithConversion(',');
bccStr.Append(PRUnichar(','));
bccStr.AppendWithConversion(email);
}
@ -919,7 +921,7 @@ nsresult nsMsgCompose::CreateMessage(const char * originalMsgURI,
nsXPIDLCString bccList;
m_identity->GetBccList(getter_Copies(bccList));
if (bccStr.Length() > 0)
bccStr.AppendWithConversion(',');
bccStr.Append(PRUnichar(','));
bccStr.AppendWithConversion(bccList);
}
m_compFields->SetBcc(bccStr.GetUnicode());
@ -947,18 +949,15 @@ nsresult nsMsgCompose::CreateMessage(const char * originalMsgURI,
if (msgHdr)
{
nsXPIDLCString subject;
nsAutoString subjectStr;
nsAutoString aCharset;
nsAutoString decodedString;
nsAutoString encodedCharset;
nsCString subjectStr;
nsXPIDLString decodedString;
nsXPIDLCString decodedCString;
PRBool charsetOverride = PR_FALSE;
nsXPIDLCString charset;
char *aCString = nsnull;
nsCOMPtr<nsIMimeConverter> mimeConverter = do_GetService(kCMimeConverterCID);
rv = msgHdr->GetCharset(getter_Copies(charset));
aCharset.AssignWithConversion(charset);
if (NS_FAILED(rv)) return rv;
rv = msgHdr->GetSubject(getter_Copies(subject));
if (NS_FAILED(rv)) return rv;
@ -986,57 +985,65 @@ nsresult nsMsgCompose::CreateMessage(const char * originalMsgURI,
{
nsXPIDLString mailCharset;
msgWindow->GetMailCharacterSet(getter_Copies(mailCharset));
if (mailCharset && (* (const PRUnichar *) mailCharset) )
aCharset = mailCharset;
if (mailCharset && (* (const PRUnichar *) mailCharset) ) {
charset = PL_strdup(NS_ConvertUCS2toUTF8(mailCharset).get());
charsetOverride = PR_TRUE;
}
}
}
// get an original charset, used for a label, UTF-8 is used for the internal processing
if (!aCharset.IsEmpty())
if (charset.get() && charset.get()[0])
{
nsCAutoString aCharsetCStr; aCharsetCStr.AssignWithConversion(aCharset);
m_compFields->SetCharacterSet(aCharsetCStr);
// set an original charset so MIME decoder can use it in case the header has no label
encodedCharset = aCharset;
}
m_compFields->SetCharacterSet(charset);
}
subjectStr.AppendWithConversion("Re: ");
subjectStr.AppendWithConversion(subject);
if (NS_SUCCEEDED(rv = nsMsgI18NDecodeMimePartIIStr(subjectStr, encodedCharset, decodedString)))
m_compFields->SetSubject(decodedString.GetUnicode());
else
m_compFields->SetSubject(subjectStr.GetUnicode());
subjectStr.Append("Re: ");
subjectStr.Append(subject);
rv = mimeConverter->DecodeMimeHeader(subjectStr.get(),
getter_Copies(decodedString),
charset, charsetOverride);
if (NS_SUCCEEDED(rv)) {
m_compFields->SetSubject(decodedString);
} else {
m_compFields->SetSubject(subjectStr);
}
nsXPIDLCString author;
rv = msgHdr->GetAuthor(getter_Copies(author));
if (NS_FAILED(rv)) return rv;
m_compFields->SetTo(author);
nsString authorStr; authorStr.AssignWithConversion(author);
if (NS_SUCCEEDED(rv = nsMsgI18NDecodeMimePartIIStr(authorStr, encodedCharset, decodedString)))
if (NS_SUCCEEDED(rv = ConvertFromUnicode(NS_ConvertASCIItoUCS2(msgCompHeaderInternalCharset()), decodedString, &aCString)))
{
m_compFields->SetTo(aCString);
PR_Free(aCString);
}
rv = mimeConverter->DecodeMimeHeader(author,
getter_Copies(decodedCString),
charset, charsetOverride);
if (NS_SUCCEEDED(rv) && decodedCString) {
m_compFields->SetTo(decodedCString);
} else {
m_compFields->SetTo(author);
}
// Setup quoting callbacks for later...
mWhatHolder = 1;
mQuoteURI = originalMsgURI;
// Setup quoting callbacks for later...
mWhatHolder = 1;
mQuoteURI = originalMsgURI;
break;
break;
}
case nsIMsgCompType::ForwardAsAttachment:
{
subjectStr.AppendWithConversion("[Fwd: ");
subjectStr.AppendWithConversion(subject);
subjectStr.AppendWithConversion("]");
subjectStr.Append("[Fwd: ");
subjectStr.Append(subject);
subjectStr.Append("]");
if (NS_SUCCEEDED(rv = nsMsgI18NDecodeMimePartIIStr(subjectStr, encodedCharset, decodedString)))
m_compFields->SetSubject(decodedString.GetUnicode());
else
m_compFields->SetSubject(subjectStr.GetUnicode());
rv = mimeConverter->DecodeMimeHeader(subjectStr.get(),
getter_Copies(decodedString),
charset, charsetOverride);
if (NS_SUCCEEDED(rv)) {
m_compFields->SetSubject(decodedString);
} else {
m_compFields->SetSubject(subjectStr);
}
// Setup quoting callbacks for later...
mQuotingToFollow = PR_FALSE; //We don't need to quote the original message.
@ -1108,30 +1115,15 @@ QuotingOutputStreamListener::QuotingOutputStreamListener(const char * originalMs
if (parser)
{
nsAutoString aCharset;
aCharset.AssignWithConversion(msgCompHeaderInternalCharset());
char * utf8Author = nsnull;
nsCAutoString utf8Author;
utf8Author = NS_ConvertUCS2toUTF8(author);
nsAutoString authorStr; authorStr.Assign(author);
rv = ConvertFromUnicode(aCharset, authorStr, &utf8Author);
if (NS_SUCCEEDED(rv) && utf8Author)
{
nsCAutoString acharsetC;
acharsetC.AssignWithConversion(aCharset);
rv = parser->ExtractHeaderAddressName(acharsetC, utf8Author,
&authorName);
if (NS_SUCCEEDED(rv))
rv = ConvertToUnicode(aCharset, authorName, authorStr);
}
else
{
nsCAutoString authorCStr;
authorCStr.AssignWithConversion(author);
rv = parser->ExtractHeaderAddressName(nsnull, authorCStr,
&authorName);
if (NS_SUCCEEDED(rv))
authorStr.AssignWithConversion(authorName);
}
PR_FREEIF(utf8Author);
rv = parser->ExtractHeaderAddressName("UTF-8", utf8Author,
&authorName);
if (NS_SUCCEEDED(rv))
authorStr = NS_ConvertUTF8toUCS2(authorName);
if (authorName)
PL_strfree(authorName);
@ -1139,13 +1131,13 @@ QuotingOutputStreamListener::QuotingOutputStreamListener(const char * originalMs
mCitePrefix.Append(authorStr);
else
mCitePrefix.Append(author);
mCitePrefix.AppendWithConversion(" wrote:<br><html>"); //XXX I18n?
mCitePrefix.Append(NS_LITERAL_STRING(" wrote:<br><html>")); //XXX I18n?
}
}
}
if (mCitePrefix.IsEmpty())
mCitePrefix.AppendWithConversion("<br><br>--- Original Message ---<br><html>"); //XXX I18n?
mCitePrefix.Append(NS_LITERAL_STRING("<br><br>--- Original Message ---<br><html>")); //XXX I18n?
}
NS_INIT_REFCNT();
@ -1201,83 +1193,61 @@ NS_IMETHODIMP QuotingOutputStreamListener::OnStopRequest(nsIRequest *request, ns
nsAutoString followUpTo;
nsAutoString messageId;
nsAutoString references;
nsAutoString encodedCharset;
nsAutoString encodedHeader;
char *outCString = nsnull;
nsXPIDLCString outCString;
PRUnichar emptyUnichar = 0;
PRBool needToRemoveDup = PR_FALSE;
nsCOMPtr<nsIMimeConverter> mimeConverter = do_GetService(kCMimeConverterCID);
if (type == nsIMsgCompType::ReplyAll)
{
mHeaders->ExtractHeader(HEADER_TO, PR_TRUE, &outCString);
mHeaders->ExtractHeader(HEADER_TO, PR_TRUE, getter_Copies(outCString));
if (outCString)
{
encodedHeader.AssignWithConversion(outCString);
if (NS_FAILED(nsMsgI18NDecodeMimePartIIStr(encodedHeader, encodedCharset, recipient)))
recipient = encodedHeader;
PR_FREEIF(outCString);
mimeConverter->DecodeMimeHeader(outCString, recipient);
}
mHeaders->ExtractHeader(HEADER_CC, PR_TRUE, &outCString);
mHeaders->ExtractHeader(HEADER_CC, PR_TRUE, getter_Copies(outCString));
if (outCString)
{
encodedHeader.AssignWithConversion(outCString);
if (NS_FAILED(nsMsgI18NDecodeMimePartIIStr(encodedHeader, encodedCharset, cc)))
cc = encodedHeader;
PR_FREEIF(outCString);
mimeConverter->DecodeMimeHeader(outCString, cc);
}
if (recipient.Length() > 0 && cc.Length() > 0)
recipient.AppendWithConversion(", ");
recipient.Append(NS_LITERAL_STRING(", "));
recipient += cc;
compFields->SetCc(recipient.GetUnicode());
needToRemoveDup = PR_TRUE;
}
mHeaders->ExtractHeader(HEADER_REPLY_TO, PR_FALSE, &outCString);
mHeaders->ExtractHeader(HEADER_REPLY_TO, PR_FALSE, getter_Copies(outCString));
if (outCString)
{
encodedHeader.AssignWithConversion(outCString);
if (NS_FAILED(nsMsgI18NDecodeMimePartIIStr(encodedHeader, encodedCharset, replyTo)))
replyTo = encodedHeader;
PR_FREEIF(outCString);
mimeConverter->DecodeMimeHeader(outCString, replyTo);
}
mHeaders->ExtractHeader(HEADER_NEWSGROUPS, PR_FALSE, &outCString);
mHeaders->ExtractHeader(HEADER_NEWSGROUPS, PR_FALSE, getter_Copies(outCString));
if (outCString)
{
encodedHeader.AssignWithConversion(outCString);
if (NS_FAILED(nsMsgI18NDecodeMimePartIIStr(encodedHeader, encodedCharset, newgroups)))
newgroups = encodedHeader;
PR_FREEIF(outCString);
mimeConverter->DecodeMimeHeader(outCString, newgroups);
}
mHeaders->ExtractHeader(HEADER_FOLLOWUP_TO, PR_FALSE, &outCString);
mHeaders->ExtractHeader(HEADER_FOLLOWUP_TO, PR_FALSE, getter_Copies(outCString));
if (outCString)
{
encodedHeader.AssignWithConversion(outCString);
if (NS_FAILED(nsMsgI18NDecodeMimePartIIStr(encodedHeader, encodedCharset, followUpTo)))
followUpTo = encodedHeader;
PR_FREEIF(outCString);
mimeConverter->DecodeMimeHeader(outCString, followUpTo);
}
mHeaders->ExtractHeader(HEADER_MESSAGE_ID, PR_FALSE, &outCString);
mHeaders->ExtractHeader(HEADER_MESSAGE_ID, PR_FALSE, getter_Copies(outCString));
if (outCString)
{
encodedHeader.AssignWithConversion(outCString);
if (NS_FAILED(nsMsgI18NDecodeMimePartIIStr(encodedHeader, encodedCharset, messageId)))
messageId = encodedHeader;
PR_FREEIF(outCString);
mimeConverter->DecodeMimeHeader(outCString, messageId);
}
mHeaders->ExtractHeader(HEADER_REFERENCES, PR_FALSE, &outCString);
mHeaders->ExtractHeader(HEADER_REFERENCES, PR_FALSE, getter_Copies(outCString));
if (outCString)
{
encodedHeader.AssignWithConversion(outCString);
if (NS_FAILED(nsMsgI18NDecodeMimePartIIStr(encodedHeader, encodedCharset, references)))
references = encodedHeader;
PR_FREEIF(outCString);
mimeConverter->DecodeMimeHeader(outCString, references);
}
if (! replyTo.IsEmpty())
@ -1303,7 +1273,7 @@ NS_IMETHODIMP QuotingOutputStreamListener::OnStopRequest(nsIRequest *request, ns
}
if (! references.IsEmpty())
references.AppendWithConversion(' ');
references.Append(PRUnichar(' '));
references += messageId;
compFields->SetReferences(nsAutoCString(references));
@ -1348,7 +1318,7 @@ NS_IMETHODIMP QuotingOutputStreamListener::OnStopRequest(nsIRequest *request, ns
#endif
if (! mHeadersOnly)
mMsgBody.AppendWithConversion("</html>");
mMsgBody.Append(NS_LITERAL_STRING("</html>"));
// Now we have an HTML representation of the quoted message.
// If we are in plain text mode, we need to convert this to plain
@ -2600,7 +2570,7 @@ NS_IMETHODIMP nsMsgCompose::CheckAndPopulateRecipients(PRBool populateMailList,
{
//oops, parser problem! I will try to do my best...
fullNameStr = pDisplayName;
fullNameStr.AppendWithConversion(" <");
fullNameStr.Append(NS_LITERAL_STRING(" <"));
if (bIsMailList)
{
if (pEmail && pEmail[0] != 0)
@ -2610,7 +2580,7 @@ NS_IMETHODIMP nsMsgCompose::CheckAndPopulateRecipients(PRBool populateMailList,
}
else
fullNameStr += pEmail;
fullNameStr.AppendWithConversion(">");
fullNameStr.Append(PRUnichar('>'));
}
if (fullNameStr.IsEmpty())
@ -2738,14 +2708,14 @@ NS_IMETHODIMP nsMsgCompose::CheckAndPopulateRecipients(PRBool populateMailList,
if (populateMailList)
{
if (! recipientsStr.IsEmpty())
recipientsStr.AppendWithConversion(',');
recipientsStr.Append(PRUnichar(','));
recipientsStr.Append(recipient->mAddress);
}
if (returnNonHTMLRecipients && recipient->mPreferFormat != nsIAbPreferMailFormat::html)
{
if (! nonHtmlRecipientsStr.IsEmpty())
nonHtmlRecipientsStr.AppendWithConversion(',');
nonHtmlRecipientsStr.Append(PRUnichar(','));
nonHtmlRecipientsStr.Append(recipient->mEmail);
}
@ -3326,12 +3296,12 @@ nsMsgMailList::nsMsgMailList(nsString listName, nsString listDescription, nsIAbD
{
//oops, parser problem! I will try to do my best...
mFullName = listName;
mFullName.AppendWithConversion(" <");
mFullName.Append(NS_LITERAL_STRING(" <"));
if (listDescription.IsEmpty())
mFullName += listName;
else
mFullName += listDescription;
mFullName.AppendWithConversion(">");
mFullName.Append(PRUnichar('>'));
}
mDirectory = directory;

10
mailnews/mime/public/nsIMimeConverter.h
View File

@ -69,12 +69,20 @@ public:
// Decode routine (also converts output to unicode)
// On success, decodedString is never null
NS_IMETHOD DecodeMimeHeader(const nsCString& header,
NS_IMETHOD DecodeMimeHeader(const char *header,
PRUnichar **decodedString,
const char *default_charset = nsnull,
PRBool override_charset = PR_FALSE,
PRBool eatContinuations = PR_TRUE) = 0;
// Decode routine (also converts output to unicode)
// On success, decodedString is never null
NS_IMETHOD DecodeMimeHeader(const char *header,
nsAWritableString& decodedString,
const char *default_charset = nsnull,
PRBool override_charset = PR_FALSE,
PRBool eatContinuations = PR_TRUE) = 0;
// OBSOLESCENT Decode routine (also converts output to unicode)
NS_IMETHOD DecodeMimePartIIStr(const nsString& header,
nsString& charset,

118
mailnews/mime/src/mimedrft.cpp
View File

@ -77,9 +77,6 @@ int mime_decompose_file_output_fn ( char *buf, PRInt32 size, voi
int mime_decompose_file_close_fn ( void *stream_closure );
extern int MimeHeaders_build_heads_list(MimeHeaders *hdrs);
static nsString& mime_decode_string(const char* str , const char* defaultCharset,
PRBool eatContinuations = PR_TRUE);
// CID's
static NS_DEFINE_CID(kCMsgComposeServiceCID, NS_MSGCOMPOSESERVICE_CID);
@ -236,17 +233,6 @@ mime_dump_attachments ( attachmentList );
return rv;
}
static nsString& mime_decode_string(const char* str, const char* defaultCharset,
PRBool eatContinuations)
{
static nsString decodedString;
nsString encodedCharset;
encodedCharset.AssignWithConversion(defaultCharset); // in case the header has no charset specified
nsMsgI18NDecodeMimePartIIStr(NS_ConvertASCIItoUCS2(str), encodedCharset,
decodedString, eatContinuations);
return decodedString;
}
nsIMsgCompFields *
CreateCompositionFields(const char *from,
const char *reply_to,
@ -268,6 +254,7 @@ CreateCompositionFields(const char *from,
char *charset)
{
nsIMsgCompFields *cFields = nsnull;
char *val;
// Create the compose fields...
nsresult rv = nsComponentManager::CreateInstance(kMsgCompFieldsCID, NULL,
@ -279,21 +266,66 @@ CreateCompositionFields(const char *from,
// Now set all of the passed in stuff...
cFields->SetCharacterSet(charset);
cFields->SetFrom(mime_decode_string(from, charset).GetUnicode());
cFields->SetSubject(mime_decode_string(subject, charset).GetUnicode());
cFields->SetReplyTo(mime_decode_string(reply_to, charset).GetUnicode());
cFields->SetTo(mime_decode_string(to, charset).GetUnicode());
cFields->SetCc(mime_decode_string(cc, charset).GetUnicode());
cFields->SetBcc(mime_decode_string(bcc, charset).GetUnicode());
cFields->SetFcc(mime_decode_string(fcc, charset).GetUnicode());
cFields->SetNewsgroups(nsAutoCString(mime_decode_string(newsgroups, charset)));
cFields->SetFollowupTo(nsAutoCString(mime_decode_string(followup_to, charset)));
cFields->SetOrganization(mime_decode_string(organization, charset).GetUnicode());
cFields->SetReferences(nsAutoCString(mime_decode_string(references, charset)));
cFields->SetOtherRandomHeaders(mime_decode_string(other_random_headers, charset).GetUnicode());
cFields->SetPriority(nsAutoCString(mime_decode_string(priority, charset)));
cFields->SetAttachments(nsAutoCString(mime_decode_string(attachment, charset)));
cFields->SetNewspostUrl(nsAutoCString(mime_decode_string(newspost_url, charset)));
val = MIME_DecodeMimeHeader(from, charset, PR_FALSE, PR_TRUE);
cFields->SetFrom(NS_ConvertUTF8toUCS2(val ? val : from).get());
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(subject, charset, PR_FALSE, PR_TRUE);
cFields->SetSubject(NS_ConvertUTF8toUCS2(val ? val : subject).get());
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(reply_to, charset, PR_FALSE, PR_TRUE);
cFields->SetReplyTo(NS_ConvertUTF8toUCS2(val ? val : reply_to).get());
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(to, charset, PR_FALSE, PR_TRUE);
cFields->SetTo(NS_ConvertUTF8toUCS2(val ? val : to).get());
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(cc, charset, PR_FALSE, PR_TRUE);
cFields->SetCc(NS_ConvertUTF8toUCS2(val ? val : cc).get());
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(bcc, charset, PR_FALSE, PR_TRUE);
cFields->SetBcc(NS_ConvertUTF8toUCS2(val ? val : bcc).get());
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(fcc, charset, PR_FALSE, PR_TRUE);
cFields->SetFcc(NS_ConvertUTF8toUCS2(val ? val : fcc).get());
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(newsgroups, charset, PR_FALSE, PR_TRUE);
cFields->SetNewsgroups(val ? val : newsgroups);
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(followup_to, charset, PR_FALSE, PR_TRUE);
cFields->SetFollowupTo(val ? val : followup_to);
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(organization, charset, PR_FALSE, PR_TRUE);
cFields->SetOrganization(NS_ConvertUTF8toUCS2(val ? val : organization).get());
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(references, charset, PR_FALSE, PR_TRUE);
cFields->SetReferences(val ? val : references);
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(other_random_headers, charset, PR_FALSE, PR_TRUE);
cFields->SetOtherRandomHeaders(NS_ConvertUTF8toUCS2(val ? val : other_random_headers).get());
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(priority, charset, PR_FALSE, PR_TRUE);
cFields->SetPriority(val ? val : priority);
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(attachment, charset, PR_FALSE, PR_TRUE);
cFields->SetAttachments(val ? val : attachment);
PR_FREEIF(val);
val = MIME_DecodeMimeHeader(newspost_url, charset, PR_FALSE, PR_TRUE);
cFields->SetNewspostUrl(val ? val : newspost_url);
PR_FREEIF(val);
return cFields;
}
@ -568,15 +600,15 @@ mime_intl_insert_message_header_1(char **body,
else
mime_SACat(body, ": ");
// MIME decode header and convert to UTF-8
nsAutoString ucs2(mime_decode_string(*hdr_value, mailcharset));
char* utf8 = ucs2.ToNewUTF8String();
if (NULL != utf8) {
mime_SACat(body, utf8);
Recycle(utf8);
}
else
mime_SACat(body, *hdr_value); // raw MIME encoded string
// MIME decode header
char* utf8 = MIME_DecodeMimeHeader(*hdr_value, mailcharset, PR_FALSE,
PR_TRUE);
if (NULL != utf8) {
mime_SACat(body, utf8);
PR_Free(utf8);
} else {
mime_SACat(body, *hdr_value); // raw MIME encoded string
}
if (htmlEdit)
mime_SACat(body, HEADER_END_JUNK);
@ -849,11 +881,11 @@ mime_insert_normal_headers(char **body,
MimeGetNamedString(MIME_MHTML_CC),
mailcharset, htmlEdit);
}
/*
Do not reveal bcc recipients when forwarding a message!
See http://bugzilla.mozilla.org/show_bug.cgi?id=41150
*/
if (newsgroups)
/*
Do not reveal bcc recipients when forwarding a message!
See http://bugzilla.mozilla.org/show_bug.cgi?id=41150
*/
if (newsgroups)
mime_intl_insert_message_header_1(&newBody, &newsgroups, HEADER_NEWSGROUPS,
MimeGetNamedString(MIME_MHTML_NEWSGROUPS),
mailcharset, htmlEdit);

35
mailnews/mime/src/nsMimeConverter.cpp
View File

@ -138,7 +138,7 @@ nsMimeConverter::DecodeMimeHeader(const char *header,
// Decode routine (also converts output to unicode)
nsresult
nsMimeConverter::DecodeMimeHeader(const nsCString& header,
nsMimeConverter::DecodeMimeHeader(const char *header,
PRUnichar **decodedString,
const char *default_charset,
PRBool override_charset,
@ -151,18 +151,39 @@ nsMimeConverter::DecodeMimeHeader(const nsCString& header,
decodedCstr = MIME_DecodeMimeHeader(header, default_charset,
override_charset, eatContinuations);
if (nsnull == decodedCstr) {
// no decode or conversion needed
*decodedString = header.ToNewUnicode();
}
else {
*decodedString = NS_ConvertUTF8toUCS2(header).ToNewUnicode();
} else {
*decodedString = NS_ConvertUTF8toUCS2(decodedCstr).ToNewUnicode();
if (!(*decodedString))
res = NS_ERROR_OUT_OF_MEMORY;
PR_FREEIF(decodedCstr);
}
if (!(*decodedString))
res = NS_ERROR_OUT_OF_MEMORY;
return res;
}
// Decode routine (also converts output to unicode)
nsresult
nsMimeConverter::DecodeMimeHeader(const char *header,
nsAWritableString& decodedString,
const char *default_charset,
PRBool override_charset,
PRBool eatContinuations)
{
char *decodedCstr = nsnull;
// apply MIME decode.
decodedCstr = MIME_DecodeMimeHeader(header, default_charset,
override_charset, eatContinuations);
if (nsnull == decodedCstr) {
decodedString = NS_ConvertUTF8toUCS2(header);
} else {
decodedString = NS_ConvertUTF8toUCS2(decodedCstr);
PR_FREEIF(decodedCstr);
}
return NS_OK;
}
nsresult
nsMimeConverter::EncodeMimePartIIStr(const char *header,
const char *mailCharset,

11
mailnews/mime/src/nsMimeConverter.h
View File

@ -61,12 +61,21 @@ public:
PRBool eatContinuations = PR_TRUE);
// Decode routine (also converts output to unicode)
NS_IMETHOD DecodeMimeHeader(const nsCString& header,
// On success, decodedString is never null
NS_IMETHOD DecodeMimeHeader(const char *header,
PRUnichar **decodedString,
const char *default_charset = 0,
PRBool override_charset = PR_FALSE,
PRBool eatContinuations = PR_TRUE);
// Decode routine (also converts output to unicode)
// On success, decodedString is never null
NS_IMETHOD DecodeMimeHeader(const char *header,
nsAWritableString& decodedString,
const char *default_charset = nsnull,
PRBool override_charset = PR_FALSE,
PRBool eatContinuations = PR_TRUE);
// OBSOLESCENT Decode routine (also converts output to unicode)
NS_IMETHOD DecodeMimePartIIStr(const nsString& header,
nsString& charset,