forked from mirrors/gecko-dev
fa06a45b28
Before this change, the trusted URI schemes, based on a string whitelist, were: https, file, resource, app, moz-extension and wss. This change removes "app" from the list (since we don't implement it), and adds "about" to the list (because we control the delivery of that).
399 lines
11 KiB
C++
399 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set sw=2 ts=8 et tw=80 : */
|
|
/* 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/. */
|
|
|
|
#include "WebSocketLog.h"
|
|
#include "BaseWebSocketChannel.h"
|
|
#include "MainThreadUtils.h"
|
|
#include "nsILoadGroup.h"
|
|
#include "nsINode.h"
|
|
#include "nsIInterfaceRequestor.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "nsProxyRelease.h"
|
|
#include "nsStandardURL.h"
|
|
#include "LoadInfo.h"
|
|
#include "mozilla/dom/ContentChild.h"
|
|
#include "nsITransportProvider.h"
|
|
|
|
using mozilla::dom::ContentChild;
|
|
|
|
namespace mozilla {
|
|
namespace net {
|
|
|
|
LazyLogModule webSocketLog("nsWebSocket");
|
|
static uint64_t gNextWebSocketID = 0;
|
|
|
|
// We use only 53 bits for the WebSocket serial ID so that it can be converted
|
|
// to and from a JS value without loss of precision. The upper bits of the
|
|
// WebSocket serial ID hold the process ID. The lower bits identify the
|
|
// WebSocket.
|
|
static const uint64_t kWebSocketIDTotalBits = 53;
|
|
static const uint64_t kWebSocketIDProcessBits = 22;
|
|
static const uint64_t kWebSocketIDWebSocketBits = kWebSocketIDTotalBits - kWebSocketIDProcessBits;
|
|
|
|
BaseWebSocketChannel::BaseWebSocketChannel()
|
|
: mWasOpened(0)
|
|
, mClientSetPingInterval(0)
|
|
, mClientSetPingTimeout(0)
|
|
, mEncrypted(false)
|
|
, mPingForced(false)
|
|
, mIsServerSide(false)
|
|
, mPingInterval(0)
|
|
, mPingResponseTimeout(10000)
|
|
{
|
|
// Generation of a unique serial ID.
|
|
uint64_t processID = 0;
|
|
if (XRE_IsContentProcess()) {
|
|
ContentChild* cc = ContentChild::GetSingleton();
|
|
processID = cc->GetID();
|
|
}
|
|
|
|
uint64_t processBits = processID & ((uint64_t(1) << kWebSocketIDProcessBits) - 1);
|
|
|
|
// Make sure no actual webSocket ends up with mWebSocketID == 0 but less then
|
|
// what the kWebSocketIDProcessBits allows.
|
|
if (++gNextWebSocketID >= (uint64_t(1) << kWebSocketIDWebSocketBits)) {
|
|
gNextWebSocketID = 1;
|
|
}
|
|
|
|
uint64_t webSocketBits = gNextWebSocketID & ((uint64_t(1) << kWebSocketIDWebSocketBits) - 1);
|
|
mSerial = (processBits << kWebSocketIDWebSocketBits) | webSocketBits;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// BaseWebSocketChannel::nsIWebSocketChannel
|
|
//-----------------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetOriginalURI(nsIURI **aOriginalURI)
|
|
{
|
|
LOG(("BaseWebSocketChannel::GetOriginalURI() %p\n", this));
|
|
|
|
if (!mOriginalURI)
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
NS_ADDREF(*aOriginalURI = mOriginalURI);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetURI(nsIURI **aURI)
|
|
{
|
|
LOG(("BaseWebSocketChannel::GetURI() %p\n", this));
|
|
|
|
if (!mOriginalURI)
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
if (mURI)
|
|
NS_ADDREF(*aURI = mURI);
|
|
else
|
|
NS_ADDREF(*aURI = mOriginalURI);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::
|
|
GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks)
|
|
{
|
|
LOG(("BaseWebSocketChannel::GetNotificationCallbacks() %p\n", this));
|
|
NS_IF_ADDREF(*aNotificationCallbacks = mCallbacks);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::
|
|
SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks)
|
|
{
|
|
LOG(("BaseWebSocketChannel::SetNotificationCallbacks() %p\n", this));
|
|
mCallbacks = aNotificationCallbacks;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetLoadGroup(nsILoadGroup **aLoadGroup)
|
|
{
|
|
LOG(("BaseWebSocketChannel::GetLoadGroup() %p\n", this));
|
|
NS_IF_ADDREF(*aLoadGroup = mLoadGroup);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::SetLoadGroup(nsILoadGroup *aLoadGroup)
|
|
{
|
|
LOG(("BaseWebSocketChannel::SetLoadGroup() %p\n", this));
|
|
mLoadGroup = aLoadGroup;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::SetLoadInfo(nsILoadInfo* aLoadInfo)
|
|
{
|
|
mLoadInfo = aLoadInfo;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetLoadInfo(nsILoadInfo** aLoadInfo)
|
|
{
|
|
NS_IF_ADDREF(*aLoadInfo = mLoadInfo);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetExtensions(nsACString &aExtensions)
|
|
{
|
|
LOG(("BaseWebSocketChannel::GetExtensions() %p\n", this));
|
|
aExtensions = mNegotiatedExtensions;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetProtocol(nsACString &aProtocol)
|
|
{
|
|
LOG(("BaseWebSocketChannel::GetProtocol() %p\n", this));
|
|
aProtocol = mProtocol;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::SetProtocol(const nsACString &aProtocol)
|
|
{
|
|
LOG(("BaseWebSocketChannel::SetProtocol() %p\n", this));
|
|
mProtocol = aProtocol; /* the sub protocol */
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetPingInterval(uint32_t *aSeconds)
|
|
{
|
|
// stored in ms but should only have second resolution
|
|
MOZ_ASSERT(!(mPingInterval % 1000));
|
|
|
|
*aSeconds = mPingInterval / 1000;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::SetPingInterval(uint32_t aSeconds)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (mWasOpened) {
|
|
return NS_ERROR_IN_PROGRESS;
|
|
}
|
|
|
|
mPingInterval = aSeconds * 1000;
|
|
mClientSetPingInterval = 1;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetPingTimeout(uint32_t *aSeconds)
|
|
{
|
|
// stored in ms but should only have second resolution
|
|
MOZ_ASSERT(!(mPingResponseTimeout % 1000));
|
|
|
|
*aSeconds = mPingResponseTimeout / 1000;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::SetPingTimeout(uint32_t aSeconds)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (mWasOpened) {
|
|
return NS_ERROR_IN_PROGRESS;
|
|
}
|
|
|
|
mPingResponseTimeout = aSeconds * 1000;
|
|
mClientSetPingTimeout = 1;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::InitLoadInfo(nsINode* aLoadingNode,
|
|
nsIPrincipal* aLoadingPrincipal,
|
|
nsIPrincipal* aTriggeringPrincipal,
|
|
uint32_t aSecurityFlags,
|
|
uint32_t aContentPolicyType)
|
|
{
|
|
mLoadInfo = new LoadInfo(aLoadingPrincipal, aTriggeringPrincipal,
|
|
aLoadingNode, aSecurityFlags, aContentPolicyType);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetSerial(uint32_t* aSerial)
|
|
{
|
|
if (!aSerial) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
*aSerial = mSerial;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::SetSerial(uint32_t aSerial)
|
|
{
|
|
mSerial = aSerial;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::SetServerParameters(nsITransportProvider* aProvider,
|
|
const nsACString& aNegotiatedExtensions)
|
|
{
|
|
MOZ_ASSERT(aProvider);
|
|
mServerTransportProvider = aProvider;
|
|
mNegotiatedExtensions = aNegotiatedExtensions;
|
|
mIsServerSide = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// BaseWebSocketChannel::nsIProtocolHandler
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetScheme(nsACString &aScheme)
|
|
{
|
|
LOG(("BaseWebSocketChannel::GetScheme() %p\n", this));
|
|
|
|
if (mEncrypted)
|
|
aScheme.AssignLiteral("wss");
|
|
else
|
|
aScheme.AssignLiteral("ws");
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetDefaultPort(int32_t *aDefaultPort)
|
|
{
|
|
LOG(("BaseWebSocketChannel::GetDefaultPort() %p\n", this));
|
|
|
|
if (mEncrypted)
|
|
*aDefaultPort = kDefaultWSSPort;
|
|
else
|
|
*aDefaultPort = kDefaultWSPort;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetProtocolFlags(uint32_t *aProtocolFlags)
|
|
{
|
|
LOG(("BaseWebSocketChannel::GetProtocolFlags() %p\n", this));
|
|
|
|
*aProtocolFlags = URI_NORELATIVE | URI_NON_PERSISTABLE | ALLOWS_PROXY |
|
|
ALLOWS_PROXY_HTTP | URI_DOES_NOT_RETURN_DATA | URI_DANGEROUS_TO_LOAD;
|
|
if (mEncrypted) {
|
|
*aProtocolFlags |= URI_IS_POTENTIALLY_TRUSTWORTHY;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::NewURI(const nsACString & aSpec, const char *aOriginCharset,
|
|
nsIURI *aBaseURI, nsIURI **_retval)
|
|
{
|
|
LOG(("BaseWebSocketChannel::NewURI() %p\n", this));
|
|
|
|
int32_t port;
|
|
nsresult rv = GetDefaultPort(&port);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
nsCOMPtr<nsIURI> base(aBaseURI);
|
|
return NS_MutateURI(new nsStandardURL::Mutator())
|
|
.Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init,
|
|
nsIStandardURL::URLTYPE_AUTHORITY,
|
|
port, nsCString(aSpec), aOriginCharset,
|
|
base, nullptr))
|
|
.Finalize(_retval);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::NewChannel2(nsIURI* aURI,
|
|
nsILoadInfo* aLoadInfo,
|
|
nsIChannel** outChannel)
|
|
{
|
|
LOG(("BaseWebSocketChannel::NewChannel2() %p\n", this));
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::NewChannel(nsIURI *aURI, nsIChannel **_retval)
|
|
{
|
|
LOG(("BaseWebSocketChannel::NewChannel() %p\n", this));
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::AllowPort(int32_t port, const char *scheme,
|
|
bool *_retval)
|
|
{
|
|
LOG(("BaseWebSocketChannel::AllowPort() %p\n", this));
|
|
|
|
// do not override any blacklisted ports
|
|
*_retval = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// BaseWebSocketChannel::nsIThreadRetargetableRequest
|
|
//-----------------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::RetargetDeliveryTo(nsIEventTarget* aTargetThread)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(aTargetThread);
|
|
MOZ_ASSERT(!mTargetThread, "Delivery target should be set once, before AsyncOpen");
|
|
MOZ_ASSERT(!mWasOpened, "Should not be called after AsyncOpen!");
|
|
|
|
mTargetThread = do_QueryInterface(aTargetThread);
|
|
MOZ_ASSERT(mTargetThread);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
BaseWebSocketChannel::GetDeliveryTarget(nsIEventTarget** aTargetThread)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsCOMPtr<nsIEventTarget> target = mTargetThread;
|
|
if (!target) {
|
|
target = GetCurrentThreadEventTarget();
|
|
}
|
|
target.forget(aTargetThread);
|
|
return NS_OK;
|
|
}
|
|
|
|
BaseWebSocketChannel::ListenerAndContextContainer::ListenerAndContextContainer(
|
|
nsIWebSocketListener* aListener,
|
|
nsISupports* aContext)
|
|
: mListener(aListener)
|
|
, mContext(aContext)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(mListener);
|
|
}
|
|
|
|
BaseWebSocketChannel::ListenerAndContextContainer::~ListenerAndContextContainer()
|
|
{
|
|
MOZ_ASSERT(mListener);
|
|
|
|
NS_ReleaseOnMainThreadSystemGroup(
|
|
"BaseWebSocketChannel::ListenerAndContextContainer::mListener",
|
|
mListener.forget());
|
|
NS_ReleaseOnMainThreadSystemGroup(
|
|
"BaseWebSocketChannel::ListenerAndContextContainer::mContext",
|
|
mContext.forget());
|
|
}
|
|
|
|
} // namespace net
|
|
} // namespace mozilla
|