f6d23d0dde
This change renames OriginAttributes.mInBrowser to mInIsolatedMozBrowser and nsIPrincipal::GetIsInBrowserElement to GetIsInIsolatedMozBrowserElement. Other methods that pass these values around also have name changes. Tokens such as "inBrowser" have previously been serialized into cache keys, used as DB column names, stored in app registries, etc. No changes are made to any serialization formats. Only runtime method and variable names are updated. No behavior changes are made in this patch, so some renamed methods may have nonsensical implementations. These are corrected in subsequent patches focused on behavior. MozReview-Commit-ID: 66HfMlsXFLs
2330 lines
75 KiB
C++
2330 lines
75 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* vim:set ts=4 sw=4 sts=4 et cin: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
// HttpLog.h should generally be included first
|
|
#include "HttpLog.h"
|
|
|
|
#include "mozilla/LoadContext.h"
|
|
#include "mozilla/LoadInfo.h"
|
|
#include "mozilla/BasePrincipal.h"
|
|
#include "mozilla/Telemetry.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsNetUtil.inl"
|
|
#include "mozIApplicationClearPrivateDataParams.h"
|
|
#include "nsCategoryCache.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsHashKeys.h"
|
|
#include "nsHttp.h"
|
|
#include "nsIAsyncStreamCopier.h"
|
|
#include "nsIAuthPrompt.h"
|
|
#include "nsIAuthPrompt2.h"
|
|
#include "nsIAuthPromptAdapterFactory.h"
|
|
#include "nsIBufferedStreams.h"
|
|
#include "nsIChannelEventSink.h"
|
|
#include "nsIContentSniffer.h"
|
|
#include "nsIDownloader.h"
|
|
#include "nsIFileProtocolHandler.h"
|
|
#include "nsIFileStreams.h"
|
|
#include "nsIFileURL.h"
|
|
#include "nsIIDNService.h"
|
|
#include "nsIInputStreamChannel.h"
|
|
#include "nsIInputStreamPump.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsILoadContext.h"
|
|
#include "nsIMIMEHeaderParam.h"
|
|
#include "nsIMutable.h"
|
|
#include "nsIOfflineCacheUpdate.h"
|
|
#include "nsIPersistentProperties2.h"
|
|
#include "nsIPrivateBrowsingChannel.h"
|
|
#include "nsIPropertyBag2.h"
|
|
#include "nsIProtocolProxyService.h"
|
|
#include "nsIRedirectChannelRegistrar.h"
|
|
#include "nsIRequestObserverProxy.h"
|
|
#include "nsIScriptSecurityManager.h"
|
|
#include "nsISimpleStreamListener.h"
|
|
#include "nsISocketProvider.h"
|
|
#include "nsISocketProviderService.h"
|
|
#include "nsIStandardURL.h"
|
|
#include "nsIStreamLoader.h"
|
|
#include "nsIIncrementalStreamLoader.h"
|
|
#include "nsIStreamTransportService.h"
|
|
#include "nsStringStream.h"
|
|
#include "nsISyncStreamListener.h"
|
|
#include "nsITransport.h"
|
|
#include "nsIUnicharStreamLoader.h"
|
|
#include "nsIURIWithPrincipal.h"
|
|
#include "nsIURLParser.h"
|
|
#include "nsIUUIDGenerator.h"
|
|
#include "nsIViewSourceChannel.h"
|
|
#include "nsInterfaceRequestorAgg.h"
|
|
#include "plstr.h"
|
|
#include "nsINestedURI.h"
|
|
#include "mozilla/dom/nsCSPUtils.h"
|
|
#include "mozilla/net/HttpBaseChannel.h"
|
|
#include "nsIScriptError.h"
|
|
#include "nsISiteSecurityService.h"
|
|
#include "nsHttpHandler.h"
|
|
|
|
#ifdef MOZ_WIDGET_GONK
|
|
#include "nsINetworkManager.h"
|
|
#include "nsThreadUtils.h" // for NS_IsMainThread
|
|
#endif
|
|
|
|
#include <limits>
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::net;
|
|
|
|
nsresult /*NS_NewChannelWithNodeAndTriggeringPrincipal */
|
|
NS_NewChannelWithTriggeringPrincipal(nsIChannel **outChannel,
|
|
nsIURI *aUri,
|
|
nsINode *aLoadingNode,
|
|
nsIPrincipal *aTriggeringPrincipal,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
nsILoadGroup *aLoadGroup /* = nullptr */,
|
|
nsIInterfaceRequestor *aCallbacks /* = nullptr */,
|
|
nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
|
|
nsIIOService *aIoService /* = nullptr */)
|
|
{
|
|
MOZ_ASSERT(aLoadingNode);
|
|
NS_ASSERTION(aTriggeringPrincipal, "Can not create channel without a triggering Principal!");
|
|
return NS_NewChannelInternal(outChannel,
|
|
aUri,
|
|
aLoadingNode,
|
|
aLoadingNode->NodePrincipal(),
|
|
aTriggeringPrincipal,
|
|
aSecurityFlags,
|
|
aContentPolicyType,
|
|
aLoadGroup,
|
|
aCallbacks,
|
|
aLoadFlags,
|
|
aIoService);
|
|
}
|
|
|
|
// See NS_NewChannelInternal for usage and argument description
|
|
nsresult /*NS_NewChannelWithPrincipalAndTriggeringPrincipal */
|
|
NS_NewChannelWithTriggeringPrincipal(nsIChannel **outChannel,
|
|
nsIURI *aUri,
|
|
nsIPrincipal *aLoadingPrincipal,
|
|
nsIPrincipal *aTriggeringPrincipal,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
nsILoadGroup *aLoadGroup /* = nullptr */,
|
|
nsIInterfaceRequestor *aCallbacks /* = nullptr */,
|
|
nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
|
|
nsIIOService *aIoService /* = nullptr */)
|
|
{
|
|
NS_ASSERTION(aLoadingPrincipal, "Can not create channel without a loading Principal!");
|
|
return NS_NewChannelInternal(outChannel,
|
|
aUri,
|
|
nullptr, // aLoadingNode
|
|
aLoadingPrincipal,
|
|
aTriggeringPrincipal,
|
|
aSecurityFlags,
|
|
aContentPolicyType,
|
|
aLoadGroup,
|
|
aCallbacks,
|
|
aLoadFlags,
|
|
aIoService);
|
|
}
|
|
|
|
nsresult /* NS_NewChannelNode */
|
|
NS_NewChannel(nsIChannel **outChannel,
|
|
nsIURI *aUri,
|
|
nsINode *aLoadingNode,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
nsILoadGroup *aLoadGroup /* = nullptr */,
|
|
nsIInterfaceRequestor *aCallbacks /* = nullptr */,
|
|
nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
|
|
nsIIOService *aIoService /* = nullptr */)
|
|
{
|
|
NS_ASSERTION(aLoadingNode, "Can not create channel without a loading Node!");
|
|
return NS_NewChannelInternal(outChannel,
|
|
aUri,
|
|
aLoadingNode,
|
|
aLoadingNode->NodePrincipal(),
|
|
nullptr, // aTriggeringPrincipal
|
|
aSecurityFlags,
|
|
aContentPolicyType,
|
|
aLoadGroup,
|
|
aCallbacks,
|
|
aLoadFlags,
|
|
aIoService);
|
|
}
|
|
|
|
nsresult
|
|
NS_MakeAbsoluteURI(nsACString &result,
|
|
const nsACString &spec,
|
|
nsIURI *baseURI)
|
|
{
|
|
nsresult rv;
|
|
if (!baseURI) {
|
|
NS_WARNING("It doesn't make sense to not supply a base URI");
|
|
result = spec;
|
|
rv = NS_OK;
|
|
}
|
|
else if (spec.IsEmpty())
|
|
rv = baseURI->GetSpec(result);
|
|
else
|
|
rv = baseURI->Resolve(spec, result);
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_MakeAbsoluteURI(char **result,
|
|
const char *spec,
|
|
nsIURI *baseURI)
|
|
{
|
|
nsresult rv;
|
|
nsAutoCString resultBuf;
|
|
rv = NS_MakeAbsoluteURI(resultBuf, nsDependentCString(spec), baseURI);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
*result = ToNewCString(resultBuf);
|
|
if (!*result)
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_MakeAbsoluteURI(nsAString &result,
|
|
const nsAString &spec,
|
|
nsIURI *baseURI)
|
|
{
|
|
nsresult rv;
|
|
if (!baseURI) {
|
|
NS_WARNING("It doesn't make sense to not supply a base URI");
|
|
result = spec;
|
|
rv = NS_OK;
|
|
}
|
|
else {
|
|
nsAutoCString resultBuf;
|
|
if (spec.IsEmpty())
|
|
rv = baseURI->GetSpec(resultBuf);
|
|
else
|
|
rv = baseURI->Resolve(NS_ConvertUTF16toUTF8(spec), resultBuf);
|
|
if (NS_SUCCEEDED(rv))
|
|
CopyUTF8toUTF16(resultBuf, result);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
int32_t
|
|
NS_GetDefaultPort(const char *scheme,
|
|
nsIIOService *ioService /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIIOService> grip;
|
|
net_EnsureIOService(&ioService, grip);
|
|
if (!ioService)
|
|
return -1;
|
|
|
|
nsCOMPtr<nsIProtocolHandler> handler;
|
|
rv = ioService->GetProtocolHandler(scheme, getter_AddRefs(handler));
|
|
if (NS_FAILED(rv))
|
|
return -1;
|
|
int32_t port;
|
|
rv = handler->GetDefaultPort(&port);
|
|
return NS_SUCCEEDED(rv) ? port : -1;
|
|
}
|
|
|
|
/**
|
|
* This function is a helper function to apply the ToAscii conversion
|
|
* to a string
|
|
*/
|
|
bool
|
|
NS_StringToACE(const nsACString &idn, nsACString &result)
|
|
{
|
|
nsCOMPtr<nsIIDNService> idnSrv = do_GetService(NS_IDNSERVICE_CONTRACTID);
|
|
if (!idnSrv)
|
|
return false;
|
|
nsresult rv = idnSrv->ConvertUTF8toACE(idn, result);
|
|
if (NS_FAILED(rv))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
int32_t
|
|
NS_GetRealPort(nsIURI *aURI)
|
|
{
|
|
int32_t port;
|
|
nsresult rv = aURI->GetPort(&port);
|
|
if (NS_FAILED(rv))
|
|
return -1;
|
|
|
|
if (port != -1)
|
|
return port; // explicitly specified
|
|
|
|
// Otherwise, we have to get the default port from the protocol handler
|
|
|
|
// Need the scheme first
|
|
nsAutoCString scheme;
|
|
rv = aURI->GetScheme(scheme);
|
|
if (NS_FAILED(rv))
|
|
return -1;
|
|
|
|
return NS_GetDefaultPort(scheme.get());
|
|
}
|
|
|
|
nsresult /* NS_NewInputStreamChannelWithLoadInfo */
|
|
NS_NewInputStreamChannelInternal(nsIChannel **outChannel,
|
|
nsIURI *aUri,
|
|
nsIInputStream *aStream,
|
|
const nsACString &aContentType,
|
|
const nsACString &aContentCharset,
|
|
nsILoadInfo *aLoadInfo)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIInputStreamChannel> isc =
|
|
do_CreateInstance(NS_INPUTSTREAMCHANNEL_CONTRACTID, &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
rv = isc->SetURI(aUri);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
rv = isc->SetContentStream(aStream);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIChannel> channel = do_QueryInterface(isc, &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!aContentType.IsEmpty()) {
|
|
rv = channel->SetContentType(aContentType);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
if (!aContentCharset.IsEmpty()) {
|
|
rv = channel->SetContentCharset(aContentCharset);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
channel->SetLoadInfo(aLoadInfo);
|
|
|
|
// If we're sandboxed, make sure to clear any owner the channel
|
|
// might already have.
|
|
if (aLoadInfo && aLoadInfo->GetLoadingSandboxed()) {
|
|
channel->SetOwner(nullptr);
|
|
}
|
|
|
|
channel.forget(outChannel);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewInputStreamChannelInternal(nsIChannel **outChannel,
|
|
nsIURI *aUri,
|
|
nsIInputStream *aStream,
|
|
const nsACString &aContentType,
|
|
const nsACString &aContentCharset,
|
|
nsINode *aLoadingNode,
|
|
nsIPrincipal *aLoadingPrincipal,
|
|
nsIPrincipal *aTriggeringPrincipal,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType)
|
|
{
|
|
nsCOMPtr<nsILoadInfo> loadInfo =
|
|
new mozilla::LoadInfo(aLoadingPrincipal,
|
|
aTriggeringPrincipal,
|
|
aLoadingNode,
|
|
aSecurityFlags,
|
|
aContentPolicyType);
|
|
if (!loadInfo) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
return NS_NewInputStreamChannelInternal(outChannel,
|
|
aUri,
|
|
aStream,
|
|
aContentType,
|
|
aContentCharset,
|
|
loadInfo);
|
|
}
|
|
|
|
nsresult /* NS_NewInputStreamChannelPrincipal */
|
|
NS_NewInputStreamChannel(nsIChannel **outChannel,
|
|
nsIURI *aUri,
|
|
nsIInputStream *aStream,
|
|
nsIPrincipal *aLoadingPrincipal,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
const nsACString &aContentType /* = EmptyCString() */,
|
|
const nsACString &aContentCharset /* = EmptyCString() */)
|
|
{
|
|
return NS_NewInputStreamChannelInternal(outChannel,
|
|
aUri,
|
|
aStream,
|
|
aContentType,
|
|
aContentCharset,
|
|
nullptr, // aLoadingNode
|
|
aLoadingPrincipal,
|
|
nullptr, // aTriggeringPrincipal
|
|
aSecurityFlags,
|
|
aContentPolicyType);
|
|
}
|
|
|
|
nsresult
|
|
NS_NewInputStreamChannelInternal(nsIChannel **outChannel,
|
|
nsIURI *aUri,
|
|
const nsAString &aData,
|
|
const nsACString &aContentType,
|
|
nsINode *aLoadingNode,
|
|
nsIPrincipal *aLoadingPrincipal,
|
|
nsIPrincipal *aTriggeringPrincipal,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
bool aIsSrcdocChannel /* = false */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIStringInputStream> stream;
|
|
stream = do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID, &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
#ifdef MOZILLA_INTERNAL_API
|
|
uint32_t len;
|
|
char* utf8Bytes = ToNewUTF8String(aData, &len);
|
|
rv = stream->AdoptData(utf8Bytes, len);
|
|
#else
|
|
char* utf8Bytes = ToNewUTF8String(aData);
|
|
rv = stream->AdoptData(utf8Bytes, strlen(utf8Bytes));
|
|
#endif
|
|
|
|
nsCOMPtr<nsIChannel> channel;
|
|
rv = NS_NewInputStreamChannelInternal(getter_AddRefs(channel),
|
|
aUri,
|
|
stream,
|
|
aContentType,
|
|
NS_LITERAL_CSTRING("UTF-8"),
|
|
aLoadingNode,
|
|
aLoadingPrincipal,
|
|
aTriggeringPrincipal,
|
|
aSecurityFlags,
|
|
aContentPolicyType);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (aIsSrcdocChannel) {
|
|
nsCOMPtr<nsIInputStreamChannel> inStrmChan = do_QueryInterface(channel);
|
|
NS_ENSURE_TRUE(inStrmChan, NS_ERROR_FAILURE);
|
|
inStrmChan->SetSrcdocData(aData);
|
|
}
|
|
channel.forget(outChannel);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewInputStreamChannel(nsIChannel **outChannel,
|
|
nsIURI *aUri,
|
|
const nsAString &aData,
|
|
const nsACString &aContentType,
|
|
nsIPrincipal *aLoadingPrincipal,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
bool aIsSrcdocChannel /* = false */)
|
|
{
|
|
return NS_NewInputStreamChannelInternal(outChannel,
|
|
aUri,
|
|
aData,
|
|
aContentType,
|
|
nullptr, // aLoadingNode
|
|
aLoadingPrincipal,
|
|
nullptr, // aTriggeringPrincipal
|
|
aSecurityFlags,
|
|
aContentPolicyType,
|
|
aIsSrcdocChannel);
|
|
}
|
|
|
|
nsresult
|
|
NS_NewInputStreamPump(nsIInputStreamPump **result,
|
|
nsIInputStream *stream,
|
|
int64_t streamPos /* = int64_t(-1) */,
|
|
int64_t streamLen /* = int64_t(-1) */,
|
|
uint32_t segsize /* = 0 */,
|
|
uint32_t segcount /* = 0 */,
|
|
bool closeWhenDone /* = false */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIInputStreamPump> pump =
|
|
do_CreateInstance(NS_INPUTSTREAMPUMP_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = pump->Init(stream, streamPos, streamLen,
|
|
segsize, segcount, closeWhenDone);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
*result = nullptr;
|
|
pump.swap(*result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewAsyncStreamCopier(nsIAsyncStreamCopier **result,
|
|
nsIInputStream *source,
|
|
nsIOutputStream *sink,
|
|
nsIEventTarget *target,
|
|
bool sourceBuffered /* = true */,
|
|
bool sinkBuffered /* = true */,
|
|
uint32_t chunkSize /* = 0 */,
|
|
bool closeSource /* = true */,
|
|
bool closeSink /* = true */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIAsyncStreamCopier> copier =
|
|
do_CreateInstance(NS_ASYNCSTREAMCOPIER_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = copier->Init(source, sink, target, sourceBuffered, sinkBuffered,
|
|
chunkSize, closeSource, closeSink);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
*result = nullptr;
|
|
copier.swap(*result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewLoadGroup(nsILoadGroup **result,
|
|
nsIRequestObserver *obs)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsILoadGroup> group =
|
|
do_CreateInstance(NS_LOADGROUP_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = group->SetGroupObserver(obs);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
*result = nullptr;
|
|
group.swap(*result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
bool NS_IsReasonableHTTPHeaderValue(const nsACString &aValue)
|
|
{
|
|
return mozilla::net::nsHttp::IsReasonableHeaderValue(aValue);
|
|
}
|
|
|
|
bool NS_IsValidHTTPToken(const nsACString &aToken)
|
|
{
|
|
return mozilla::net::nsHttp::IsValidToken(aToken);
|
|
}
|
|
|
|
nsresult
|
|
NS_NewLoadGroup(nsILoadGroup **aResult, nsIPrincipal *aPrincipal)
|
|
{
|
|
using mozilla::LoadContext;
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsILoadGroup> group =
|
|
do_CreateInstance(NS_LOADGROUP_CONTRACTID, &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
RefPtr<LoadContext> loadContext = new LoadContext(aPrincipal);
|
|
rv = group->SetNotificationCallbacks(loadContext);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
group.forget(aResult);
|
|
return rv;
|
|
}
|
|
|
|
bool
|
|
NS_LoadGroupMatchesPrincipal(nsILoadGroup *aLoadGroup,
|
|
nsIPrincipal *aPrincipal)
|
|
{
|
|
if (!aPrincipal) {
|
|
return false;
|
|
}
|
|
|
|
// If this is a null principal then the load group doesn't really matter.
|
|
// The principal will not be allowed to perform any actions that actually
|
|
// use the load group. Unconditionally treat null principals as a match.
|
|
bool isNullPrincipal;
|
|
nsresult rv = aPrincipal->GetIsNullPrincipal(&isNullPrincipal);
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
if (isNullPrincipal) {
|
|
return true;
|
|
}
|
|
|
|
if (!aLoadGroup) {
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsILoadContext> loadContext;
|
|
NS_QueryNotificationCallbacks(nullptr, aLoadGroup, NS_GET_IID(nsILoadContext),
|
|
getter_AddRefs(loadContext));
|
|
NS_ENSURE_TRUE(loadContext, false);
|
|
|
|
// Verify load context appId and browser flag match the principal
|
|
uint32_t contextAppId;
|
|
bool contextInBrowserElement;
|
|
rv = loadContext->GetAppId(&contextAppId);
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
rv = loadContext->GetIsInBrowserElement(&contextInBrowserElement);
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
|
|
uint32_t principalAppId;
|
|
bool principalInIsolatedBrowser;
|
|
rv = aPrincipal->GetAppId(&principalAppId);
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
rv = aPrincipal->GetIsInIsolatedMozBrowserElement(&principalInIsolatedBrowser);
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
|
|
return contextAppId == principalAppId &&
|
|
contextInBrowserElement == principalInIsolatedBrowser;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewDownloader(nsIStreamListener **result,
|
|
nsIDownloadObserver *observer,
|
|
nsIFile *downloadLocation /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIDownloader> downloader =
|
|
do_CreateInstance(NS_DOWNLOADER_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = downloader->Init(observer, downloadLocation);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
downloader.forget(result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewIncrementalStreamLoader(nsIIncrementalStreamLoader **result,
|
|
nsIIncrementalStreamLoaderObserver *observer)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIIncrementalStreamLoader> loader =
|
|
do_CreateInstance(NS_INCREMENTALSTREAMLOADER_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = loader->Init(observer);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
*result = nullptr;
|
|
loader.swap(*result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewStreamLoaderInternal(nsIStreamLoader **outStream,
|
|
nsIURI *aUri,
|
|
nsIStreamLoaderObserver *aObserver,
|
|
nsINode *aLoadingNode,
|
|
nsIPrincipal *aLoadingPrincipal,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
nsILoadGroup *aLoadGroup /* = nullptr */,
|
|
nsIInterfaceRequestor *aCallbacks /* = nullptr */,
|
|
nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
|
|
nsIURI *aReferrer /* = nullptr */)
|
|
{
|
|
nsCOMPtr<nsIChannel> channel;
|
|
nsresult rv = NS_NewChannelInternal(getter_AddRefs(channel),
|
|
aUri,
|
|
aLoadingNode,
|
|
aLoadingPrincipal,
|
|
nullptr, // aTriggeringPrincipal
|
|
aSecurityFlags,
|
|
aContentPolicyType,
|
|
aLoadGroup,
|
|
aCallbacks,
|
|
aLoadFlags);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
|
|
if (httpChannel) {
|
|
httpChannel->SetReferrer(aReferrer);
|
|
}
|
|
rv = NS_NewStreamLoader(outStream, aObserver);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
return channel->AsyncOpen2(*outStream);
|
|
}
|
|
|
|
|
|
nsresult /* NS_NewStreamLoaderNode */
|
|
NS_NewStreamLoader(nsIStreamLoader **outStream,
|
|
nsIURI *aUri,
|
|
nsIStreamLoaderObserver *aObserver,
|
|
nsINode *aLoadingNode,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
nsILoadGroup *aLoadGroup /* = nullptr */,
|
|
nsIInterfaceRequestor *aCallbacks /* = nullptr */,
|
|
nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
|
|
nsIURI *aReferrer /* = nullptr */)
|
|
{
|
|
NS_ASSERTION(aLoadingNode, "Can not create stream loader without a loading Node!");
|
|
return NS_NewStreamLoaderInternal(outStream,
|
|
aUri,
|
|
aObserver,
|
|
aLoadingNode,
|
|
aLoadingNode->NodePrincipal(),
|
|
aSecurityFlags,
|
|
aContentPolicyType,
|
|
aLoadGroup,
|
|
aCallbacks,
|
|
aLoadFlags,
|
|
aReferrer);
|
|
}
|
|
|
|
nsresult /* NS_NewStreamLoaderPrincipal */
|
|
NS_NewStreamLoader(nsIStreamLoader **outStream,
|
|
nsIURI *aUri,
|
|
nsIStreamLoaderObserver *aObserver,
|
|
nsIPrincipal *aLoadingPrincipal,
|
|
nsSecurityFlags aSecurityFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
nsILoadGroup *aLoadGroup /* = nullptr */,
|
|
nsIInterfaceRequestor *aCallbacks /* = nullptr */,
|
|
nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
|
|
nsIURI *aReferrer /* = nullptr */)
|
|
{
|
|
return NS_NewStreamLoaderInternal(outStream,
|
|
aUri,
|
|
aObserver,
|
|
nullptr, // aLoadingNode
|
|
aLoadingPrincipal,
|
|
aSecurityFlags,
|
|
aContentPolicyType,
|
|
aLoadGroup,
|
|
aCallbacks,
|
|
aLoadFlags,
|
|
aReferrer);
|
|
}
|
|
|
|
nsresult
|
|
NS_NewUnicharStreamLoader(nsIUnicharStreamLoader **result,
|
|
nsIUnicharStreamLoaderObserver *observer)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIUnicharStreamLoader> loader =
|
|
do_CreateInstance(NS_UNICHARSTREAMLOADER_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = loader->Init(observer);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
*result = nullptr;
|
|
loader.swap(*result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewSyncStreamListener(nsIStreamListener **result,
|
|
nsIInputStream **stream)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsISyncStreamListener> listener =
|
|
do_CreateInstance(NS_SYNCSTREAMLISTENER_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = listener->GetInputStream(stream);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
listener.forget(result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_ImplementChannelOpen(nsIChannel *channel,
|
|
nsIInputStream **result)
|
|
{
|
|
nsCOMPtr<nsIStreamListener> listener;
|
|
nsCOMPtr<nsIInputStream> stream;
|
|
nsresult rv = NS_NewSyncStreamListener(getter_AddRefs(listener),
|
|
getter_AddRefs(stream));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = channel->AsyncOpen(listener, nullptr);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
uint64_t n;
|
|
// block until the initial response is received or an error occurs.
|
|
rv = stream->Available(&n);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
*result = nullptr;
|
|
stream.swap(*result);
|
|
}
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewRequestObserverProxy(nsIRequestObserver **result,
|
|
nsIRequestObserver *observer,
|
|
nsISupports *context)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIRequestObserverProxy> proxy =
|
|
do_CreateInstance(NS_REQUESTOBSERVERPROXY_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = proxy->Init(observer, context);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
proxy.forget(result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewSimpleStreamListener(nsIStreamListener **result,
|
|
nsIOutputStream *sink,
|
|
nsIRequestObserver *observer /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsISimpleStreamListener> listener =
|
|
do_CreateInstance(NS_SIMPLESTREAMLISTENER_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = listener->Init(sink, observer);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
listener.forget(result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_CheckPortSafety(int32_t port,
|
|
const char *scheme,
|
|
nsIIOService *ioService /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIIOService> grip;
|
|
rv = net_EnsureIOService(&ioService, grip);
|
|
if (ioService) {
|
|
bool allow;
|
|
rv = ioService->AllowPort(port, scheme, &allow);
|
|
if (NS_SUCCEEDED(rv) && !allow) {
|
|
NS_WARNING("port blocked");
|
|
rv = NS_ERROR_PORT_ACCESS_NOT_ALLOWED;
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_CheckPortSafety(nsIURI *uri)
|
|
{
|
|
int32_t port;
|
|
nsresult rv = uri->GetPort(&port);
|
|
if (NS_FAILED(rv) || port == -1) // port undefined or default-valued
|
|
return NS_OK;
|
|
nsAutoCString scheme;
|
|
uri->GetScheme(scheme);
|
|
return NS_CheckPortSafety(port, scheme.get());
|
|
}
|
|
|
|
nsresult
|
|
NS_NewProxyInfo(const nsACString &type,
|
|
const nsACString &host,
|
|
int32_t port,
|
|
uint32_t flags,
|
|
nsIProxyInfo **result)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIProtocolProxyService> pps =
|
|
do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = pps->NewProxyInfo(type, host, port, flags, UINT32_MAX, nullptr,
|
|
result);
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_GetFileProtocolHandler(nsIFileProtocolHandler **result,
|
|
nsIIOService *ioService /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIIOService> grip;
|
|
rv = net_EnsureIOService(&ioService, grip);
|
|
if (ioService) {
|
|
nsCOMPtr<nsIProtocolHandler> handler;
|
|
rv = ioService->GetProtocolHandler("file", getter_AddRefs(handler));
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = CallQueryInterface(handler, result);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_GetFileFromURLSpec(const nsACString &inURL,
|
|
nsIFile **result,
|
|
nsIIOService *ioService /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIFileProtocolHandler> fileHandler;
|
|
rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService);
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = fileHandler->GetFileFromURLSpec(inURL, result);
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_GetURLSpecFromFile(nsIFile *file,
|
|
nsACString &url,
|
|
nsIIOService *ioService /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIFileProtocolHandler> fileHandler;
|
|
rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService);
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = fileHandler->GetURLSpecFromFile(file, url);
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_GetURLSpecFromActualFile(nsIFile *file,
|
|
nsACString &url,
|
|
nsIIOService *ioService /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIFileProtocolHandler> fileHandler;
|
|
rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService);
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = fileHandler->GetURLSpecFromActualFile(file, url);
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_GetURLSpecFromDir(nsIFile *file,
|
|
nsACString &url,
|
|
nsIIOService *ioService /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIFileProtocolHandler> fileHandler;
|
|
rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService);
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = fileHandler->GetURLSpecFromDir(file, url);
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_GetReferrerFromChannel(nsIChannel *channel,
|
|
nsIURI **referrer)
|
|
{
|
|
nsresult rv = NS_ERROR_NOT_AVAILABLE;
|
|
*referrer = nullptr;
|
|
|
|
nsCOMPtr<nsIPropertyBag2> props(do_QueryInterface(channel));
|
|
if (props) {
|
|
// We have to check for a property on a property bag because the
|
|
// referrer may be empty for security reasons (for example, when loading
|
|
// an http page with an https referrer).
|
|
rv = props->GetPropertyAsInterface(NS_LITERAL_STRING("docshell.internalReferrer"),
|
|
NS_GET_IID(nsIURI),
|
|
reinterpret_cast<void **>(referrer));
|
|
if (NS_FAILED(rv))
|
|
*referrer = nullptr;
|
|
}
|
|
|
|
// if that didn't work, we can still try to get the referrer from the
|
|
// nsIHttpChannel (if we can QI to it)
|
|
if (!(*referrer)) {
|
|
nsCOMPtr<nsIHttpChannel> chan(do_QueryInterface(channel));
|
|
if (chan) {
|
|
rv = chan->GetReferrer(referrer);
|
|
if (NS_FAILED(rv))
|
|
*referrer = nullptr;
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_ParseRequestContentType(const nsACString &rawContentType,
|
|
nsCString &contentType,
|
|
nsCString &contentCharset)
|
|
{
|
|
// contentCharset is left untouched if not present in rawContentType
|
|
nsresult rv;
|
|
nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
nsCString charset;
|
|
bool hadCharset;
|
|
rv = util->ParseRequestContentType(rawContentType, charset, &hadCharset,
|
|
contentType);
|
|
if (NS_SUCCEEDED(rv) && hadCharset)
|
|
contentCharset = charset;
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_ParseResponseContentType(const nsACString &rawContentType,
|
|
nsCString &contentType,
|
|
nsCString &contentCharset)
|
|
{
|
|
// contentCharset is left untouched if not present in rawContentType
|
|
nsresult rv;
|
|
nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
nsCString charset;
|
|
bool hadCharset;
|
|
rv = util->ParseResponseContentType(rawContentType, charset, &hadCharset,
|
|
contentType);
|
|
if (NS_SUCCEEDED(rv) && hadCharset)
|
|
contentCharset = charset;
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_ExtractCharsetFromContentType(const nsACString &rawContentType,
|
|
nsCString &contentCharset,
|
|
bool *hadCharset,
|
|
int32_t *charsetStart,
|
|
int32_t *charsetEnd)
|
|
{
|
|
// contentCharset is left untouched if not present in rawContentType
|
|
nsresult rv;
|
|
nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return util->ExtractCharsetFromContentType(rawContentType,
|
|
contentCharset,
|
|
charsetStart,
|
|
charsetEnd,
|
|
hadCharset);
|
|
}
|
|
|
|
nsresult
|
|
NS_NewPartialLocalFileInputStream(nsIInputStream **result,
|
|
nsIFile *file,
|
|
uint64_t offset,
|
|
uint64_t length,
|
|
int32_t ioFlags /* = -1 */,
|
|
int32_t perm /* = -1 */,
|
|
int32_t behaviorFlags /* = 0 */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIPartialFileInputStream> in =
|
|
do_CreateInstance(NS_PARTIALLOCALFILEINPUTSTREAM_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = in->Init(file, offset, length, ioFlags, perm, behaviorFlags);
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = CallQueryInterface(in, result);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewAtomicFileOutputStream(nsIOutputStream **result,
|
|
nsIFile *file,
|
|
int32_t ioFlags /* = -1 */,
|
|
int32_t perm /* = -1 */,
|
|
int32_t behaviorFlags /* = 0 */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIFileOutputStream> out =
|
|
do_CreateInstance(NS_ATOMICLOCALFILEOUTPUTSTREAM_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = out->Init(file, ioFlags, perm, behaviorFlags);
|
|
if (NS_SUCCEEDED(rv))
|
|
out.forget(result);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewSafeLocalFileOutputStream(nsIOutputStream **result,
|
|
nsIFile *file,
|
|
int32_t ioFlags /* = -1 */,
|
|
int32_t perm /* = -1 */,
|
|
int32_t behaviorFlags /* = 0 */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIFileOutputStream> out =
|
|
do_CreateInstance(NS_SAFELOCALFILEOUTPUTSTREAM_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = out->Init(file, ioFlags, perm, behaviorFlags);
|
|
if (NS_SUCCEEDED(rv))
|
|
out.forget(result);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewLocalFileStream(nsIFileStream **result,
|
|
nsIFile *file,
|
|
int32_t ioFlags /* = -1 */,
|
|
int32_t perm /* = -1 */,
|
|
int32_t behaviorFlags /* = 0 */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIFileStream> stream =
|
|
do_CreateInstance(NS_LOCALFILESTREAM_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = stream->Init(file, ioFlags, perm, behaviorFlags);
|
|
if (NS_SUCCEEDED(rv))
|
|
stream.forget(result);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_BackgroundInputStream(nsIInputStream **result,
|
|
nsIInputStream *stream,
|
|
uint32_t segmentSize /* = 0 */,
|
|
uint32_t segmentCount /* = 0 */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIStreamTransportService> sts =
|
|
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsCOMPtr<nsITransport> inTransport;
|
|
rv = sts->CreateInputTransport(stream, int64_t(-1), int64_t(-1),
|
|
true, getter_AddRefs(inTransport));
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = inTransport->OpenInputStream(nsITransport::OPEN_BLOCKING,
|
|
segmentSize, segmentCount,
|
|
result);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_BackgroundOutputStream(nsIOutputStream **result,
|
|
nsIOutputStream *stream,
|
|
uint32_t segmentSize /* = 0 */,
|
|
uint32_t segmentCount /* = 0 */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIStreamTransportService> sts =
|
|
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsCOMPtr<nsITransport> inTransport;
|
|
rv = sts->CreateOutputTransport(stream, int64_t(-1), int64_t(-1),
|
|
true, getter_AddRefs(inTransport));
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = inTransport->OpenOutputStream(nsITransport::OPEN_BLOCKING,
|
|
segmentSize, segmentCount,
|
|
result);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewBufferedOutputStream(nsIOutputStream **result,
|
|
nsIOutputStream *str,
|
|
uint32_t bufferSize)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIBufferedOutputStream> out =
|
|
do_CreateInstance(NS_BUFFEREDOUTPUTSTREAM_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = out->Init(str, bufferSize);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
out.forget(result);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
already_AddRefed<nsIOutputStream>
|
|
NS_BufferOutputStream(nsIOutputStream *aOutputStream,
|
|
uint32_t aBufferSize)
|
|
{
|
|
NS_ASSERTION(aOutputStream, "No output stream given!");
|
|
|
|
nsCOMPtr<nsIOutputStream> bos;
|
|
nsresult rv = NS_NewBufferedOutputStream(getter_AddRefs(bos), aOutputStream,
|
|
aBufferSize);
|
|
if (NS_SUCCEEDED(rv))
|
|
return bos.forget();
|
|
|
|
bos = aOutputStream;
|
|
return bos.forget();
|
|
}
|
|
|
|
already_AddRefed<nsIInputStream>
|
|
NS_BufferInputStream(nsIInputStream *aInputStream,
|
|
uint32_t aBufferSize)
|
|
{
|
|
NS_ASSERTION(aInputStream, "No input stream given!");
|
|
|
|
nsCOMPtr<nsIInputStream> bis;
|
|
nsresult rv = NS_NewBufferedInputStream(getter_AddRefs(bis), aInputStream,
|
|
aBufferSize);
|
|
if (NS_SUCCEEDED(rv))
|
|
return bis.forget();
|
|
|
|
bis = aInputStream;
|
|
return bis.forget();
|
|
}
|
|
|
|
nsresult
|
|
NS_ReadInputStreamToBuffer(nsIInputStream *aInputStream,
|
|
void **aDest,
|
|
uint32_t aCount)
|
|
{
|
|
nsresult rv;
|
|
|
|
if (!*aDest) {
|
|
*aDest = malloc(aCount);
|
|
if (!*aDest)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
char * p = reinterpret_cast<char*>(*aDest);
|
|
uint32_t bytesRead;
|
|
uint32_t totalRead = 0;
|
|
while (1) {
|
|
rv = aInputStream->Read(p + totalRead, aCount - totalRead, &bytesRead);
|
|
if (!NS_SUCCEEDED(rv))
|
|
return rv;
|
|
totalRead += bytesRead;
|
|
if (totalRead == aCount)
|
|
break;
|
|
// if Read reads 0 bytes, we've hit EOF
|
|
if (bytesRead == 0)
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
#ifdef MOZILLA_INTERNAL_API
|
|
|
|
nsresult
|
|
NS_ReadInputStreamToString(nsIInputStream *aInputStream,
|
|
nsACString &aDest,
|
|
uint32_t aCount)
|
|
{
|
|
if (!aDest.SetLength(aCount, mozilla::fallible))
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
void* dest = aDest.BeginWriting();
|
|
return NS_ReadInputStreamToBuffer(aInputStream, &dest, aCount);
|
|
}
|
|
|
|
#endif
|
|
|
|
nsresult
|
|
NS_LoadPersistentPropertiesFromURISpec(nsIPersistentProperties **outResult,
|
|
const nsACString &aSpec)
|
|
{
|
|
nsCOMPtr<nsIURI> uri;
|
|
nsresult rv = NS_NewURI(getter_AddRefs(uri), aSpec);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIChannel> channel;
|
|
rv = NS_NewChannel(getter_AddRefs(channel),
|
|
uri,
|
|
nsContentUtils::GetSystemPrincipal(),
|
|
nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
|
|
nsIContentPolicy::TYPE_OTHER);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
nsCOMPtr<nsIInputStream> in;
|
|
rv = channel->Open2(getter_AddRefs(in));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIPersistentProperties> properties =
|
|
do_CreateInstance(NS_PERSISTENTPROPERTIES_CONTRACTID, &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
rv = properties->Load(in);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
properties.swap(*outResult);
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
NS_UsePrivateBrowsing(nsIChannel *channel)
|
|
{
|
|
bool isPrivate = false;
|
|
nsCOMPtr<nsIPrivateBrowsingChannel> pbChannel = do_QueryInterface(channel);
|
|
if (pbChannel && NS_SUCCEEDED(pbChannel->GetIsChannelPrivate(&isPrivate))) {
|
|
return isPrivate;
|
|
}
|
|
|
|
// Some channels may not implement nsIPrivateBrowsingChannel
|
|
nsCOMPtr<nsILoadContext> loadContext;
|
|
NS_QueryNotificationCallbacks(channel, loadContext);
|
|
return loadContext && loadContext->UsePrivateBrowsing();
|
|
}
|
|
|
|
bool
|
|
NS_GetOriginAttributes(nsIChannel *aChannel,
|
|
mozilla::NeckoOriginAttributes &aAttributes)
|
|
{
|
|
nsCOMPtr<nsILoadContext> loadContext;
|
|
NS_QueryNotificationCallbacks(aChannel, loadContext);
|
|
if (!loadContext) {
|
|
return false;
|
|
}
|
|
|
|
DocShellOriginAttributes doa;
|
|
loadContext->GetOriginAttributes(doa);
|
|
aAttributes.InheritFromDocShellToNecko(doa);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
NS_GetAppInfo(nsIChannel *aChannel,
|
|
uint32_t *aAppID,
|
|
bool *aIsInBrowserElement)
|
|
{
|
|
nsCOMPtr<nsILoadContext> loadContext;
|
|
NS_QueryNotificationCallbacks(aChannel, loadContext);
|
|
if (!loadContext) {
|
|
return false;
|
|
}
|
|
|
|
nsresult rv = loadContext->GetAppId(aAppID);
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
|
|
rv = loadContext->GetIsInBrowserElement(aIsInBrowserElement);
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
NS_HasBeenCrossOrigin(nsIChannel* aChannel, bool aReport)
|
|
{
|
|
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
|
|
MOZ_RELEASE_ASSERT(loadInfo, "Origin tracking only works for channels created with a loadinfo");
|
|
|
|
// Always treat tainted channels as cross-origin.
|
|
if (loadInfo->GetTainting() != LoadTainting::Basic) {
|
|
return true;
|
|
}
|
|
|
|
nsCOMPtr<nsIPrincipal> loadingPrincipal = loadInfo->LoadingPrincipal();
|
|
uint32_t mode = loadInfo->GetSecurityMode();
|
|
bool dataInherits =
|
|
mode == nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS ||
|
|
mode == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS ||
|
|
mode == nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS;
|
|
|
|
bool aboutBlankInherits = dataInherits && loadInfo->GetAboutBlankInherits();
|
|
|
|
for (nsIPrincipal* principal : loadInfo->RedirectChain()) {
|
|
nsCOMPtr<nsIURI> uri;
|
|
principal->GetURI(getter_AddRefs(uri));
|
|
if (!uri) {
|
|
return true;
|
|
}
|
|
|
|
if (aboutBlankInherits && NS_IsAboutBlank(uri)) {
|
|
continue;
|
|
}
|
|
|
|
if (NS_FAILED(loadingPrincipal->CheckMayLoad(uri, aReport, dataInherits))) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
|
|
if (!uri) {
|
|
return true;
|
|
}
|
|
|
|
if (aboutBlankInherits && NS_IsAboutBlank(uri)) {
|
|
return false;
|
|
}
|
|
|
|
return NS_FAILED(loadingPrincipal->CheckMayLoad(uri, aReport, dataInherits));
|
|
}
|
|
|
|
nsresult
|
|
NS_GetAppInfoFromClearDataNotification(nsISupports *aSubject,
|
|
uint32_t *aAppID,
|
|
bool *aBrowserOnly)
|
|
{
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<mozIApplicationClearPrivateDataParams>
|
|
clearParams(do_QueryInterface(aSubject));
|
|
MOZ_ASSERT(clearParams);
|
|
if (!clearParams) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
uint32_t appId;
|
|
rv = clearParams->GetAppId(&appId);
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
|
MOZ_ASSERT(appId != NECKO_UNKNOWN_APP_ID);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
if (appId == NECKO_UNKNOWN_APP_ID) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
bool browserOnly = false;
|
|
rv = clearParams->GetBrowserOnly(&browserOnly);
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
*aAppID = appId;
|
|
*aBrowserOnly = browserOnly;
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
NS_ShouldCheckAppCache(nsIURI *aURI, bool usePrivateBrowsing)
|
|
{
|
|
if (usePrivateBrowsing) {
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsIOfflineCacheUpdateService> offlineService =
|
|
do_GetService("@mozilla.org/offlinecacheupdate-service;1");
|
|
if (!offlineService) {
|
|
return false;
|
|
}
|
|
|
|
bool allowed;
|
|
nsresult rv = offlineService->OfflineAppAllowedForURI(aURI,
|
|
nullptr,
|
|
&allowed);
|
|
return NS_SUCCEEDED(rv) && allowed;
|
|
}
|
|
|
|
bool
|
|
NS_ShouldCheckAppCache(nsIPrincipal *aPrincipal, bool usePrivateBrowsing)
|
|
{
|
|
if (usePrivateBrowsing) {
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsIOfflineCacheUpdateService> offlineService =
|
|
do_GetService("@mozilla.org/offlinecacheupdate-service;1");
|
|
if (!offlineService) {
|
|
return false;
|
|
}
|
|
|
|
bool allowed;
|
|
nsresult rv = offlineService->OfflineAppAllowed(aPrincipal,
|
|
nullptr,
|
|
&allowed);
|
|
return NS_SUCCEEDED(rv) && allowed;
|
|
}
|
|
|
|
void
|
|
NS_WrapAuthPrompt(nsIAuthPrompt *aAuthPrompt,
|
|
nsIAuthPrompt2 **aAuthPrompt2)
|
|
{
|
|
nsCOMPtr<nsIAuthPromptAdapterFactory> factory =
|
|
do_GetService(NS_AUTHPROMPT_ADAPTER_FACTORY_CONTRACTID);
|
|
if (!factory)
|
|
return;
|
|
|
|
NS_WARNING("Using deprecated nsIAuthPrompt");
|
|
factory->CreateAdapter(aAuthPrompt, aAuthPrompt2);
|
|
}
|
|
|
|
void
|
|
NS_QueryAuthPrompt2(nsIInterfaceRequestor *aCallbacks,
|
|
nsIAuthPrompt2 **aAuthPrompt)
|
|
{
|
|
CallGetInterface(aCallbacks, aAuthPrompt);
|
|
if (*aAuthPrompt)
|
|
return;
|
|
|
|
// Maybe only nsIAuthPrompt is provided and we have to wrap it.
|
|
nsCOMPtr<nsIAuthPrompt> prompt(do_GetInterface(aCallbacks));
|
|
if (!prompt)
|
|
return;
|
|
|
|
NS_WrapAuthPrompt(prompt, aAuthPrompt);
|
|
}
|
|
|
|
void
|
|
NS_QueryAuthPrompt2(nsIChannel *aChannel,
|
|
nsIAuthPrompt2 **aAuthPrompt)
|
|
{
|
|
*aAuthPrompt = nullptr;
|
|
|
|
// We want to use any auth prompt we can find on the channel's callbacks,
|
|
// and if that fails use the loadgroup's prompt (if any)
|
|
// Therefore, we can't just use NS_QueryNotificationCallbacks, because
|
|
// that would prefer a loadgroup's nsIAuthPrompt2 over a channel's
|
|
// nsIAuthPrompt.
|
|
nsCOMPtr<nsIInterfaceRequestor> callbacks;
|
|
aChannel->GetNotificationCallbacks(getter_AddRefs(callbacks));
|
|
if (callbacks) {
|
|
NS_QueryAuthPrompt2(callbacks, aAuthPrompt);
|
|
if (*aAuthPrompt)
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsILoadGroup> group;
|
|
aChannel->GetLoadGroup(getter_AddRefs(group));
|
|
if (!group)
|
|
return;
|
|
|
|
group->GetNotificationCallbacks(getter_AddRefs(callbacks));
|
|
if (!callbacks)
|
|
return;
|
|
NS_QueryAuthPrompt2(callbacks, aAuthPrompt);
|
|
}
|
|
|
|
nsresult
|
|
NS_NewNotificationCallbacksAggregation(nsIInterfaceRequestor *callbacks,
|
|
nsILoadGroup *loadGroup,
|
|
nsIEventTarget *target,
|
|
nsIInterfaceRequestor **result)
|
|
{
|
|
nsCOMPtr<nsIInterfaceRequestor> cbs;
|
|
if (loadGroup)
|
|
loadGroup->GetNotificationCallbacks(getter_AddRefs(cbs));
|
|
return NS_NewInterfaceRequestorAggregation(callbacks, cbs, target, result);
|
|
}
|
|
|
|
nsresult
|
|
NS_NewNotificationCallbacksAggregation(nsIInterfaceRequestor *callbacks,
|
|
nsILoadGroup *loadGroup,
|
|
nsIInterfaceRequestor **result)
|
|
{
|
|
return NS_NewNotificationCallbacksAggregation(callbacks, loadGroup, nullptr, result);
|
|
}
|
|
|
|
bool
|
|
NS_IsAppOffline(uint32_t appId)
|
|
{
|
|
bool appOffline = false;
|
|
nsCOMPtr<nsIIOService> io(
|
|
do_GetService("@mozilla.org/network/io-service;1"));
|
|
if (io) {
|
|
io->IsAppOffline(appId, &appOffline);
|
|
}
|
|
return appOffline;
|
|
}
|
|
|
|
bool
|
|
NS_IsAppOffline(nsIPrincipal *principal)
|
|
{
|
|
if (!principal) {
|
|
return NS_IsOffline();
|
|
}
|
|
uint32_t appId = nsIScriptSecurityManager::UNKNOWN_APP_ID;
|
|
principal->GetAppId(&appId);
|
|
|
|
return NS_IsAppOffline(appId);
|
|
}
|
|
|
|
nsresult
|
|
NS_DoImplGetInnermostURI(nsINestedURI *nestedURI, nsIURI **result)
|
|
{
|
|
NS_PRECONDITION(nestedURI, "Must have a nested URI!");
|
|
NS_PRECONDITION(!*result, "Must have null *result");
|
|
|
|
nsCOMPtr<nsIURI> inner;
|
|
nsresult rv = nestedURI->GetInnerURI(getter_AddRefs(inner));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// We may need to loop here until we reach the innermost
|
|
// URI.
|
|
nsCOMPtr<nsINestedURI> nestedInner(do_QueryInterface(inner));
|
|
while (nestedInner) {
|
|
rv = nestedInner->GetInnerURI(getter_AddRefs(inner));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
nestedInner = do_QueryInterface(inner);
|
|
}
|
|
|
|
// Found the innermost one if we reach here.
|
|
inner.swap(*result);
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
NS_ImplGetInnermostURI(nsINestedURI *nestedURI, nsIURI **result)
|
|
{
|
|
// Make it safe to use swap()
|
|
*result = nullptr;
|
|
|
|
return NS_DoImplGetInnermostURI(nestedURI, result);
|
|
}
|
|
|
|
nsresult
|
|
NS_EnsureSafeToReturn(nsIURI *uri, nsIURI **result)
|
|
{
|
|
NS_PRECONDITION(uri, "Must have a URI");
|
|
|
|
// Assume mutable until told otherwise
|
|
bool isMutable = true;
|
|
nsCOMPtr<nsIMutable> mutableObj(do_QueryInterface(uri));
|
|
if (mutableObj) {
|
|
nsresult rv = mutableObj->GetMutable(&isMutable);
|
|
isMutable = NS_FAILED(rv) || isMutable;
|
|
}
|
|
|
|
if (!isMutable) {
|
|
NS_ADDREF(*result = uri);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult rv = uri->Clone(result);
|
|
if (NS_SUCCEEDED(rv) && !*result) {
|
|
NS_ERROR("nsIURI.clone contract was violated");
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
NS_TryToSetImmutable(nsIURI *uri)
|
|
{
|
|
nsCOMPtr<nsIMutable> mutableObj(do_QueryInterface(uri));
|
|
if (mutableObj) {
|
|
mutableObj->SetMutable(false);
|
|
}
|
|
}
|
|
|
|
already_AddRefed<nsIURI>
|
|
NS_TryToMakeImmutable(nsIURI *uri,
|
|
nsresult *outRv /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv);
|
|
|
|
nsCOMPtr<nsIURI> result;
|
|
if (NS_SUCCEEDED(rv)) {
|
|
NS_ASSERTION(util, "do_GetNetUtil lied");
|
|
rv = util->ToImmutableURI(uri, getter_AddRefs(result));
|
|
}
|
|
|
|
if (NS_FAILED(rv)) {
|
|
result = uri;
|
|
}
|
|
|
|
if (outRv) {
|
|
*outRv = rv;
|
|
}
|
|
|
|
return result.forget();
|
|
}
|
|
|
|
already_AddRefed<nsIURI>
|
|
NS_GetInnermostURI(nsIURI *aURI)
|
|
{
|
|
NS_PRECONDITION(aURI, "Must have URI");
|
|
|
|
nsCOMPtr<nsIURI> uri = aURI;
|
|
|
|
nsCOMPtr<nsINestedURI> nestedURI(do_QueryInterface(uri));
|
|
if (!nestedURI) {
|
|
return uri.forget();
|
|
}
|
|
|
|
nsresult rv = nestedURI->GetInnermostURI(getter_AddRefs(uri));
|
|
if (NS_FAILED(rv)) {
|
|
return nullptr;
|
|
}
|
|
|
|
return uri.forget();
|
|
}
|
|
|
|
nsresult
|
|
NS_GetFinalChannelURI(nsIChannel *channel, nsIURI **uri)
|
|
{
|
|
*uri = nullptr;
|
|
nsLoadFlags loadFlags = 0;
|
|
nsresult rv = channel->GetLoadFlags(&loadFlags);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (loadFlags & nsIChannel::LOAD_REPLACE) {
|
|
return channel->GetURI(uri);
|
|
}
|
|
|
|
return channel->GetOriginalURI(uri);
|
|
}
|
|
|
|
uint32_t
|
|
NS_SecurityHashURI(nsIURI *aURI)
|
|
{
|
|
nsCOMPtr<nsIURI> baseURI = NS_GetInnermostURI(aURI);
|
|
|
|
nsAutoCString scheme;
|
|
uint32_t schemeHash = 0;
|
|
if (NS_SUCCEEDED(baseURI->GetScheme(scheme)))
|
|
schemeHash = mozilla::HashString(scheme);
|
|
|
|
// TODO figure out how to hash file:// URIs
|
|
if (scheme.EqualsLiteral("file"))
|
|
return schemeHash; // sad face
|
|
|
|
bool hasFlag;
|
|
if (NS_FAILED(NS_URIChainHasFlags(baseURI,
|
|
nsIProtocolHandler::ORIGIN_IS_FULL_SPEC, &hasFlag)) ||
|
|
hasFlag)
|
|
{
|
|
nsAutoCString spec;
|
|
uint32_t specHash;
|
|
nsresult res = baseURI->GetSpec(spec);
|
|
if (NS_SUCCEEDED(res))
|
|
specHash = mozilla::HashString(spec);
|
|
else
|
|
specHash = static_cast<uint32_t>(res);
|
|
return specHash;
|
|
}
|
|
|
|
nsAutoCString host;
|
|
uint32_t hostHash = 0;
|
|
if (NS_SUCCEEDED(baseURI->GetAsciiHost(host)))
|
|
hostHash = mozilla::HashString(host);
|
|
|
|
return mozilla::AddToHash(schemeHash, hostHash, NS_GetRealPort(baseURI));
|
|
}
|
|
|
|
bool
|
|
NS_SecurityCompareURIs(nsIURI *aSourceURI,
|
|
nsIURI *aTargetURI,
|
|
bool aStrictFileOriginPolicy)
|
|
{
|
|
// Note that this is not an Equals() test on purpose -- for URIs that don't
|
|
// support host/port, we want equality to basically be object identity, for
|
|
// security purposes. Otherwise, for example, two javascript: URIs that
|
|
// are otherwise unrelated could end up "same origin", which would be
|
|
// unfortunate.
|
|
if (aSourceURI && aSourceURI == aTargetURI)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (!aTargetURI || !aSourceURI)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// If either URI is a nested URI, get the base URI
|
|
nsCOMPtr<nsIURI> sourceBaseURI = NS_GetInnermostURI(aSourceURI);
|
|
nsCOMPtr<nsIURI> targetBaseURI = NS_GetInnermostURI(aTargetURI);
|
|
|
|
// If either uri is an nsIURIWithPrincipal
|
|
nsCOMPtr<nsIURIWithPrincipal> uriPrinc = do_QueryInterface(sourceBaseURI);
|
|
if (uriPrinc) {
|
|
uriPrinc->GetPrincipalUri(getter_AddRefs(sourceBaseURI));
|
|
}
|
|
|
|
uriPrinc = do_QueryInterface(targetBaseURI);
|
|
if (uriPrinc) {
|
|
uriPrinc->GetPrincipalUri(getter_AddRefs(targetBaseURI));
|
|
}
|
|
|
|
if (!sourceBaseURI || !targetBaseURI)
|
|
return false;
|
|
|
|
// Compare schemes
|
|
nsAutoCString targetScheme;
|
|
bool sameScheme = false;
|
|
if (NS_FAILED( targetBaseURI->GetScheme(targetScheme) ) ||
|
|
NS_FAILED( sourceBaseURI->SchemeIs(targetScheme.get(), &sameScheme) ) ||
|
|
!sameScheme)
|
|
{
|
|
// Not same-origin if schemes differ
|
|
return false;
|
|
}
|
|
|
|
// For file scheme, reject unless the files are identical. See
|
|
// NS_RelaxStrictFileOriginPolicy for enforcing file same-origin checking
|
|
if (targetScheme.EqualsLiteral("file"))
|
|
{
|
|
// in traditional unsafe behavior all files are the same origin
|
|
if (!aStrictFileOriginPolicy)
|
|
return true;
|
|
|
|
nsCOMPtr<nsIFileURL> sourceFileURL(do_QueryInterface(sourceBaseURI));
|
|
nsCOMPtr<nsIFileURL> targetFileURL(do_QueryInterface(targetBaseURI));
|
|
|
|
if (!sourceFileURL || !targetFileURL)
|
|
return false;
|
|
|
|
nsCOMPtr<nsIFile> sourceFile, targetFile;
|
|
|
|
sourceFileURL->GetFile(getter_AddRefs(sourceFile));
|
|
targetFileURL->GetFile(getter_AddRefs(targetFile));
|
|
|
|
if (!sourceFile || !targetFile)
|
|
return false;
|
|
|
|
// Otherwise they had better match
|
|
bool filesAreEqual = false;
|
|
nsresult rv = sourceFile->Equals(targetFile, &filesAreEqual);
|
|
return NS_SUCCEEDED(rv) && filesAreEqual;
|
|
}
|
|
|
|
bool hasFlag;
|
|
if (NS_FAILED(NS_URIChainHasFlags(targetBaseURI,
|
|
nsIProtocolHandler::ORIGIN_IS_FULL_SPEC, &hasFlag)) ||
|
|
hasFlag)
|
|
{
|
|
// URIs with this flag have the whole spec as a distinct trust
|
|
// domain; use the whole spec for comparison
|
|
nsAutoCString targetSpec;
|
|
nsAutoCString sourceSpec;
|
|
return ( NS_SUCCEEDED( targetBaseURI->GetSpec(targetSpec) ) &&
|
|
NS_SUCCEEDED( sourceBaseURI->GetSpec(sourceSpec) ) &&
|
|
targetSpec.Equals(sourceSpec) );
|
|
}
|
|
|
|
// Compare hosts
|
|
nsAutoCString targetHost;
|
|
nsAutoCString sourceHost;
|
|
if (NS_FAILED( targetBaseURI->GetAsciiHost(targetHost) ) ||
|
|
NS_FAILED( sourceBaseURI->GetAsciiHost(sourceHost) ))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsIStandardURL> targetURL(do_QueryInterface(targetBaseURI));
|
|
nsCOMPtr<nsIStandardURL> sourceURL(do_QueryInterface(sourceBaseURI));
|
|
if (!targetURL || !sourceURL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
#ifdef MOZILLA_INTERNAL_API
|
|
if (!targetHost.Equals(sourceHost, nsCaseInsensitiveCStringComparator() ))
|
|
#else
|
|
if (!targetHost.Equals(sourceHost, CaseInsensitiveCompare))
|
|
#endif
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return NS_GetRealPort(targetBaseURI) == NS_GetRealPort(sourceBaseURI);
|
|
}
|
|
|
|
bool
|
|
NS_URIIsLocalFile(nsIURI *aURI)
|
|
{
|
|
nsCOMPtr<nsINetUtil> util = do_GetNetUtil();
|
|
|
|
bool isFile;
|
|
return util && NS_SUCCEEDED(util->ProtocolHasFlags(aURI,
|
|
nsIProtocolHandler::URI_IS_LOCAL_FILE,
|
|
&isFile)) &&
|
|
isFile;
|
|
}
|
|
|
|
bool
|
|
NS_RelaxStrictFileOriginPolicy(nsIURI *aTargetURI,
|
|
nsIURI *aSourceURI,
|
|
bool aAllowDirectoryTarget /* = false */)
|
|
{
|
|
if (!NS_URIIsLocalFile(aTargetURI)) {
|
|
// This is probably not what the caller intended
|
|
NS_NOTREACHED("NS_RelaxStrictFileOriginPolicy called with non-file URI");
|
|
return false;
|
|
}
|
|
|
|
if (!NS_URIIsLocalFile(aSourceURI)) {
|
|
// If the source is not also a file: uri then forget it
|
|
// (don't want resource: principals in a file: doc)
|
|
//
|
|
// note: we're not de-nesting jar: uris here, we want to
|
|
// keep archive content bottled up in its own little island
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// pull out the internal files
|
|
//
|
|
nsCOMPtr<nsIFileURL> targetFileURL(do_QueryInterface(aTargetURI));
|
|
nsCOMPtr<nsIFileURL> sourceFileURL(do_QueryInterface(aSourceURI));
|
|
nsCOMPtr<nsIFile> targetFile;
|
|
nsCOMPtr<nsIFile> sourceFile;
|
|
bool targetIsDir;
|
|
|
|
// Make sure targetFile is not a directory (bug 209234)
|
|
// and that it exists w/out unescaping (bug 395343)
|
|
if (!sourceFileURL || !targetFileURL ||
|
|
NS_FAILED(targetFileURL->GetFile(getter_AddRefs(targetFile))) ||
|
|
NS_FAILED(sourceFileURL->GetFile(getter_AddRefs(sourceFile))) ||
|
|
!targetFile || !sourceFile ||
|
|
NS_FAILED(targetFile->Normalize()) ||
|
|
#ifndef MOZ_WIDGET_ANDROID
|
|
NS_FAILED(sourceFile->Normalize()) ||
|
|
#endif
|
|
(!aAllowDirectoryTarget &&
|
|
(NS_FAILED(targetFile->IsDirectory(&targetIsDir)) || targetIsDir))) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// If the file to be loaded is in a subdirectory of the source
|
|
// (or same-dir if source is not a directory) then it will
|
|
// inherit its source principal and be scriptable by that source.
|
|
//
|
|
bool sourceIsDir;
|
|
bool allowed = false;
|
|
nsresult rv = sourceFile->IsDirectory(&sourceIsDir);
|
|
if (NS_SUCCEEDED(rv) && sourceIsDir) {
|
|
rv = sourceFile->Contains(targetFile, &allowed);
|
|
} else {
|
|
nsCOMPtr<nsIFile> sourceParent;
|
|
rv = sourceFile->GetParent(getter_AddRefs(sourceParent));
|
|
if (NS_SUCCEEDED(rv) && sourceParent) {
|
|
rv = sourceParent->Equals(targetFile, &allowed);
|
|
if (NS_FAILED(rv) || !allowed) {
|
|
rv = sourceParent->Contains(targetFile, &allowed);
|
|
} else {
|
|
MOZ_ASSERT(aAllowDirectoryTarget,
|
|
"sourceFile->Parent == targetFile, but targetFile "
|
|
"should've been disallowed if it is a directory");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (NS_SUCCEEDED(rv) && allowed) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
NS_IsInternalSameURIRedirect(nsIChannel *aOldChannel,
|
|
nsIChannel *aNewChannel,
|
|
uint32_t aFlags)
|
|
{
|
|
if (!(aFlags & nsIChannelEventSink::REDIRECT_INTERNAL)) {
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> oldURI, newURI;
|
|
aOldChannel->GetURI(getter_AddRefs(oldURI));
|
|
aNewChannel->GetURI(getter_AddRefs(newURI));
|
|
|
|
if (!oldURI || !newURI) {
|
|
return false;
|
|
}
|
|
|
|
bool res;
|
|
return NS_SUCCEEDED(oldURI->Equals(newURI, &res)) && res;
|
|
}
|
|
|
|
bool
|
|
NS_IsHSTSUpgradeRedirect(nsIChannel *aOldChannel,
|
|
nsIChannel *aNewChannel,
|
|
uint32_t aFlags)
|
|
{
|
|
if (!(aFlags & nsIChannelEventSink::REDIRECT_STS_UPGRADE)) {
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> oldURI, newURI;
|
|
aOldChannel->GetURI(getter_AddRefs(oldURI));
|
|
aNewChannel->GetURI(getter_AddRefs(newURI));
|
|
|
|
if (!oldURI || !newURI) {
|
|
return false;
|
|
}
|
|
|
|
bool isHttp;
|
|
if (NS_FAILED(oldURI->SchemeIs("http", &isHttp)) || !isHttp) {
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> upgradedURI;
|
|
nsresult rv =
|
|
HttpBaseChannel::GetSecureUpgradedURI(oldURI, getter_AddRefs(upgradedURI));
|
|
if (NS_FAILED(rv)) {
|
|
return false;
|
|
}
|
|
|
|
bool res;
|
|
return NS_SUCCEEDED(upgradedURI->Equals(newURI, &res)) && res;
|
|
}
|
|
|
|
nsresult
|
|
NS_LinkRedirectChannels(uint32_t channelId,
|
|
nsIParentChannel *parentChannel,
|
|
nsIChannel **_result)
|
|
{
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIRedirectChannelRegistrar> registrar =
|
|
do_GetService("@mozilla.org/redirectchannelregistrar;1", &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return registrar->LinkChannels(channelId,
|
|
parentChannel,
|
|
_result);
|
|
}
|
|
|
|
#define NS_FAKE_SCHEME "http://"
|
|
#define NS_FAKE_TLD ".invalid"
|
|
nsresult NS_MakeRandomInvalidURLString(nsCString &result)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIUUIDGenerator> uuidgen =
|
|
do_GetService("@mozilla.org/uuid-generator;1", &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsID idee;
|
|
rv = uuidgen->GenerateUUIDInPlace(&idee);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
char chars[NSID_LENGTH];
|
|
idee.ToProvidedString(chars);
|
|
|
|
result.AssignLiteral(NS_FAKE_SCHEME);
|
|
// Strip off the '{' and '}' at the beginning and end of the UUID
|
|
result.Append(chars + 1, NSID_LENGTH - 3);
|
|
result.AppendLiteral(NS_FAKE_TLD);
|
|
|
|
return NS_OK;
|
|
}
|
|
#undef NS_FAKE_SCHEME
|
|
#undef NS_FAKE_TLD
|
|
|
|
nsresult
|
|
NS_CheckIsJavaCompatibleURLString(nsCString &urlString, bool *result)
|
|
{
|
|
*result = false; // Default to "no"
|
|
|
|
nsresult rv = NS_OK;
|
|
nsCOMPtr<nsIURLParser> urlParser =
|
|
do_GetService(NS_STDURLPARSER_CONTRACTID, &rv);
|
|
if (NS_FAILED(rv) || !urlParser)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
bool compatible = true;
|
|
uint32_t schemePos = 0;
|
|
int32_t schemeLen = 0;
|
|
urlParser->ParseURL(urlString.get(), -1, &schemePos, &schemeLen,
|
|
nullptr, nullptr, nullptr, nullptr);
|
|
if (schemeLen != -1) {
|
|
nsCString scheme;
|
|
scheme.Assign(urlString.get() + schemePos, schemeLen);
|
|
// By default Java only understands a small number of URL schemes, and of
|
|
// these only some can legitimately represent a browser page's "origin"
|
|
// (and be something we can legitimately expect Java to handle ... or not
|
|
// to mishandle).
|
|
//
|
|
// Besides those listed below, the OJI plugin understands the "jar",
|
|
// "mailto", "netdoc", "javascript" and "rmi" schemes, and Java Plugin2
|
|
// also understands the "about" scheme. We actually pass "about" URLs
|
|
// to Java ("about:blank" when processing a javascript: URL (one that
|
|
// calls Java) from the location bar of a blank page, and (in FF4 and up)
|
|
// "about:home" when processing a javascript: URL from the home page).
|
|
// And Java doesn't appear to mishandle them (for example it doesn't allow
|
|
// connections to "about" URLs). But it doesn't make any sense to do
|
|
// same-origin checks on "about" URLs, so we don't include them in our
|
|
// scheme whitelist.
|
|
//
|
|
// The OJI plugin doesn't understand "chrome" URLs (only Java Plugin2
|
|
// does) -- so we mustn't pass them to the OJI plugin. But we do need to
|
|
// pass "chrome" URLs to Java Plugin2: Java Plugin2 grants additional
|
|
// privileges to chrome "origins", and some extensions take advantage of
|
|
// this. For more information see bug 620773.
|
|
//
|
|
// As of FF4, we no longer support the OJI plugin.
|
|
if (PL_strcasecmp(scheme.get(), "http") &&
|
|
PL_strcasecmp(scheme.get(), "https") &&
|
|
PL_strcasecmp(scheme.get(), "file") &&
|
|
PL_strcasecmp(scheme.get(), "ftp") &&
|
|
PL_strcasecmp(scheme.get(), "gopher") &&
|
|
PL_strcasecmp(scheme.get(), "chrome"))
|
|
compatible = false;
|
|
} else {
|
|
compatible = false;
|
|
}
|
|
|
|
*result = compatible;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/** Given the first (disposition) token from a Content-Disposition header,
|
|
* tell whether it indicates the content is inline or attachment
|
|
* @param aDispToken the disposition token from the content-disposition header
|
|
*/
|
|
uint32_t
|
|
NS_GetContentDispositionFromToken(const nsAString &aDispToken)
|
|
{
|
|
// RFC 2183, section 2.8 says that an unknown disposition
|
|
// value should be treated as "attachment"
|
|
// If all of these tests eval to false, then we have a content-disposition of
|
|
// "attachment" or unknown
|
|
if (aDispToken.IsEmpty() ||
|
|
aDispToken.LowerCaseEqualsLiteral("inline") ||
|
|
// Broken sites just send
|
|
// Content-Disposition: filename="file"
|
|
// without a disposition token... screen those out.
|
|
StringHead(aDispToken, 8).LowerCaseEqualsLiteral("filename"))
|
|
return nsIChannel::DISPOSITION_INLINE;
|
|
|
|
return nsIChannel::DISPOSITION_ATTACHMENT;
|
|
}
|
|
|
|
uint32_t
|
|
NS_GetContentDispositionFromHeader(const nsACString &aHeader,
|
|
nsIChannel *aChan /* = nullptr */)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIMIMEHeaderParam> mimehdrpar = do_GetService(NS_MIMEHEADERPARAM_CONTRACTID, &rv);
|
|
if (NS_FAILED(rv))
|
|
return nsIChannel::DISPOSITION_ATTACHMENT;
|
|
|
|
nsAutoCString fallbackCharset;
|
|
if (aChan) {
|
|
nsCOMPtr<nsIURI> uri;
|
|
aChan->GetURI(getter_AddRefs(uri));
|
|
if (uri)
|
|
uri->GetOriginCharset(fallbackCharset);
|
|
}
|
|
|
|
nsAutoString dispToken;
|
|
rv = mimehdrpar->GetParameterHTTP(aHeader, "", fallbackCharset, true, nullptr,
|
|
dispToken);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
// special case (see bug 272541): empty disposition type handled as "inline"
|
|
if (rv == NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY)
|
|
return nsIChannel::DISPOSITION_INLINE;
|
|
return nsIChannel::DISPOSITION_ATTACHMENT;
|
|
}
|
|
|
|
return NS_GetContentDispositionFromToken(dispToken);
|
|
}
|
|
|
|
nsresult
|
|
NS_GetFilenameFromDisposition(nsAString &aFilename,
|
|
const nsACString &aDisposition,
|
|
nsIURI *aURI /* = nullptr */)
|
|
{
|
|
aFilename.Truncate();
|
|
|
|
nsresult rv;
|
|
nsCOMPtr<nsIMIMEHeaderParam> mimehdrpar =
|
|
do_GetService(NS_MIMEHEADERPARAM_CONTRACTID, &rv);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
nsCOMPtr<nsIURL> url = do_QueryInterface(aURI);
|
|
|
|
nsAutoCString fallbackCharset;
|
|
if (url)
|
|
url->GetOriginCharset(fallbackCharset);
|
|
// Get the value of 'filename' parameter
|
|
rv = mimehdrpar->GetParameterHTTP(aDisposition, "filename",
|
|
fallbackCharset, true, nullptr,
|
|
aFilename);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
aFilename.Truncate();
|
|
return rv;
|
|
}
|
|
|
|
if (aFilename.IsEmpty())
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void net_EnsurePSMInit()
|
|
{
|
|
nsCOMPtr<nsISocketProviderService> spserv =
|
|
do_GetService(NS_SOCKETPROVIDERSERVICE_CONTRACTID);
|
|
if (spserv) {
|
|
nsCOMPtr<nsISocketProvider> provider;
|
|
spserv->GetSocketProvider("ssl", getter_AddRefs(provider));
|
|
}
|
|
}
|
|
|
|
bool NS_IsAboutBlank(nsIURI *uri)
|
|
{
|
|
// GetSpec can be expensive for some URIs, so check the scheme first.
|
|
bool isAbout = false;
|
|
if (NS_FAILED(uri->SchemeIs("about", &isAbout)) || !isAbout) {
|
|
return false;
|
|
}
|
|
|
|
nsAutoCString str;
|
|
uri->GetSpec(str);
|
|
return str.EqualsLiteral("about:blank");
|
|
}
|
|
|
|
nsresult
|
|
NS_GenerateHostPort(const nsCString& host, int32_t port,
|
|
nsACString &hostLine)
|
|
{
|
|
if (strchr(host.get(), ':')) {
|
|
// host is an IPv6 address literal and must be encapsulated in []'s
|
|
hostLine.Assign('[');
|
|
// scope id is not needed for Host header.
|
|
int scopeIdPos = host.FindChar('%');
|
|
if (scopeIdPos == -1)
|
|
hostLine.Append(host);
|
|
else if (scopeIdPos > 0)
|
|
hostLine.Append(Substring(host, 0, scopeIdPos));
|
|
else
|
|
return NS_ERROR_MALFORMED_URI;
|
|
hostLine.Append(']');
|
|
}
|
|
else
|
|
hostLine.Assign(host);
|
|
if (port != -1) {
|
|
hostLine.Append(':');
|
|
hostLine.AppendInt(port);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
NS_SniffContent(const char *aSnifferType, nsIRequest *aRequest,
|
|
const uint8_t *aData, uint32_t aLength,
|
|
nsACString &aSniffedType)
|
|
{
|
|
typedef nsCategoryCache<nsIContentSniffer> ContentSnifferCache;
|
|
extern ContentSnifferCache* gNetSniffers;
|
|
extern ContentSnifferCache* gDataSniffers;
|
|
ContentSnifferCache* cache = nullptr;
|
|
if (!strcmp(aSnifferType, NS_CONTENT_SNIFFER_CATEGORY)) {
|
|
if (!gNetSniffers) {
|
|
gNetSniffers = new ContentSnifferCache(NS_CONTENT_SNIFFER_CATEGORY);
|
|
}
|
|
cache = gNetSniffers;
|
|
} else if (!strcmp(aSnifferType, NS_DATA_SNIFFER_CATEGORY)) {
|
|
if (!gDataSniffers) {
|
|
gDataSniffers = new ContentSnifferCache(NS_DATA_SNIFFER_CATEGORY);
|
|
}
|
|
cache = gDataSniffers;
|
|
} else {
|
|
// Invalid content sniffer type was requested
|
|
MOZ_ASSERT(false);
|
|
return;
|
|
}
|
|
|
|
nsCOMArray<nsIContentSniffer> sniffers;
|
|
cache->GetEntries(sniffers);
|
|
for (int32_t i = 0; i < sniffers.Count(); ++i) {
|
|
nsresult rv = sniffers[i]->GetMIMETypeFromContent(aRequest, aData, aLength, aSniffedType);
|
|
if (NS_SUCCEEDED(rv) && !aSniffedType.IsEmpty()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
aSniffedType.Truncate();
|
|
}
|
|
|
|
bool
|
|
NS_IsSrcdocChannel(nsIChannel *aChannel)
|
|
{
|
|
bool isSrcdoc;
|
|
nsCOMPtr<nsIInputStreamChannel> isr = do_QueryInterface(aChannel);
|
|
if (isr) {
|
|
isr->GetIsSrcdocChannel(&isSrcdoc);
|
|
return isSrcdoc;
|
|
}
|
|
nsCOMPtr<nsIViewSourceChannel> vsc = do_QueryInterface(aChannel);
|
|
if (vsc) {
|
|
vsc->GetIsSrcdocChannel(&isSrcdoc);
|
|
return isSrcdoc;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
nsresult
|
|
NS_ShouldSecureUpgrade(nsIURI* aURI,
|
|
nsILoadInfo* aLoadInfo,
|
|
nsIPrincipal* aChannelResultPrincipal,
|
|
bool aPrivateBrowsing,
|
|
bool aAllowSTS,
|
|
bool& aShouldUpgrade)
|
|
{
|
|
// Even if we're in private browsing mode, we still enforce existing STS
|
|
// data (it is read-only).
|
|
// if the connection is not using SSL and either the exact host matches or
|
|
// a superdomain wants to force HTTPS, do it.
|
|
bool isHttps = false;
|
|
nsresult rv = aURI->SchemeIs("https", &isHttps);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!isHttps) {
|
|
// If any of the documents up the chain to the root doucment makes use of
|
|
// the CSP directive 'upgrade-insecure-requests', then it's time to fulfill
|
|
// the promise to CSP and mixed content blocking to upgrade the channel
|
|
// from http to https.
|
|
if (aLoadInfo) {
|
|
// Please note that cross origin top level navigations are not subject
|
|
// to upgrade-insecure-requests, see:
|
|
// http://www.w3.org/TR/upgrade-insecure-requests/#examples
|
|
bool crossOriginNavigation =
|
|
(aLoadInfo->GetExternalContentPolicyType() == nsIContentPolicy::TYPE_DOCUMENT) &&
|
|
(!aChannelResultPrincipal->Equals(aLoadInfo->LoadingPrincipal()));
|
|
|
|
if (aLoadInfo->GetUpgradeInsecureRequests() && !crossOriginNavigation) {
|
|
// let's log a message to the console that we are upgrading a request
|
|
nsAutoCString spec, scheme;
|
|
aURI->GetSpec(spec);
|
|
aURI->GetScheme(scheme);
|
|
// append the additional 's' for security to the scheme :-)
|
|
scheme.AppendASCII("s");
|
|
NS_ConvertUTF8toUTF16 reportSpec(spec);
|
|
NS_ConvertUTF8toUTF16 reportScheme(scheme);
|
|
|
|
const char16_t* params[] = { reportSpec.get(), reportScheme.get() };
|
|
uint32_t innerWindowId = aLoadInfo->GetInnerWindowID();
|
|
CSP_LogLocalizedStr(MOZ_UTF16("upgradeInsecureRequest"),
|
|
params, ArrayLength(params),
|
|
EmptyString(), // aSourceFile
|
|
EmptyString(), // aScriptSample
|
|
0, // aLineNumber
|
|
0, // aColumnNumber
|
|
nsIScriptError::warningFlag, "CSP",
|
|
innerWindowId);
|
|
|
|
Telemetry::Accumulate(Telemetry::HTTP_SCHEME_UPGRADE, 4);
|
|
aShouldUpgrade = true;
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
// enforce Strict-Transport-Security
|
|
nsISiteSecurityService* sss = gHttpHandler->GetSSService();
|
|
NS_ENSURE_TRUE(sss, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
bool isStsHost = false;
|
|
uint32_t flags = aPrivateBrowsing ? nsISocketProvider::NO_PERMANENT_STORAGE : 0;
|
|
rv = sss->IsSecureURI(nsISiteSecurityService::HEADER_HSTS, aURI, flags,
|
|
&isStsHost);
|
|
|
|
// if the SSS check fails, it's likely because this load is on a
|
|
// malformed URI or something else in the setup is wrong, so any error
|
|
// should be reported.
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (isStsHost) {
|
|
LOG(("nsHttpChannel::Connect() STS permissions found\n"));
|
|
if (aAllowSTS) {
|
|
Telemetry::Accumulate(Telemetry::HTTP_SCHEME_UPGRADE, 3);
|
|
aShouldUpgrade = true;
|
|
return NS_OK;
|
|
} else {
|
|
Telemetry::Accumulate(Telemetry::HTTP_SCHEME_UPGRADE, 2);
|
|
}
|
|
} else {
|
|
Telemetry::Accumulate(Telemetry::HTTP_SCHEME_UPGRADE, 1);
|
|
}
|
|
} else {
|
|
Telemetry::Accumulate(Telemetry::HTTP_SCHEME_UPGRADE, 0);
|
|
}
|
|
aShouldUpgrade = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
namespace mozilla {
|
|
namespace net {
|
|
|
|
bool
|
|
InScriptableRange(int64_t val)
|
|
{
|
|
return (val <= kJS_MAX_SAFE_INTEGER) && (val >= kJS_MIN_SAFE_INTEGER);
|
|
}
|
|
|
|
bool
|
|
InScriptableRange(uint64_t val)
|
|
{
|
|
return val <= kJS_MAX_SAFE_UINTEGER;
|
|
}
|
|
|
|
} // namespace net
|
|
} // namespace mozilla
|