PRBool
nsMIMEInfoAndroid::GetMimeInfoForFileExt(const nsACString& aFileExt,
nsMIMEInfoAndroid **aMimeInfo)
{
nsCString mimeType;
if (mozilla::AndroidBridge::Bridge())
mozilla::AndroidBridge::Bridge()->
GetMimeTypeFromExtensions(aFileExt, mimeType);
// "*/*" means that the bridge didn't know.
if (mimeType.Equals(nsDependentCString("*/*"), nsCaseInsensitiveCStringComparator()))
return false;
PRBool found = GetMimeInfoForMimeType(mimeType, aMimeInfo);
(*aMimeInfo)->SetPrimaryExtension(aFileExt);
return found;
}
nsresult nsIDNService::decodeACE(const nsACString& in, nsACString& out,
bool allowUnassigned)
{
bool isAce;
IsACE(in, &isAce);
if (!isAce) {
out.Assign(in);
return NS_OK;
}
// RFC 3490 - 4.2 ToUnicode
// The ToUnicode output never contains more code points than its input.
punycode_uint output_length = in.Length() - kACEPrefixLen + 1;
punycode_uint *output = new punycode_uint[output_length];
NS_ENSURE_TRUE(output, NS_ERROR_OUT_OF_MEMORY);
enum punycode_status status = punycode_decode(in.Length() - kACEPrefixLen,
PromiseFlatCString(in).get() + kACEPrefixLen,
&output_length,
output,
nullptr);
if (status != punycode_success) {
delete [] output;
return NS_ERROR_FAILURE;
}
// UCS4 -> UTF8
output[output_length] = 0;
nsAutoString utf16;
ucs4toUtf16(output, utf16);
delete [] output;
if (!isOnlySafeChars(utf16, mIDNBlacklist))
return NS_ERROR_FAILURE;
CopyUTF16toUTF8(utf16, out);
// Validation: encode back to ACE and compare the strings
nsAutoCString ace;
nsresult rv = UTF8toACE(out, ace, allowUnassigned);
NS_ENSURE_SUCCESS(rv, rv);
if (!ace.Equals(in, nsCaseInsensitiveCStringComparator()))
return NS_ERROR_FAILURE;
return NS_OK;
}
void nsEudoraWin32::GetAccountName( const char *pSection, nsString& str)
{
str.Truncate();
nsCString s(pSection);
if (s.LowerCaseEqualsLiteral("settings"))
{
str.AssignLiteral("Eudora ");
str.Append(NS_ConvertASCIItoUTF16(pSection));
}
else
{
str.AssignASCII(pSection);
if (StringBeginsWith(s, NS_LITERAL_CSTRING("persona-"), nsCaseInsensitiveCStringComparator()))
CopyASCIItoUTF16(Substring(s, 8), str);
}
}
NS_IMETHODIMP
nsMIMEInfoBase::ExtensionExists(const nsACString& aExtension, PRBool *_retval)
{
NS_ASSERTION(!aExtension.IsEmpty(), "no extension");
PRBool found = PR_FALSE;
PRUint32 extCount = mExtensions.Length();
if (extCount < 1) return NS_OK;
for (PRUint8 i=0; i < extCount; i++) {
const nsCString& ext = mExtensions[i];
if (ext.Equals(aExtension, nsCaseInsensitiveCStringComparator())) {
found = PR_TRUE;
break;
}
}
*_retval = found;
return NS_OK;
}
NS_IMETHODIMP
nsMIMEInfoAndroid::ExtensionExists(const nsACString & aExtension, bool *aRetVal)
{
NS_ASSERTION(!aExtension.IsEmpty(), "no extension");
bool found = false;
PRUint32 extCount = mExtensions.Length();
if (extCount < 1) return NS_OK;
for (PRUint8 i=0; i < extCount; i++) {
const nsCString& ext = mExtensions[i];
if (ext.Equals(aExtension, nsCaseInsensitiveCStringComparator())) {
found = true;
break;
}
}
*aRetVal = found;
return NS_OK;
}
PRInt32
nsCStringArray::IndexOfIgnoreCase(const nsACString& aPossibleString) const
{
if (mImpl)
{
void** ap = mImpl->mArray;
void** end = ap + mImpl->mCount;
while (ap < end)
{
nsCString* string = static_cast<nsCString*>(*ap);
if (string->Equals(aPossibleString, nsCaseInsensitiveCStringComparator()))
{
return ap - mImpl->mArray;
}
ap++;
}
}
return -1;
}
NS_IMETHODIMP
nsMIMEInfoBase::SetPrimaryExtension(const nsACString& aExtension)
{
NS_ASSERTION(!aExtension.IsEmpty(), "no extension");
PRUint32 extCount = mExtensions.Count();
PRUint8 i;
PRBool found = PR_FALSE;
for (i=0; i < extCount; i++) {
nsCString* ext = (nsCString*)mExtensions.CStringAt(i);
if (ext->Equals(aExtension, nsCaseInsensitiveCStringComparator())) {
found = PR_TRUE;
break;
}
}
if (found) {
mExtensions.RemoveCStringAt(i);
}
mExtensions.InsertCStringAt(aExtension, 0);
return NS_OK;
}
NS_IMETHODIMP
nsMIMEInfoAndroid::SetPrimaryExtension(const nsACString & aExtension)
{
NS_ASSERTION(!aExtension.IsEmpty(), "no extension");
PRUint32 extCount = mExtensions.Length();
PRUint8 i;
bool found = false;
for (i=0; i < extCount; i++) {
const nsCString& ext = mExtensions[i];
if (ext.Equals(aExtension, nsCaseInsensitiveCStringComparator())) {
found = true;
break;
}
}
if (found) {
mExtensions.RemoveElementAt(i);
}
mExtensions.InsertElementAt(0, aExtension);
return NS_OK;
}
nsresult
HttpBaseChannel::nsContentEncodings::PrepareForNext(void)
{
NS_ASSERTION(mCurStart == mCurEnd, "Indeterminate state");
// At this point both mCurStart and mCurEnd point to somewhere
// past the end of the next thing we want to return
while (mCurEnd != mEncodingHeader) {
--mCurEnd;
if (*mCurEnd != ',' && !nsCRT::IsAsciiSpace(*mCurEnd))
break;
}
if (mCurEnd == mEncodingHeader)
return NS_ERROR_NOT_AVAILABLE; // no more encodings
++mCurEnd;
// At this point mCurEnd points to the first char _after_ the
// header we want. Furthermore, mCurEnd - 1 != mEncodingHeader
mCurStart = mCurEnd - 1;
while (mCurStart != mEncodingHeader &&
*mCurStart != ',' && !nsCRT::IsAsciiSpace(*mCurStart))
--mCurStart;
if (*mCurStart == ',' || nsCRT::IsAsciiSpace(*mCurStart))
++mCurStart; // we stopped because of a weird char, so move up one
// At this point mCurStart and mCurEnd bracket the encoding string
// we want. Check that it's not "identity"
if (Substring(mCurStart, mCurEnd).Equals("identity",
nsCaseInsensitiveCStringComparator())) {
mCurEnd = mCurStart;
return PrepareForNext();
}
mReady = true;
return NS_OK;
}
void nsEudoraAddress::ResolveEntries(nsCString& name, nsVoidArray& list,
nsVoidArray& result, bool addResolvedEntries,
bool wasResolved, int32_t& numResolved)
{
/* a safe-guard against recursive entries */
if (result.Count() > m_alias.Count())
return;
int32_t max = list.Count();
int32_t i;
CAliasData * pData;
CAliasEntry * pEntry;
for (i = 0; i < max; i++) {
pData = (CAliasData *)list.ElementAt(i);
// resolve the email to an existing alias!
if (!name.Equals(pData->m_email, nsCaseInsensitiveCStringComparator()) &&
((pEntry = ResolveAlias(pData->m_fullEntry)) != nullptr)) {
// This new entry has all of the entries for this puppie.
// Resolve all of it's entries!
numResolved++; // Track the number of entries resolved
// We pass in true for the 5th parameter so that we know that we're
// calling ourselves recursively.
ResolveEntries(pEntry->m_name,
pEntry->m_list,
result,
addResolvedEntries,
true,
numResolved);
}
else if (addResolvedEntries || !wasResolved) {
// This is either an ordinary entry (i.e. just contains the info) or we were told
// to add resolved alias entries.
result.AppendElement(pData);
}
}
}
//
// 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;
}
NS_IMETHODIMP nsAbIPCCard::Equals(nsIAbCard *card, PRBool *_retval)
{
NS_ENSURE_ARG_POINTER(card);
NS_ENSURE_ARG_POINTER(_retval);
nsXPIDLString str;
*_retval = PR_FALSE;
card->GetFirstName(getter_Copies(str));
if (Compare(str, m_FirstName, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetLastName(getter_Copies(str));
if (Compare(str, m_LastName, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetDisplayName(getter_Copies(str));
if (Compare(str, m_DisplayName, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetNickName(getter_Copies(str));
if (Compare(str, m_NickName, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetPrimaryEmail(getter_Copies(str));
if (Compare(str, m_PrimaryEmail, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetSecondEmail(getter_Copies(str));
if (Compare(str, m_SecondEmail, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetWorkPhone(getter_Copies(str));
if (Compare(str, m_WorkPhone, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetHomePhone(getter_Copies(str));
if (Compare(str, m_HomePhone, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetFaxNumber(getter_Copies(str));
if (Compare(str, m_FaxNumber, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetPagerNumber(getter_Copies(str));
if (Compare(str, m_PagerNumber, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetCellularNumber(getter_Copies(str));
if (Compare(str, m_CellularNumber, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetHomeAddress(getter_Copies(str));
if (Compare(str, m_HomeAddress, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetHomeAddress2(getter_Copies(str));
if (Compare(str, m_HomeAddress2, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetHomeCity(getter_Copies(str));
if (Compare(str, m_HomeCity, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetHomeState(getter_Copies(str));
if (Compare(str, m_HomeState, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetHomeZipCode(getter_Copies(str));
if (Compare(str, m_HomeZipCode, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetHomeCountry(getter_Copies(str));
if (Compare(str, m_HomeCountry, nsCaseInsensitiveStringComparator()))
return NS_OK;
// both card and this have their addresses split, which is correct
card->GetWorkAddress(getter_Copies(str));
if (Compare(str, m_WorkAddress, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetWorkAddress2(getter_Copies(str));
if (Compare(str, m_WorkAddress2, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetWorkCity(getter_Copies(str));
if (Compare(str, m_WorkCity, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetWorkState(getter_Copies(str));
if (Compare(str, m_WorkState, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetWorkZipCode(getter_Copies(str));
if (Compare(str, m_WorkZipCode, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetWorkCountry(getter_Copies(str));
if (Compare(str, m_WorkCountry, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetJobTitle(getter_Copies(str));
if (Compare(str, m_JobTitle, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetDepartment(getter_Copies(str));
if (Compare(str, m_Department, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetCompany(getter_Copies(str));
if (Compare(str, m_Company, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetWebPage1(getter_Copies(str));
if (Compare(str, m_WebPage1, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetWebPage2(getter_Copies(str));
if (Compare(str, m_WebPage2, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetBirthYear(getter_Copies(str));
if (Compare(str, m_BirthYear, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetBirthMonth(getter_Copies(str));
if (Compare(str, m_BirthMonth, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetBirthDay(getter_Copies(str));
if (Compare(str, m_BirthDay, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetCustom1(getter_Copies(str));
if (Compare(str, m_Custom1, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetCustom2(getter_Copies(str));
if (Compare(str, m_Custom2, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetCustom3(getter_Copies(str));
if (Compare(str, m_Custom3, nsCaseInsensitiveStringComparator()))
return NS_OK;
card->GetCustom4(getter_Copies(str));
if (Compare(str, m_Custom4, nsCaseInsensitiveStringComparator()))
return NS_OK;
PRBool isMailList=PR_FALSE;
card->GetIsMailList(&isMailList);
if (isMailList != m_IsMailList)
return NS_OK;
nsXPIDLCString str2;
card->GetMailListURI(getter_Copies(str2));
if (m_MailListURI.Equals(str2, nsCaseInsensitiveCStringComparator()))
return NS_OK;
*_retval = PR_TRUE;
return NS_OK;
}
PRBool nsAbIPCCard::Equals(nsABCOMCardStruct * card, nsStringArray & differingAttrs)
{
if(!card)
return PR_FALSE;
differingAttrs.Clear();
if(card->firstName)
if (Compare(nsDependentString(card->firstName), m_FirstName, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kFirstNameColumn));
if(card->lastName)
if (Compare(nsDependentString(card->lastName), m_LastName, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kLastNameColumn));
if(card->displayName)
if (Compare(nsDependentString(card->displayName), m_DisplayName, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kDisplayNameColumn));
if(card->nickName)
if (Compare(nsDependentString(card->nickName), m_NickName, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kNicknameColumn));
if(card->primaryEmail)
if (Compare(nsDependentString(card->primaryEmail), m_PrimaryEmail, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kPriEmailColumn));
if(card->secondEmail)
if (Compare(nsDependentString(card->secondEmail), m_SecondEmail, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(k2ndEmailColumn));
if(card->workPhone)
if (Compare(nsDependentString(card->workPhone), m_WorkPhone, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kWorkPhoneColumn));
if(card->homePhone)
if (Compare(nsDependentString(card->homePhone), m_HomePhone, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kHomePhoneColumn));
if(card->faxNumber)
if (Compare(nsDependentString(card->faxNumber), m_FaxNumber, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kFaxColumn));
if(card->pagerNumber)
if (Compare(nsDependentString(card->pagerNumber), m_PagerNumber, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kPagerColumn));
if(card->cellularNumber)
if (Compare(nsDependentString(card->cellularNumber), m_CellularNumber, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kCellularColumn));
// card has home and work addresses joined, but "this" has them split
if(card->homeAddress)
if (Compare(nsDependentString(card->homeAddress), m_HomeAddress, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kHomeAddressColumn));
if(card->homeAddress2)
if (Compare(nsDependentString(card->homeAddress2), m_HomeAddress2, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kHomeAddress2Column));
if(card->homeCity)
if (Compare(nsDependentString(card->homeCity), m_HomeCity, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kHomeCityColumn));
if(card->homeState)
if (Compare(nsDependentString(card->homeState), m_HomeState, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kHomeStateColumn));
if(card->homeZipCode)
if (Compare(nsDependentString(card->homeZipCode), m_HomeZipCode, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kHomeZipCodeColumn));
if(card->homeCountry)
if (Compare(nsDependentString(card->homeCountry), m_HomeCountry, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kHomeCountryColumn));
// card->workAddress is Joined, m_workAddress and m_workAddress2 are split
if(card->workAddress)
if (Compare(nsDependentString(card->workAddress), m_WorkAddress, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kWorkAddressColumn));
if(card->workAddress2)
if (Compare(nsDependentString(card->workAddress2), m_WorkAddress2, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kWorkAddress2Column));
if(card->workCity)
if (Compare(nsDependentString(card->workCity), m_WorkCity, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kWorkCityColumn));
if(card->workState)
if (Compare(nsDependentString(card->workState), m_WorkState, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kWorkStateColumn));
if(card->workZipCode)
if (Compare(nsDependentString(card->workZipCode), m_WorkZipCode, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kWorkZipCodeColumn));
if(card->workCountry)
if (Compare(nsDependentString(card->workCountry), m_WorkCountry, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kWorkCountryColumn));
if(card->jobTitle)
if (Compare(nsDependentString(card->jobTitle), m_JobTitle, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kJobTitleColumn));
if(card->department)
if (Compare(nsDependentString(card->department), m_Department, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kDepartmentColumn));
if(card->company)
if (Compare(nsDependentString(card->company), m_Company, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kCompanyColumn));
if(card->webPage1)
if (Compare(nsDependentString(card->webPage1), m_WebPage1, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kWebPage1Column));
if(card->webPage2)
if (Compare(nsDependentString(card->webPage2), m_WebPage2, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kWebPage2Column));
if(card->birthYear)
if (Compare(nsDependentString(card->birthYear), m_BirthYear, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kBirthYearColumn));
if(card->birthMonth)
if (Compare(nsDependentString(card->birthMonth), m_BirthMonth, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kBirthMonthColumn));
if(card->birthDay)
if (Compare(nsDependentString(card->birthDay), m_BirthDay, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kBirthDayColumn));
if(card->custom1)
if (Compare(nsDependentString(card->custom1), m_Custom1, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kCustom1Column));
if(card->custom2)
if (Compare(nsDependentString(card->custom2), m_Custom2, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kCustom2Column));
if(card->custom3)
if (Compare(nsDependentString(card->custom3), m_Custom3, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kCustom3Column));
if(card->custom4)
if (Compare(nsDependentString(card->custom4), m_Custom4, nsCaseInsensitiveStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kCustom4Column));
if (card->isMailList != m_IsMailList)
differingAttrs.AppendString(NS_LITERAL_STRING(kMailListName));
if(card->mailListURI) {
nsCAutoString str(card->mailListURI);
if (str.Equals(m_MailListURI, nsCaseInsensitiveCStringComparator()))
differingAttrs.AppendString(NS_LITERAL_STRING(kMailListDescription));
}
return (differingAttrs.Count() == 0);
}
// parse and process a formatting attribute. If aStringArray is
// non-NULL, return a list of the attributes from mNameFormat in
// aStringArray. Otherwise, generate an autocomplete value from the
// information in aMessage and append it to aValue. Any errors
// (including failure to find a required attribute while building up aValue)
// return an NS_ERROR_* up the stack so that the caller doesn't try and
// generate an nsIAutoCompleteItem from this.
//
nsresult
nsAbLDAPAutoCompFormatter::ProcessFormat(const nsAString & aFormat,
nsILDAPMessage *aMessage,
nsACString *aValue,
nsCStringArray *aAttrs)
{
nsresult rv; // temp for return values
// get some iterators to parse aFormat
//
const PRUnichar *iter = aFormat.BeginReading();
const PRUnichar *iterEnd = aFormat.EndReading();
// get the console service for error logging
//
nsCOMPtr<nsIConsoleService> consoleSvc =
do_GetService("@mozilla.org/consoleservice;1", &rv);
if (NS_FAILED(rv)) {
NS_WARNING("nsAbLDAPAutoCompFormatter::ProcessFormat(): "
"couldn't get console service");
}
PRBool attrRequired = PR_FALSE; // is this attr required or optional?
nsCAutoString attrName; // current attr to get
// parse until we hit the end of the string
//
while (iter != iterEnd) {
switch (*iter) { // process the next char
case PRUnichar('{'):
attrRequired = PR_TRUE; // this attribute is required
/*FALLTHROUGH*/
case PRUnichar('['):
rv = ParseAttrName(&iter, iterEnd, attrRequired,
consoleSvc, attrName);
if ( NS_FAILED(rv) ) {
// something unrecoverable happened; stop parsing and
// propagate the error up the stack
//
return rv;
}
// if we're building an array
if ( aAttrs ) {
// see if the string is already present in the array
int i = 0, found = -1;
while ( i < aAttrs->Count() ) {
#ifdef MOZILLA_INTERNAL_API
if (aAttrs->CStringAt(i)->Equals(attrName, nsCaseInsensitiveCStringComparator())) {
#else
if (aAttrs->CStringAt(i)->Equals(attrName, CaseInsensitiveCompare)) {
#endif
found = i;
break;
}
++i;
}
// and it doesn't already contain this string
if (found == -1) {
// add it
if (!aAttrs->AppendCString(attrName)) {
// current AppendCString always returns PR_TRUE;
// if we hit this error, something has changed in
// that code
//
NS_ERROR(
"nsAbLDAPAutoCompFormatter::ProcessFormat():"
" aAttrs->AppendCString(attrName) failed");
return NS_ERROR_UNEXPECTED;
}
}
} else {
// otherwise, append the first value of this attr to aValue
// XXXdmose should do better than this; bug 76595
rv = AppendFirstAttrValue(attrName, aMessage, attrRequired,
*aValue);
if ( NS_FAILED(rv) ) {
// something unrecoverable happened; stop parsing and
// propagate the error up the stack
//
return rv;
}
}
attrName.Truncate(); // clear out for next pass
attrRequired = PR_FALSE; // reset to the default for the next pass
break;
case PRUnichar('\\'):
// advance the iterator and be sure we haven't run off the end
//
++iter;
if (iter == iterEnd) {
// abort; missing escaped char
//
if (consoleSvc) {
consoleSvc->LogStringMessage(
NS_LITERAL_STRING(
"LDAP addressbook autocomplete formatter: error parsing format string: premature end of string after \\ escape").get());
NS_ERROR("LDAP addressbook autocomplete formatter: error "
"parsing format string: premature end of string "
"after \\ escape");
}
return NS_ERROR_ILLEGAL_VALUE;
}
/*FALLTHROUGH*/
default:
// if we're not just building an array of attribute names, append
// this character to the item we're generating.
//
if (!aAttrs) {
// this character gets treated as a literal
//
aValue->Append(NS_ConvertUTF16toUTF8(nsDependentString(iter,1)));
}
}
++iter; // advance the iterator
}
return NS_OK;
}
NS_IMETHODIMP nsSpamSettings::CheckWhiteList(nsIMsgDBHdr *aMsgHdr, bool *aResult)
{
NS_ENSURE_ARG_POINTER(aMsgHdr);
NS_ENSURE_ARG_POINTER(aResult);
*aResult = false; // default in case of error or no whitelisting
if (!mUseWhiteList || (!mWhiteListDirArray.Count() &&
mTrustedMailDomains.IsEmpty()))
return NS_OK;
// do per-message processing
nsCString author;
aMsgHdr->GetAuthor(getter_Copies(author));
nsresult rv;
nsCOMPtr<nsIMsgHeaderParser> headerParser =
do_GetService(NS_MAILNEWS_MIME_HEADER_PARSER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString authorEmailAddress;
rv = headerParser->ExtractHeaderAddressMailboxes(author, authorEmailAddress);
NS_ENSURE_SUCCESS(rv, rv);
if (authorEmailAddress.IsEmpty())
return NS_OK;
// should we skip whitelisting for the identity email?
if (mInhibitWhiteListingIdentityUser)
{
for (PRUint32 i = 0; i < mEmails.Length(); ++i)
{
if (mEmails[i].Equals(authorEmailAddress, nsCaseInsensitiveCStringComparator()))
return NS_OK;
}
}
if (!mTrustedMailDomains.IsEmpty() || mInhibitWhiteListingIdentityDomain)
{
nsCAutoString domain;
PRInt32 atPos = authorEmailAddress.FindChar('@');
if (atPos >= 0)
domain = Substring(authorEmailAddress, atPos + 1);
if (!domain.IsEmpty())
{
if (!mTrustedMailDomains.IsEmpty() &&
MsgHostDomainIsTrusted(domain, mTrustedMailDomains))
{
*aResult = true;
return NS_OK;
}
if (mInhibitWhiteListingIdentityDomain)
{
for (PRUint32 i = 0; i < mEmails.Length(); ++i)
{
nsCAutoString identityDomain;
PRInt32 atPos = mEmails[i].FindChar('@');
if (atPos >= 0)
{
identityDomain = Substring(mEmails[i], atPos + 1);
if (identityDomain.Equals(domain, nsCaseInsensitiveCStringComparator()))
return NS_OK; // don't whitelist
}
}
}
}
}
if (mWhiteListDirArray.Count())
{
nsCOMPtr<nsIAbCard> cardForAddress;
for (PRInt32 index = 0;
index < mWhiteListDirArray.Count() && !cardForAddress;
index++)
{
mWhiteListDirArray[index]->CardForEmailAddress(authorEmailAddress,
getter_AddRefs(cardForAddress));
}
if (cardForAddress)
{
*aResult = true;
return NS_OK;
}
}
return NS_OK; // default return is false
}
static int
CompareCStringIgnoreCase(const nsCString* aCString1, const nsCString* aCString2, void*)
{
return Compare(*aCString1, *aCString2, nsCaseInsensitiveCStringComparator());
}
/**
* Load default pref files from a directory. The files in the
* directory are sorted reverse-alphabetically; a set of "special file
* names" may be specified which are loaded after all the others.
*/
static nsresult
pref_LoadPrefsInDir(nsIFile* aDir, char const *const *aSpecialFiles, PRUint32 aSpecialFilesCount)
{
nsresult rv, rv2;
PRBool hasMoreElements;
nsCOMPtr<nsISimpleEnumerator> dirIterator;
// this may fail in some normal cases, such as embedders who do not use a GRE
rv = aDir->GetDirectoryEntries(getter_AddRefs(dirIterator));
if (NS_FAILED(rv)) {
// If the directory doesn't exist, then we have no reason to complain. We
// loaded everything (and nothing) successfully.
if (rv == NS_ERROR_FILE_NOT_FOUND)
rv = NS_OK;
return rv;
}
rv = dirIterator->HasMoreElements(&hasMoreElements);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMArray<nsIFile> prefFiles(INITIAL_PREF_FILES);
nsCOMArray<nsIFile> specialFiles(aSpecialFilesCount);
nsCOMPtr<nsIFile> prefFile;
while (hasMoreElements && NS_SUCCEEDED(rv)) {
nsCAutoString leafName;
rv = dirIterator->GetNext(getter_AddRefs(prefFile));
if (NS_FAILED(rv)) {
break;
}
prefFile->GetNativeLeafName(leafName);
NS_ASSERTION(!leafName.IsEmpty(), "Failure in default prefs: directory enumerator returned empty file?");
// Skip non-js files
if (StringEndsWith(leafName, NS_LITERAL_CSTRING(".js"),
nsCaseInsensitiveCStringComparator())) {
PRBool shouldParse = PR_TRUE;
// separate out special files
for (PRUint32 i = 0; i < aSpecialFilesCount; ++i) {
if (leafName.Equals(nsDependentCString(aSpecialFiles[i]))) {
shouldParse = PR_FALSE;
// special files should be process in order; we put them into
// the array by index; this can make the array sparse
specialFiles.ReplaceObjectAt(prefFile, i);
}
}
if (shouldParse) {
prefFiles.AppendObject(prefFile);
}
}
rv = dirIterator->HasMoreElements(&hasMoreElements);
}
if (prefFiles.Count() + specialFiles.Count() == 0) {
NS_WARNING("No default pref files found.");
if (NS_SUCCEEDED(rv)) {
rv = NS_SUCCESS_FILE_DIRECTORY_EMPTY;
}
return rv;
}
prefFiles.Sort(pref_CompareFileNames, nsnull);
PRUint32 arrayCount = prefFiles.Count();
PRUint32 i;
for (i = 0; i < arrayCount; ++i) {
rv2 = openPrefFile(prefFiles[i]);
if (NS_FAILED(rv2)) {
NS_ERROR("Default pref file not parsed successfully.");
rv = rv2;
}
}
arrayCount = specialFiles.Count();
for (i = 0; i < arrayCount; ++i) {
// this may be a sparse array; test before parsing
nsIFile* file = specialFiles[i];
if (file) {
rv2 = openPrefFile(file);
if (NS_FAILED(rv2)) {
NS_ERROR("Special default pref file not parsed successfully.");
rv = rv2;
}
}
}
return rv;
}
nsresult nsAbPalmHotSync::GetABInterface()
{
// Use GetChildNodes() call here.
nsresult rv;
nsCOMPtr<nsIAbManager> abManager(do_GetService(NS_ABMANAGER_CONTRACTID, &rv));
if (NS_FAILED(rv))
return E_FAIL;
nsString description;
nsCString fileName, uri, prefName;
PRUint32 palmSyncTimeStamp;
PRInt32 dirType, palmCategoryIndex;
nsCOMPtr<nsISimpleEnumerator> subDirectories;
if (NS_FAILED(abManager->GetDirectories(getter_AddRefs(subDirectories))) || !subDirectories)
return E_FAIL;
// Check each valid addrbook.
nsCOMPtr<nsISupports> item;
nsCOMPtr<nsIAbDirectory> directory;
PRBool hasMore;
while (NS_SUCCEEDED(rv = subDirectories->HasMoreElements(&hasMore)) && hasMore)
{
if (NS_SUCCEEDED(subDirectories->GetNext(getter_AddRefs(item))))
{
directory = do_QueryInterface(item, &rv);
if (NS_SUCCEEDED(rv))
{
// TODO: may need to skip mailing list?? but maybe not since there's no mailing list on the top level.
rv = directory->GetDescription(description);
if(NS_FAILED(rv)) return E_FAIL;
rv = directory->GetFileName(fileName);
if(NS_FAILED(rv)) return E_FAIL;
rv = directory->GetURI(uri);
if(NS_FAILED(rv)) return E_FAIL;
rv = directory->GetDirType(&dirType);
if(NS_FAILED(rv)) return E_FAIL;
rv = directory->GetDirPrefId(prefName);
if (NS_FAILED(rv)) return E_FAIL;
rv = directory->GetIntValue("PalmCategoryId", -1, &palmCategoryIndex);
if (NS_FAILED(rv)) return E_FAIL;
rv = directory->GetIntValue("PalmSyncTimeStamp", 0,
(PRInt32*)&palmSyncTimeStamp);
if (NS_FAILED(rv)) return E_FAIL;
// Skip/Ignore 4.X addrbooks (ie, with ".na2" extension).
if (((fileName.Length() > kABFileName_PreviousSuffixLen) &&
strcmp(fileName.get() + fileName.Length() - kABFileName_PreviousSuffixLen, kABFileName_PreviousSuffix) == 0) ||
(dirType != kPABDirectory && dirType != kMAPIDirectory))
continue;
// If Palm category is already assigned to AB then just check that (ie, was synced before).
if((palmCategoryIndex > -1) && (mPalmCategoryIndex == palmCategoryIndex))
break;
// If Palm category is not already assigned check the AB name (ie, never
// synced before). Note that Palm category name is only 15 chars max.
if (description.Length() > 15 && mAbName.Length() <= 15)
description.Cut(15, description.Length()-15);
// check for matching AB+Category, and special case personal address book
// to match "Personal" category.
if(description == mAbName ||
(prefName.Equals("ldap_2.servers.pab", nsCaseInsensitiveCStringComparator())
&& mAbName.LowerCaseEqualsLiteral("personal")))
break;
directory = nsnull;
}
}
}
// If not found return error.
if(!directory)
return NS_ERROR_FILE_NOT_FOUND;
mDirectory = directory;
mFileName = fileName;
mUri = uri;
mDescription = description;
mDirType = dirType;
mPalmSyncTimeStamp = palmSyncTimeStamp;
return NS_OK;
}
NS_IMETHODIMP nsMsgFilterList::MatchOrChangeFilterTarget(const nsACString &oldFolderUri, const nsACString &newFolderUri, bool caseInsensitive, bool *found)
{
NS_ENSURE_ARG_POINTER(found);
uint32_t numFilters = 0;
nsresult rv = GetFilterCount(&numFilters);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgFilter> filter;
nsCString folderUri;
*found = false;
for (uint32_t index = 0; index < numFilters; index++)
{
rv = GetFilterAt(index, getter_AddRefs(filter));
NS_ENSURE_SUCCESS(rv, rv);
uint32_t numActions;
rv = filter->GetActionCount(&numActions);
NS_ENSURE_SUCCESS(rv, rv);
for (uint32_t actionIndex = 0; actionIndex < numActions; actionIndex++)
{
nsCOMPtr<nsIMsgRuleAction> filterAction;
rv = filter->GetActionAt(actionIndex, getter_AddRefs(filterAction));
if (NS_FAILED(rv) || !filterAction)
continue;
nsMsgRuleActionType actionType;
if (NS_FAILED(filterAction->GetType(&actionType)))
continue;
if (actionType == nsMsgFilterAction::MoveToFolder ||
actionType == nsMsgFilterAction::CopyToFolder)
{
rv = filterAction->GetTargetFolderUri(folderUri);
if (NS_SUCCEEDED(rv) && !folderUri.IsEmpty())
{
bool matchFound = false;
if (caseInsensitive)
{
if (folderUri.Equals(oldFolderUri, nsCaseInsensitiveCStringComparator())) //local
matchFound = true;
}
else
{
if (folderUri.Equals(oldFolderUri)) //imap
matchFound = true;
}
if (matchFound)
{
*found = true;
//if we just want to match the uri's, newFolderUri will be null
if (!newFolderUri.IsEmpty())
{
rv = filterAction->SetTargetFolderUri(newFolderUri);
NS_ENSURE_SUCCESS(rv, rv);
}
}
}
}
}
}
return rv;
}
nsresult
GfxInfo::GetFeatureStatusImpl(int32_t aFeature,
int32_t *aStatus,
nsAString & aSuggestedDriverVersion,
const nsTArray<GfxDriverInfo>& aDriverInfo,
OperatingSystem* aOS /* = nullptr */)
{
NS_ENSURE_ARG_POINTER(aStatus);
aSuggestedDriverVersion.SetIsVoid(true);
*aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
OperatingSystem os = mOS;
if (aOS)
*aOS = os;
// OpenGL layers are never blacklisted on Android.
// This early return is so we avoid potentially slow
// GLStrings initialization on startup when we initialize GL layers.
if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS) {
*aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
return NS_OK;
}
EnsureInitialized();
if (mGLStrings->Vendor().IsEmpty() || mGLStrings->Renderer().IsEmpty()) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
// Don't evaluate special cases when evaluating the downloaded blocklist.
if (aDriverInfo.IsEmpty()) {
if (aFeature == FEATURE_WEBGL_OPENGL) {
if (mGLStrings->Renderer().Find("Adreno 200") != -1 ||
mGLStrings->Renderer().Find("Adreno 205") != -1)
{
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
if (mHardware.EqualsLiteral("ville")) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
}
if (aFeature == FEATURE_STAGEFRIGHT) {
NS_LossyConvertUTF16toASCII cManufacturer(mManufacturer);
NS_LossyConvertUTF16toASCII cModel(mModel);
NS_LossyConvertUTF16toASCII cHardware(mHardware);
if (cHardware.EqualsLiteral("antares") ||
cHardware.EqualsLiteral("harmony") ||
cHardware.EqualsLiteral("picasso") ||
cHardware.EqualsLiteral("picasso_e") ||
cHardware.EqualsLiteral("ventana") ||
cHardware.EqualsLiteral("rk30board"))
{
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
if (CompareVersions(mOSVersion.get(), "2.2.0") >= 0 &&
CompareVersions(mOSVersion.get(), "2.3.0") < 0)
{
// Froyo LG devices are whitelisted.
// All other Froyo
bool isWhitelisted =
cManufacturer.Equals("lge", nsCaseInsensitiveCStringComparator());
if (!isWhitelisted) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
}
else if (CompareVersions(mOSVersion.get(), "2.3.0") >= 0 &&
CompareVersions(mOSVersion.get(), "2.4.0") < 0)
{
// Gingerbread HTC devices are whitelisted.
// Gingerbread Samsung devices are whitelisted except for:
// Samsung devices identified in Bug 847837
// Gingerbread Sony devices are whitelisted.
// All other Gingerbread devices are blacklisted.
bool isWhitelisted =
cManufacturer.Equals("htc", nsCaseInsensitiveCStringComparator()) ||
(cManufacturer.Find("sony", true) != -1) ||
cManufacturer.Equals("samsung", nsCaseInsensitiveCStringComparator());
if (cModel.Equals("GT-I8160", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("GT-I8160L", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("GT-I8530", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("GT-I9070", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("GT-I9070P", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("GT-I8160P", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("GT-S7500", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("GT-S7500T", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("GT-S7500L", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("GT-S6500T", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("smdkc110", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("smdkc210", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("herring", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("shw-m110s", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("shw-m180s", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("n1", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("latona", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("aalto", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("atlas", nsCaseInsensitiveCStringComparator()) ||
cHardware.Equals("qcom", nsCaseInsensitiveCStringComparator()))
{
isWhitelisted = false;
}
if (!isWhitelisted) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
}
else if (CompareVersions(mOSVersion.get(), "3.0.0") >= 0 &&
CompareVersions(mOSVersion.get(), "4.0.0") < 0)
{
// Honeycomb Samsung devices are whitelisted.
// All other Honeycomb devices are blacklisted.
bool isWhitelisted =
cManufacturer.Equals("samsung", nsCaseInsensitiveCStringComparator());
if (!isWhitelisted) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
}
else if (CompareVersions(mOSVersion.get(), "4.0.0") < 0)
{
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;
return NS_OK;
}
else if (CompareVersions(mOSVersion.get(), "4.1.0") < 0)
{
// Whitelist:
// All Samsung ICS devices, except for:
// Samsung SGH-I717 (Bug 845729)
// Samsung SGH-I727 (Bug 845729)
// Samsung SGH-I757 (Bug 845729)
// All Galaxy nexus ICS devices
// Sony Xperia Ion (LT28) ICS devices
bool isWhitelisted =
cModel.Equals("LT28h", nsCaseInsensitiveCStringComparator()) ||
cManufacturer.Equals("samsung", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("galaxy nexus", nsCaseInsensitiveCStringComparator()); // some Galaxy Nexus have manufacturer=amazon
if (cModel.Find("SGH-I717", true) != -1 ||
cModel.Find("SGH-I727", true) != -1 ||
cModel.Find("SGH-I757", true) != -1)
{
isWhitelisted = false;
}
if (!isWhitelisted) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
}
else if (CompareVersions(mOSVersion.get(), "4.2.0") < 0)
{
// Whitelist:
// All JB phones except for those in blocklist below
// Blocklist:
// Samsung devices from bug 812881 and 853522.
// Motorola XT890 from bug 882342.
bool isBlocklisted =
cModel.Find("GT-P3100", true) != -1 ||
cModel.Find("GT-P3110", true) != -1 ||
cModel.Find("GT-P3113", true) != -1 ||
cModel.Find("GT-P5100", true) != -1 ||
cModel.Find("GT-P5110", true) != -1 ||
cModel.Find("GT-P5113", true) != -1 ||
cModel.Find("XT890", true) != -1;
if (isBlocklisted) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
}
else if (CompareVersions(mOSVersion.get(), "4.3.0") < 0)
{
// Blocklist all Sony devices
if (cManufacturer.Find("Sony", true) != -1) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
}
}
if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_ENCODE) {
if (mozilla::AndroidBridge::Bridge()) {
*aStatus = mozilla::AndroidBridge::Bridge()->GetHWEncoderCapability() ? nsIGfxInfo::FEATURE_STATUS_OK : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
}
if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_DECODE) {
if (mozilla::AndroidBridge::Bridge()) {
*aStatus = mozilla::AndroidBridge::Bridge()->GetHWDecoderCapability() ? nsIGfxInfo::FEATURE_STATUS_OK : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
}
}
return GfxInfoBase::GetFeatureStatusImpl(aFeature, aStatus, aSuggestedDriverVersion, aDriverInfo, &os);
}
bool
CaseInsensitiveFindInReadable( const nsACString& aPattern, nsACString::const_iterator& aSearchStart, nsACString::const_iterator& aSearchEnd )
{
return FindInReadable_Impl(aPattern, aSearchStart, aSearchEnd, nsCaseInsensitiveCStringComparator());
}
static bool
CompareWebGLExtensionName(const nsACString& name, const char* other)
{
return name.Equals(other, nsCaseInsensitiveCStringComparator());
}
nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIRequest *request,
nsIURI* aURL)
{
nsresult rv = NS_OK;
// If we don't yet have a stream listener, we need to get
// one from the plugin.
// NOTE: this should only happen when a stream was NOT created
// with GetURL or PostURL (i.e. it's the initial stream we
// send to the plugin as determined by the SRC or DATA attribute)
if (!mPStreamListener) {
if (!mPluginInstance) {
return NS_ERROR_FAILURE;
}
nsRefPtr<nsNPAPIPluginStreamListener> streamListener;
rv = mPluginInstance->NewStreamListener(nullptr, nullptr,
getter_AddRefs(streamListener));
if (NS_FAILED(rv) || !streamListener) {
return NS_ERROR_FAILURE;
}
mPStreamListener = static_cast<nsNPAPIPluginStreamListener*>(streamListener.get());
}
mPStreamListener->SetStreamListenerPeer(this);
// get httpChannel to retrieve some info we need for nsIPluginStreamInfo setup
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(channel);
/*
* Assumption
* By the time nsPluginStreamListenerPeer::OnDataAvailable() gets
* called, all the headers have been read.
*/
if (httpChannel) {
// Reassemble the HTTP response status line and provide it to our
// listener. Would be nice if we could get the raw status line,
// but nsIHttpChannel doesn't currently provide that.
// Status code: required; the status line isn't useful without it.
uint32_t statusNum;
if (NS_SUCCEEDED(httpChannel->GetResponseStatus(&statusNum)) &&
statusNum < 1000) {
// HTTP version: provide if available. Defaults to empty string.
nsCString ver;
nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal =
do_QueryInterface(channel);
if (httpChannelInternal) {
uint32_t major, minor;
if (NS_SUCCEEDED(httpChannelInternal->GetResponseVersion(&major,
&minor))) {
ver = nsPrintfCString("/%lu.%lu", major, minor);
}
}
// Status text: provide if available. Defaults to "OK".
nsCString statusText;
if (NS_FAILED(httpChannel->GetResponseStatusText(statusText))) {
statusText = "OK";
}
// Assemble everything and pass to listener.
nsPrintfCString status("HTTP%s %lu %s", ver.get(), statusNum,
statusText.get());
static_cast<nsIHTTPHeaderListener*>(mPStreamListener)->StatusLine(status.get());
}
// Also provide all HTTP response headers to our listener.
httpChannel->VisitResponseHeaders(this);
mSeekable = false;
// first we look for a content-encoding header. If we find one, we tell the
// plugin that stream is not seekable, because the plugin always sees
// uncompressed data, so it can't make meaningful range requests on a
// compressed entity. Also, we force the plugin to use
// nsPluginStreamType_AsFile stream type and we have to save decompressed
// file into local plugin cache, because necko cache contains original
// compressed file.
nsAutoCString contentEncoding;
if (NS_SUCCEEDED(httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("Content-Encoding"),
contentEncoding))) {
mUseLocalCache = true;
} else {
// set seekability (seekable if the stream has a known length and if the
// http server accepts byte ranges).
uint32_t length;
GetLength(&length);
if (length) {
nsAutoCString range;
if (NS_SUCCEEDED(httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("accept-ranges"), range)) &&
range.Equals(NS_LITERAL_CSTRING("bytes"), nsCaseInsensitiveCStringComparator())) {
mSeekable = true;
}
}
}
// we require a content len
// get Last-Modified header for plugin info
nsAutoCString lastModified;
if (NS_SUCCEEDED(httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("last-modified"), lastModified)) &&
!lastModified.IsEmpty()) {
PRTime time64;
PR_ParseTimeString(lastModified.get(), true, &time64); //convert string time to integer time
// Convert PRTime to unix-style time_t, i.e. seconds since the epoch
double fpTime = double(time64);
mModified = (uint32_t)(fpTime * 1e-6 + 0.5);
}
}
MOZ_ASSERT(!mRequest);
mRequest = request;
rv = mPStreamListener->OnStartBinding(this);
mStartBinding = true;
if (NS_FAILED(rv))
return rv;
int32_t streamType = NP_NORMAL;
mPStreamListener->GetStreamType(&streamType);
if (streamType != STREAM_TYPE_UNKNOWN) {
OnStreamTypeSet(streamType);
}
return NS_OK;
}
nsresult
GfxInfo::GetFeatureStatusImpl(int32_t aFeature,
int32_t *aStatus,
nsAString &aSuggestedDriverVersion,
const nsTArray<GfxDriverInfo>& aDriverInfo,
nsACString &aFailureId,
OperatingSystem* aOS /* = nullptr */)
{
NS_ENSURE_ARG_POINTER(aStatus);
aSuggestedDriverVersion.SetIsVoid(true);
*aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
OperatingSystem os = mOS;
if (aOS)
*aOS = os;
// OpenGL layers are never blacklisted on Android.
// This early return is so we avoid potentially slow
// GLStrings initialization on startup when we initialize GL layers.
if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS) {
*aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
return NS_OK;
}
EnsureInitialized();
if (mGLStrings->Vendor().IsEmpty() || mGLStrings->Renderer().IsEmpty()) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
return NS_OK;
}
// Don't evaluate special cases when evaluating the downloaded blocklist.
if (aDriverInfo.IsEmpty()) {
if (aFeature == nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION) {
if (mSDKVersion < 11) {
// It's slower than software due to not having a compositing fast path
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;
aFailureId = "FEATURE_FAILURE_CANVAS_2D_SDK";
} else if (mGLStrings->Renderer().Find("Vivante GC1000") != -1) {
// Blocklist Vivante GC1000. See bug 1248183.
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILED_CANVAS_2D_HW";
} else {
*aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
}
return NS_OK;
}
if (aFeature == FEATURE_WEBGL_OPENGL) {
if (mGLStrings->Renderer().Find("Adreno 200") != -1 ||
mGLStrings->Renderer().Find("Adreno 205") != -1)
{
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILURE_ADRENO_20x";
return NS_OK;
}
if (mHardware.EqualsLiteral("ville")) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILURE_VILLE";
return NS_OK;
}
}
if (aFeature == FEATURE_STAGEFRIGHT) {
NS_LossyConvertUTF16toASCII cManufacturer(mManufacturer);
NS_LossyConvertUTF16toASCII cModel(mModel);
NS_LossyConvertUTF16toASCII cHardware(mHardware);
if (cHardware.EqualsLiteral("antares") ||
cHardware.EqualsLiteral("harmony") ||
cHardware.EqualsLiteral("picasso") ||
cHardware.EqualsLiteral("picasso_e") ||
cHardware.EqualsLiteral("ventana") ||
cHardware.EqualsLiteral("rk30board"))
{
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILURE_STAGE_HW";
return NS_OK;
}
if (CompareVersions(mOSVersion.get(), "4.1.0") < 0)
{
// Whitelist:
// All Samsung ICS devices, except for:
// Samsung SGH-I717 (Bug 845729)
// Samsung SGH-I727 (Bug 845729)
// Samsung SGH-I757 (Bug 845729)
// All Galaxy nexus ICS devices
// Sony Xperia Ion (LT28) ICS devices
bool isWhitelisted =
cModel.Equals("LT28h", nsCaseInsensitiveCStringComparator()) ||
cManufacturer.Equals("samsung", nsCaseInsensitiveCStringComparator()) ||
cModel.Equals("galaxy nexus", nsCaseInsensitiveCStringComparator()); // some Galaxy Nexus have manufacturer=amazon
if (cModel.Find("SGH-I717", true) != -1 ||
cModel.Find("SGH-I727", true) != -1 ||
cModel.Find("SGH-I757", true) != -1)
{
isWhitelisted = false;
}
if (!isWhitelisted) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILURE_4_1_HW";
return NS_OK;
}
}
else if (CompareVersions(mOSVersion.get(), "4.2.0") < 0)
{
// Whitelist:
// All JB phones except for those in blocklist below
// Blocklist:
// Samsung devices from bug 812881 and 853522.
// Motorola XT890 from bug 882342.
bool isBlocklisted =
cModel.Find("GT-P3100", true) != -1 ||
cModel.Find("GT-P3110", true) != -1 ||
cModel.Find("GT-P3113", true) != -1 ||
cModel.Find("GT-P5100", true) != -1 ||
cModel.Find("GT-P5110", true) != -1 ||
cModel.Find("GT-P5113", true) != -1 ||
cModel.Find("XT890", true) != -1;
if (isBlocklisted) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILURE_4_2_HW";
return NS_OK;
}
}
else if (CompareVersions(mOSVersion.get(), "4.3.0") < 0)
{
// Blocklist all Sony devices
if (cManufacturer.Find("Sony", true) != -1) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILURE_4_3_SONY";
return NS_OK;
}
}
}
if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_ENCODE) {
if (mozilla::AndroidBridge::Bridge()) {
*aStatus = mozilla::AndroidBridge::Bridge()->GetHWEncoderCapability() ? nsIGfxInfo::FEATURE_STATUS_OK : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILURE_WEBRTC_ENCODE";
return NS_OK;
}
}
if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_DECODE) {
if (mozilla::AndroidBridge::Bridge()) {
*aStatus = mozilla::AndroidBridge::Bridge()->GetHWDecoderCapability() ? nsIGfxInfo::FEATURE_STATUS_OK : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILURE_WEBRTC_DECODE";
return NS_OK;
}
}
if (aFeature == FEATURE_VP8_HW_DECODE || aFeature == FEATURE_VP9_HW_DECODE) {
NS_LossyConvertUTF16toASCII model(mModel);
bool isBlocked =
// GIFV crash, see bug 1232911.
model.Equals("GT-N8013", nsCaseInsensitiveCStringComparator());
if (isBlocked) {
*aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
aFailureId = "FEATURE_FAILURE_VPx";
} else {
*aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
}
return NS_OK;
}
}
return GfxInfoBase::GetFeatureStatusImpl(aFeature, aStatus, aSuggestedDriverVersion, aDriverInfo, aFailureId, &os);
}
void CMapiMessage::ProcessHeaderLine( nsCString& line)
{
PRUint32 len, start;
nsCString tStr;
nsCString left13;
nsCString left26;
nsCString left8;
nsCString left5;
line.Left( left13, 13);
line.Left( left26, 26);
line.Left( left8, 8);
line.Left( left5, 5);
if (left13.Equals(NS_LITERAL_CSTRING("Mime-Version:"), nsCaseInsensitiveCStringComparator()))
m_bMimeVersion = TRUE;
else if (left13.Equals(NS_LITERAL_CSTRING("Content-Type:"), nsCaseInsensitiveCStringComparator())) {
// Note: this isn't a complete parser, the content type
// we extract could have rfc822 comments in it
len = 13;
while ((len < line.Length()) && IsSpace( line.CharAt( len)))
len++;
start = len;
while ((len < line.Length()) && (line.CharAt( len) != ';'))
len++;
line.Mid( m_mimeContentType, start, len - start);
len++;
// look for "boundary="
BOOL haveB;
BOOL haveC;
while (len < line.Length()) {
haveB = FALSE;
haveC = FALSE;
while ((len < line.Length()) && IsSpace( line.CharAt( len)))
len++;
start = len;
while ((len < line.Length()) && (line.CharAt( len) != '='))
len++;
if (len - start) {
line.Mid( tStr, start, len - start);
if (tStr.Equals(NS_LITERAL_CSTRING("boundary"), nsCaseInsensitiveCStringComparator()))
haveB = TRUE;
else if (tStr.Equals(NS_LITERAL_CSTRING("charset"), nsCaseInsensitiveCStringComparator()))
haveC = TRUE;
}
len++;
while ((len < line.Length()) && IsSpace( line.CharAt( len)))
len++;
if ((len < line.Length()) && (line.CharAt( len) == '"')) {
len++;
BOOL slash = FALSE;
tStr.Truncate();
while (len < line.Length()) {
if (slash) {
slash = FALSE;
tStr.Append(line.CharAt( len));
}
else if (line.CharAt( len) == '"')
break;
else if (line.CharAt( len) != '\\')
tStr.Append(line.CharAt( len));
else
slash = TRUE;
len++;
}
len++;
if (haveB) {
m_mimeBoundary = tStr;
haveB = FALSE;
}
if (haveC) {
m_mimeCharset = tStr;
haveC = FALSE;
}
}
tStr.Truncate();
while ((len < line.Length()) && (line.CharAt( len) != ';')) {
tStr.Append(line.CharAt( len));
len++;
}
len++;
if (haveB) {
tStr.Trim( kWhitespace);
m_mimeBoundary = tStr;
}
if (haveC) {
tStr.Trim( kWhitespace);
m_mimeCharset = tStr;
}
}
}
else if (left26.Equals(NS_LITERAL_CSTRING("Content-Transfer-Encoding:"), nsCaseInsensitiveCStringComparator())) {
m_bMimeEncoding = TRUE;
}
else if (left8.Equals(NS_LITERAL_CSTRING("Subject:"), nsCaseInsensitiveCStringComparator()))
m_bHasSubject = TRUE;
else if (left5.Equals(NS_LITERAL_CSTRING("From:"), nsCaseInsensitiveCStringComparator()))
m_bHasFrom = TRUE;
else if (left5.Equals(NS_LITERAL_CSTRING("Date:"), nsCaseInsensitiveCStringComparator()))
m_bHasDate = TRUE;
}
static
nsresult
UpdateAttendee(calIEvent * e,
ews_calendar_item * item,
const nsCString & ownerEmail,
bool required) {
int c = 0;
ews_attendee ** attendees = NULL;
nsresult rv = NS_OK;
if (required) {
c = item->required_attendees_count;
attendees = item->required_attendees;
} else {
c = item->optional_attendees_count;
attendees = item->optional_attendees;
}
if (c == 0 || !attendees)
return NS_OK;
for(int i=0;i < c;i++) {
nsCOMPtr<calIAttendee> a =
do_CreateInstance(CAL_ATTENDEE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCString id;
if (attendees[i]->email_address.routing_type &&
!strcmp(attendees[i]->email_address.routing_type, "EX")) {
id.AppendLiteral("ldap:");
} else {
id.AppendLiteral("mailto:");
}
id.AppendLiteral(attendees[i]->email_address.email);
rv = a->SetId(id);
NS_ENSURE_SUCCESS(rv, rv);
rv = a->SetRsvp(nsCString("FALSE"));
NS_ENSURE_SUCCESS(rv, rv);
rv = a->SetUserType(nsCString("INDIVIDUAL"));
NS_ENSURE_SUCCESS(rv, rv);
rv = a->SetRole(nsCString(required ? "REQ-PARTICIPANT" : "OPT-PARTICIPANT"));
NS_ENSURE_SUCCESS(rv, rv);
nsCString name;
if (attendees[i]->email_address.name) {
name.AssignLiteral(attendees[i]->email_address.name);
}
rv = a->SetCommonName(name);
NS_ENSURE_SUCCESS(rv, rv);
nsCString status;
if (ownerEmail.Equals(nsCString(attendees[i]->email_address.email),
nsCaseInsensitiveCStringComparator())) {
status.AssignLiteral(participationArray[item->my_response_type]);
} else {
status.AssignLiteral(participationArray[attendees[i]->response_type]);
}
rv = a->SetParticipationStatus(status);
NS_ENSURE_SUCCESS(rv, rv);
rv = e->AddAttendee(a);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
