extern "C" NS_GFX_(void) NS_RGBToASCIIHex(nscolor aColor, nsAFlatCString& aResult) { aResult.SetLength(7); NS_ASSERTION(aResult.Length() == 7, "small SetLength failed, use an autostring instead!"); char *buf = aResult.BeginWriting(); PR_snprintf(buf, 8, "#%02x%02x%02x", NS_GET_R(aColor), NS_GET_G(aColor), NS_GET_B(aColor)); }
nsCStringKey::nsCStringKey(const nsAFlatCString& str) : mStr(const_cast<char*>(str.get())), mStrLen(str.Length()), mOwnership(OWN_CLONE) { NS_ASSERTION(mStr, "null string key"); #ifdef DEBUG mKeyType = CStringKey; #endif MOZ_COUNT_CTOR(nsCStringKey); }
nsresult nsTextToSubURI::convertURItoUnicode(const nsAFlatCString &aCharset, const nsAFlatCString &aURI, nsAString &_retval) { // check for 7bit encoding the data may not be ASCII after we decode bool isStatefulCharset = statefulCharset(aCharset.get()); if (!isStatefulCharset) { if (IsASCII(aURI)) { CopyASCIItoUTF16(aURI, _retval); return NS_OK; } if (IsUTF8(aURI)) { CopyUTF8toUTF16(aURI, _retval); return NS_OK; } } // empty charset could indicate UTF-8, but aURI turns out not to be UTF-8. NS_ENSURE_FALSE(aCharset.IsEmpty(), NS_ERROR_INVALID_ARG); nsAutoCString encoding; if (!EncodingUtils::FindEncodingForLabelNoReplacement(aCharset, encoding)) { return NS_ERROR_UCONV_NOCONV; } nsCOMPtr<nsIUnicodeDecoder> unicodeDecoder = EncodingUtils::DecoderForEncoding(encoding); unicodeDecoder->SetInputErrorBehavior(nsIUnicodeDecoder::kOnError_Signal); int32_t srcLen = aURI.Length(); int32_t dstLen; nsresult rv = unicodeDecoder->GetMaxLength(aURI.get(), srcLen, &dstLen); NS_ENSURE_SUCCESS(rv, rv); char16_t *ustr = (char16_t *) moz_xmalloc(dstLen * sizeof(char16_t)); NS_ENSURE_TRUE(ustr, NS_ERROR_OUT_OF_MEMORY); rv = unicodeDecoder->Convert(aURI.get(), &srcLen, ustr, &dstLen); if (NS_SUCCEEDED(rv)) _retval.Assign(ustr, dstLen); free(ustr); return rv; }
bool validOperator(nsAFlatCString& aString) { bool result=false; int len=aString.Length(); switch(len) { case 1: return true; case 3: result=(aString.Equals(NS_LITERAL_CSTRING("<<=")) || aString.Equals(NS_LITERAL_CSTRING(">>="))); break; default: switch(aString[0]) { case '+': case '=': case '&': case '|': case '<': case '>': if((aString[1]==aString[0]) || (aString[1]=='=')) result=true; break; case '-': if((aString[1]==aString[0]) || (aString[1]=='>')) result=true; break; case ':': if((len==2) && (aString[1]==aString[0])) result=true; break; case '*': case '/': case '^': case '!': case '~': case '%': if((aString[1]=='=')) result=true; break; case '(': result=aString[1]==')'; break; case '[': result=aString[1]==']'; break; default: break; } break; } return result; }
// note that this appends to aResult, and does not assign! static void str_escape(const char * original, nsAFlatCString& aResult) { /* JavaScript does not allow quotes, slashes, or line terminators inside * strings so we must escape them. ECMAScript defines four line * terminators, but we're only worrying about \r and \n here. We currently * feed our pref script to the JS interpreter as Latin-1 so we won't * encounter \u2028 (line separator) or \u2029 (paragraph separator). * * WARNING: There are hints that we may be moving to storing prefs * as utf8. If we ever feed them to the JS compiler as UTF8 then * we'll have to worry about the multibyte sequences that would be * interpreted as \u2028 and \u2029 */ const char *p; if (original == NULL) return; /* Paranoid worst case all slashes will free quickly */ for (p=original; *p; ++p) { switch (*p) { case '\n': aResult.Append("\\n"); break; case '\r': aResult.Append("\\r"); break; case '\\': aResult.Append("\\\\"); break; case '\"': aResult.Append("\\\""); break; default: aResult.Append(*p); break; } } }
static nsresult ConvertToUTF8(nsIUnicodeDecoder *aUnicodeDecoder, nsAFlatCString& aString) { int32_t numberOfBytes = aString.Length(); int32_t outUnicodeLen; nsAutoString buffer; nsresult rv = aUnicodeDecoder->GetMaxLength(aString.get(), numberOfBytes, &outUnicodeLen); NS_ENSURE_SUCCESS(rv, rv); if (!EnsureStringLength(buffer, outUnicodeLen)) return NS_ERROR_OUT_OF_MEMORY; rv = aUnicodeDecoder->Convert(aString.get(), &numberOfBytes, buffer.BeginWriting(), &outUnicodeLen); NS_ENSURE_SUCCESS(rv, rv); buffer.SetLength(outUnicodeLen); CopyUTF16toUTF8(buffer, aString); return NS_OK; }
bool CommonElementAnimationData::CanAnimatePropertyOnCompositor(const dom::Element *aElement, nsCSSProperty aProperty) { static bool sShouldLog; static bool sShouldLogPrefCached; if (!sShouldLogPrefCached) { sShouldLogPrefCached = true; Preferences::AddBoolVarCache(&sShouldLog, "layers.offmainthreadcomposition.log-animations"); } nsIFrame* frame = aElement->GetPrimaryFrame(); if (aProperty == eCSSProperty_visibility) { return true; } if (aProperty == eCSSProperty_opacity) { bool enabled = nsLayoutUtils::AreOpacityAnimationsEnabled(); if (!enabled && sShouldLog) { printf_stderr("Performance warning: Async animation of 'opacity' is disabled\n"); } return enabled; } if (aProperty == eCSSProperty_transform) { if (frame && frame->Preserves3D() && frame->Preserves3DChildren()) { if (sShouldLog) { printf_stderr("Gecko bug: Async animation of 'preserve-3d' transforms is not supported. See bug 779598\n"); } return false; } if (frame && frame->IsSVGTransformed()) { if (sShouldLog) { printf_stderr("Gecko bug: Async 'transform' animations of frames with SVG transforms is not supported. See bug 779599\n"); } return false; } bool enabled = nsLayoutUtils::AreTransformAnimationsEnabled(); if (!enabled && sShouldLog) { printf_stderr("Performance warning: Async animation of 'transform' is disabled\n"); } return enabled; } if (sShouldLog) { const nsAFlatCString propName = nsCSSProps::GetStringValue(aProperty); printf_stderr("Performance warning: Async animation cancelled because of unsupported property '%s'\n", propName.get()); } return false; }
nsresult nsTextToSubURI::convertURItoUnicode(const nsAFlatCString &aCharset, const nsAFlatCString &aURI, bool aIRI, nsAString &_retval) { nsresult rv = NS_OK; // check for 7bit encoding the data may not be ASCII after we decode bool isStatefulCharset = statefulCharset(aCharset.get()); if (!isStatefulCharset && IsASCII(aURI)) { CopyASCIItoUTF16(aURI, _retval); return rv; } if (!isStatefulCharset && aIRI) { if (IsUTF8(aURI)) { CopyUTF8toUTF16(aURI, _retval); return rv; } } // empty charset could indicate UTF-8, but aURI turns out not to be UTF-8. NS_ENSURE_FALSE(aCharset.IsEmpty(), NS_ERROR_INVALID_ARG); nsCOMPtr<nsICharsetConverterManager> charsetConverterManager; charsetConverterManager = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIUnicodeDecoder> unicodeDecoder; rv = charsetConverterManager->GetUnicodeDecoder(aCharset.get(), getter_AddRefs(unicodeDecoder)); NS_ENSURE_SUCCESS(rv, rv); unicodeDecoder->SetInputErrorBehavior(nsIUnicodeDecoder::kOnError_Signal); int32_t srcLen = aURI.Length(); int32_t dstLen; rv = unicodeDecoder->GetMaxLength(aURI.get(), srcLen, &dstLen); NS_ENSURE_SUCCESS(rv, rv); char16_t *ustr = (char16_t *) NS_Alloc(dstLen * sizeof(char16_t)); NS_ENSURE_TRUE(ustr, NS_ERROR_OUT_OF_MEMORY); rv = unicodeDecoder->Convert(aURI.get(), &srcLen, ustr, &dstLen); if (NS_SUCCEEDED(rv)) _retval.Assign(ustr, dstLen); NS_Free(ustr); return rv; }
/** * Consume characters until you find one contained in given * input set. * * @update gess 3/25/98 * @param * @return error code */ int CScanner::readUntil(nsAFlatCString& aString,nsAFlatCString& aTerminalSet,bool addTerminal){ char theChar=0; int result=kNoError; while(kNoError == result) { result=getChar(theChar); if(kNoError==result) { int pos=aTerminalSet.FindChar(theChar); if(kNotFound!=pos) { if(addTerminal) aString+=theChar; else push(theChar); break; } else aString+=theChar; } } return result; }
nsresult nsTestUConv::Encode(PRUnichar ** aSrc, PRUnichar * aSrcEnd, char ** aDest, char * aDestEnd, const nsAFlatCString& aCharset) { char * trace = "Encode"; mLog.AddTrace(trace); nsresult res = NS_OK; nsCOMPtr<nsICharsetConverterManager> ccMan = do_GetService(kCharsetConverterManagerCID, &res); if (NS_FAILED(res)) { mLog.PrintError("NS_WITH_SERVICE", res); return res; } nsCOMPtr<nsIUnicodeEncoder> enc; res = ccMan->GetUnicodeEncoder(aCharset.get(), getter_AddRefs(enc)); if (NS_FAILED(res)) { mLog.PrintError("GetUnicodeEncoder()", res); return res; } res = ConvertEncode(aSrc, aSrcEnd, aDest, aDestEnd, enc); if (NS_FAILED(res)) { mLog.PrintError("Convert()", res); return res; } res = FinishEncode(aDest, aDestEnd, enc); if (NS_FAILED(res)) { mLog.PrintError("Finish()", res); return res; } mLog.DelTrace(trace); return res; }
nsresult nsHttpChannelAuthProvider::GetCredentialsForChallenge(const char *challenge, const char *authType, bool proxyAuth, nsIHttpAuthenticator *auth, nsAFlatCString &creds) { LOG(("nsHttpChannelAuthProvider::GetCredentialsForChallenge " "[this=%p channel=%p proxyAuth=%d challenges=%s]\n", this, mAuthChannel, proxyAuth, challenge)); // this getter never fails nsHttpAuthCache *authCache = gHttpHandler->AuthCache(); uint32_t authFlags; nsresult rv = auth->GetAuthFlags(&authFlags); if (NS_FAILED(rv)) return rv; nsCAutoString realm; ParseRealm(challenge, realm); // if no realm, then use the auth type as the realm. ToUpperCase so the // ficticious realm stands out a bit more. // XXX this will cause some single signon misses! // XXX this was meant to be used with NTLM, which supplies no realm. /* if (realm.IsEmpty()) { realm = authType; ToUpperCase(realm); } */ // set informations that depend on whether // we're authenticating against a proxy // or a webserver const char *host; int32_t port; nsHttpAuthIdentity *ident; nsCAutoString path, scheme; bool identFromURI = false; nsISupports **continuationState; rv = GetAuthorizationMembers(proxyAuth, scheme, host, port, path, ident, continuationState); if (NS_FAILED(rv)) return rv; if (!proxyAuth) { // if this is the first challenge, then try using the identity // specified in the URL. if (mIdent.IsEmpty()) { GetIdentityFromURI(authFlags, mIdent); identFromURI = !mIdent.IsEmpty(); } } // // if we already tried some credentials for this transaction, then // we need to possibly clear them from the cache, unless the credentials // in the cache have changed, in which case we'd want to give them a // try instead. // nsHttpAuthEntry *entry = nullptr; authCache->GetAuthEntryForDomain(scheme.get(), host, port, realm.get(), &entry); // hold reference to the auth session state (in case we clear our // reference to the entry). nsCOMPtr<nsISupports> sessionStateGrip; if (entry) sessionStateGrip = entry->mMetaData; // for digest auth, maybe our cached nonce value simply timed out... bool identityInvalid; nsISupports *sessionState = sessionStateGrip; rv = auth->ChallengeReceived(mAuthChannel, challenge, proxyAuth, &sessionState, &*continuationState, &identityInvalid); sessionStateGrip.swap(sessionState); if (NS_FAILED(rv)) return rv; LOG((" identity invalid = %d\n", identityInvalid)); if (identityInvalid) { if (entry) { if (ident->Equals(entry->Identity())) { LOG((" clearing bad auth cache entry\n")); // ok, we've already tried this user identity, so clear the // corresponding entry from the auth cache. authCache->ClearAuthEntry(scheme.get(), host, port, realm.get()); entry = nullptr; ident->Clear(); } else if (!identFromURI || nsCRT::strcmp(ident->User(), entry->Identity().User()) == 0) { LOG((" taking identity from auth cache\n")); // the password from the auth cache is more likely to be // correct than the one in the URL. at least, we know that it // works with the given username. it is possible for a server // to distinguish logons based on the supplied password alone, // but that would be quite unusual... and i don't think we need // to worry about such unorthodox cases. ident->Set(entry->Identity()); identFromURI = false; if (entry->Creds()[0] != '\0') { LOG((" using cached credentials!\n")); creds.Assign(entry->Creds()); return entry->AddPath(path.get()); } } } else if (!identFromURI) { // hmm... identity invalid, but no auth entry! the realm probably // changed (see bug 201986). ident->Clear(); } if (!entry && ident->IsEmpty()) { uint32_t level = nsIAuthPrompt2::LEVEL_NONE; if (mUsingSSL) level = nsIAuthPrompt2::LEVEL_SECURE; else if (authFlags & nsIHttpAuthenticator::IDENTITY_ENCRYPTED) level = nsIAuthPrompt2::LEVEL_PW_ENCRYPTED; // at this point we are forced to interact with the user to get // their username and password for this domain. rv = PromptForIdentity(level, proxyAuth, realm.get(), authType, authFlags, *ident); if (NS_FAILED(rv)) return rv; identFromURI = false; } } if (identFromURI) { // Warn the user before automatically using the identity from the URL // to automatically log them into a site (see bug 232567). if (!ConfirmAuth(NS_LITERAL_STRING("AutomaticAuth"), false)) { // calling cancel here sets our mStatus and aborts the HTTP // transaction, which prevents OnDataAvailable events. mAuthChannel->Cancel(NS_ERROR_ABORT); // this return code alone is not equivalent to Cancel, since // it only instructs our caller that authentication failed. // without an explicit call to Cancel, our caller would just // load the page that accompanies the HTTP auth challenge. return NS_ERROR_ABORT; } } // // get credentials for the given user:pass // // always store the credentials we're trying now so that they will be used // on subsequent links. This will potentially remove good credentials from // the cache. This is ok as we don't want to use cached credentials if the // user specified something on the URI or in another manner. This is so // that we don't transparently authenticate as someone they're not // expecting to authenticate as. // nsXPIDLCString result; rv = GenCredsAndSetEntry(auth, proxyAuth, scheme.get(), host, port, path.get(), realm.get(), challenge, *ident, sessionStateGrip, getter_Copies(result)); if (NS_SUCCEEDED(rv)) creds = result; return rv; }
nsresult nsPermissionManager::AddInternal(const nsAFlatCString &aHost, const nsAFlatCString &aType, PRUint32 aPermission, PRInt64 aID, PRUint32 aExpireType, PRInt64 aExpireTime, NotifyOperationType aNotifyOperation, DBOperationType aDBOperation) { if (!IsChildProcess()) { IPC::Permission permission((aHost), (aType), aPermission, aExpireType, aExpireTime); nsTArray<ContentParent*> cplist; ContentParent::GetAll(cplist); for (PRUint32 i = 0; i < cplist.Length(); ++i) { ContentParent* cp = cplist[i]; if (cp->NeedsPermissionsUpdate()) unused << cp->SendAddPermission(permission); } } if (!gHostArena) { gHostArena = new PLArenaPool; if (!gHostArena) return NS_ERROR_OUT_OF_MEMORY; PL_INIT_ARENA_POOL(gHostArena, "PermissionHostArena", HOST_ARENA_SIZE); } // look up the type index PRInt32 typeIndex = GetTypeIndex(aType.get(), true); NS_ENSURE_TRUE(typeIndex != -1, NS_ERROR_OUT_OF_MEMORY); // When an entry already exists, PutEntry will return that, instead // of adding a new one nsHostEntry *entry = mHostTable.PutEntry(aHost.get()); if (!entry) return NS_ERROR_FAILURE; if (!entry->GetKey()) { mHostTable.RawRemoveEntry(entry); return NS_ERROR_OUT_OF_MEMORY; } // figure out the transaction type, and get any existing permission value OperationType op; PRInt32 index = entry->GetPermissionIndex(typeIndex); if (index == -1) { if (aPermission == nsIPermissionManager::UNKNOWN_ACTION) op = eOperationNone; else op = eOperationAdding; } else { nsPermissionEntry oldPermissionEntry = entry->GetPermissions()[index]; // remove the permission if the permission is UNKNOWN, update the // permission if its value or expire type have changed OR if the time has // changed and the expire type is time, otherwise, don't modify. There's // no need to modify a permission that doesn't expire with time when the // only thing changed is the expire time. if (aPermission == oldPermissionEntry.mPermission && aExpireType == oldPermissionEntry.mExpireType && (aExpireType != nsIPermissionManager::EXPIRE_TIME || aExpireTime == oldPermissionEntry.mExpireTime)) op = eOperationNone; else if (aPermission == nsIPermissionManager::UNKNOWN_ACTION) op = eOperationRemoving; else op = eOperationChanging; } // do the work for adding, deleting, or changing a permission: // update the in-memory list, write to the db, and notify consumers. PRInt64 id; switch (op) { case eOperationNone: { // nothing to do return NS_OK; } case eOperationAdding: { if (aDBOperation == eWriteToDB) { // we'll be writing to the database - generate a known unique id id = ++mLargestID; } else { // we're reading from the database - use the id already assigned id = aID; } entry->GetPermissions().AppendElement(nsPermissionEntry(typeIndex, aPermission, id, aExpireType, aExpireTime)); if (aDBOperation == eWriteToDB && aExpireType != nsIPermissionManager::EXPIRE_SESSION) UpdateDB(op, mStmtInsert, id, aHost, aType, aPermission, aExpireType, aExpireTime); if (aNotifyOperation == eNotify) { NotifyObserversWithPermission(aHost, mTypeArray[typeIndex], aPermission, aExpireType, aExpireTime, NS_LITERAL_STRING("added").get()); } break; } case eOperationRemoving: { nsPermissionEntry oldPermissionEntry = entry->GetPermissions()[index]; id = oldPermissionEntry.mID; entry->GetPermissions().RemoveElementAt(index); // If no more types are present, remove the entry if (entry->GetPermissions().IsEmpty()) mHostTable.RawRemoveEntry(entry); if (aDBOperation == eWriteToDB) UpdateDB(op, mStmtDelete, id, EmptyCString(), EmptyCString(), 0, nsIPermissionManager::EXPIRE_NEVER, 0); if (aNotifyOperation == eNotify) { NotifyObserversWithPermission(aHost, mTypeArray[typeIndex], oldPermissionEntry.mPermission, oldPermissionEntry.mExpireType, oldPermissionEntry.mExpireTime, NS_LITERAL_STRING("deleted").get()); } break; } case eOperationChanging: { id = entry->GetPermissions()[index].mID; entry->GetPermissions()[index].mPermission = aPermission; if (aDBOperation == eWriteToDB && aExpireType != nsIPermissionManager::EXPIRE_SESSION) UpdateDB(op, mStmtUpdate, id, EmptyCString(), EmptyCString(), aPermission, aExpireType, aExpireTime); if (aNotifyOperation == eNotify) { NotifyObserversWithPermission(aHost, mTypeArray[typeIndex], aPermission, aExpireType, aExpireTime, NS_LITERAL_STRING("changed").get()); } break; } } return NS_OK; }
void logging::Enable(const nsAFlatCString& aModules) { EnableLogging(aModules.get()); }
//---------------------------------------------------------------------------------------- void nsPersistentFileDescriptor::SetData(const nsAFlatCString& inData) //---------------------------------------------------------------------------------------- { mDescriptorString.CopyFrom(inData.get(), inData.Length()); }
//---------------------------------------------------------------------------------------- void nsPersistentFileDescriptor::GetData(nsAFlatCString& outData) const //---------------------------------------------------------------------------------------- { outData.Assign(mDescriptorString, mDescriptorString.Length()); }