2010-06-17 11:34:24 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set sw=2 ts=8 et tw=80 : */
|
2012-05-21 04:12:37 -07:00
|
|
|
/* 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/. */
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-10-10 22:50:08 -07:00
|
|
|
#include "mozilla/Util.h"
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
#include "nsWebSocket.h"
|
2011-05-23 09:46:36 -07:00
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
#include "nsIScriptGlobalObject.h"
|
|
|
|
#include "nsIDOMWindow.h"
|
|
|
|
#include "nsIDocument.h"
|
|
|
|
#include "nsXPCOM.h"
|
|
|
|
#include "nsIXPConnect.h"
|
|
|
|
#include "nsContentUtils.h"
|
|
|
|
#include "nsEventDispatcher.h"
|
|
|
|
#include "nsDOMError.h"
|
|
|
|
#include "nsIScriptObjectPrincipal.h"
|
2011-10-03 12:11:31 -07:00
|
|
|
#include "nsDOMClassInfoID.h"
|
2010-06-17 11:34:24 -07:00
|
|
|
#include "jsapi.h"
|
|
|
|
#include "nsIURL.h"
|
|
|
|
#include "nsICharsetConverterManager.h"
|
|
|
|
#include "nsIUnicodeEncoder.h"
|
|
|
|
#include "nsThreadUtils.h"
|
|
|
|
#include "nsIDOMMessageEvent.h"
|
|
|
|
#include "nsIPromptFactory.h"
|
|
|
|
#include "nsIWindowWatcher.h"
|
|
|
|
#include "nsIPrompt.h"
|
|
|
|
#include "nsIStringBundle.h"
|
|
|
|
#include "nsIConsoleService.h"
|
|
|
|
#include "nsLayoutStatics.h"
|
2010-06-17 11:36:01 -07:00
|
|
|
#include "nsIDOMCloseEvent.h"
|
|
|
|
#include "nsICryptoHash.h"
|
2010-12-21 09:05:34 -08:00
|
|
|
#include "jsdbgapi.h"
|
|
|
|
#include "nsIJSContextStack.h"
|
|
|
|
#include "nsJSUtils.h"
|
|
|
|
#include "nsIScriptError.h"
|
2011-05-21 18:27:52 -07:00
|
|
|
#include "nsNetUtil.h"
|
|
|
|
#include "nsILoadGroup.h"
|
2011-05-24 23:31:59 -07:00
|
|
|
#include "mozilla/Preferences.h"
|
2011-08-03 09:42:02 -07:00
|
|
|
#include "nsDOMLists.h"
|
2011-09-29 09:06:36 -07:00
|
|
|
#include "xpcpublic.h"
|
2011-12-07 15:19:43 -08:00
|
|
|
#include "nsContentPolicyUtils.h"
|
|
|
|
#include "nsContentErrors.h"
|
2012-01-14 09:43:00 -08:00
|
|
|
#include "jsfriendapi.h"
|
2011-12-15 15:19:01 -08:00
|
|
|
#include "prmem.h"
|
|
|
|
#include "nsDOMFile.h"
|
2012-01-26 07:55:30 -08:00
|
|
|
#include "nsWrapperCacheInlines.h"
|
2012-02-07 18:53:33 -08:00
|
|
|
#include "nsDOMEventTargetHelper.h"
|
2012-02-21 14:57:10 -08:00
|
|
|
#include "nsIObserverService.h"
|
2012-07-20 09:58:28 -07:00
|
|
|
#include "GeneratedEvents.h"
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
using namespace mozilla;
|
|
|
|
|
|
|
|
#define UTF_8_REPLACEMENT_CHAR static_cast<PRUnichar>(0xFFFD)
|
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
#define TRUE_OR_FAIL_WEBSOCKET(x, ret) \
|
2010-06-17 11:34:24 -07:00
|
|
|
PR_BEGIN_MACRO \
|
|
|
|
if (NS_UNLIKELY(!(x))) { \
|
2012-02-21 14:57:10 -08:00
|
|
|
NS_WARNING("TRUE_OR_FAIL_WEBSOCKET(" #x ") failed"); \
|
2012-01-31 20:41:43 -08:00
|
|
|
FailConnection(nsIWebSocketChannel::CLOSE_INTERNAL_ERROR); \
|
|
|
|
return ret; \
|
2010-06-17 11:34:24 -07:00
|
|
|
} \
|
|
|
|
PR_END_MACRO
|
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
#define SUCCESS_OR_FAIL_WEBSOCKET(res, ret) \
|
2010-06-17 11:34:24 -07:00
|
|
|
PR_BEGIN_MACRO \
|
|
|
|
nsresult __rv = res; \
|
|
|
|
if (NS_FAILED(__rv)) { \
|
|
|
|
NS_ENSURE_SUCCESS_BODY(res, ret) \
|
2012-01-31 20:41:43 -08:00
|
|
|
FailConnection(nsIWebSocketChannel::CLOSE_INTERNAL_ERROR); \
|
2010-06-17 11:34:24 -07:00
|
|
|
return ret; \
|
|
|
|
} \
|
|
|
|
PR_END_MACRO
|
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
class CallDispatchConnectionCloseEvents: public nsRunnable
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
CallDispatchConnectionCloseEvents(nsWebSocket *aWebSocket)
|
|
|
|
: mWebSocket(aWebSocket)
|
|
|
|
{}
|
|
|
|
|
|
|
|
NS_IMETHOD Run()
|
|
|
|
{
|
|
|
|
mWebSocket->DispatchConnectionCloseEvents();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
nsRefPtr<nsWebSocket> mWebSocket;
|
|
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// nsWebSocket
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsresult
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::PrintErrorOnConsole(const char *aBundleURI,
|
|
|
|
const PRUnichar *aError,
|
|
|
|
const PRUnichar **aFormatStrings,
|
|
|
|
PRUint32 aFormatStringsLen)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:34:24 -07:00
|
|
|
nsresult rv;
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsCOMPtr<nsIStringBundleService> bundleService =
|
|
|
|
do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsCOMPtr<nsIStringBundle> strBundle;
|
|
|
|
rv = bundleService->CreateBundle(aBundleURI, getter_AddRefs(strBundle));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsCOMPtr<nsIConsoleService> console(
|
|
|
|
do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-12-21 13:51:29 -08:00
|
|
|
nsCOMPtr<nsIScriptError> errorObject(
|
2011-05-21 18:27:52 -07:00
|
|
|
do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
// Localize the error message
|
|
|
|
nsXPIDLString message;
|
|
|
|
if (aFormatStrings) {
|
|
|
|
rv = strBundle->FormatStringFromName(aError, aFormatStrings,
|
|
|
|
aFormatStringsLen,
|
|
|
|
getter_Copies(message));
|
2010-06-17 11:34:24 -07:00
|
|
|
} else {
|
2011-05-21 18:27:52 -07:00
|
|
|
rv = strBundle->GetStringFromName(aError, getter_Copies(message));
|
|
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-12-21 13:51:29 -08:00
|
|
|
rv = errorObject->InitWithWindowID(message.get(),
|
|
|
|
NS_ConvertUTF8toUTF16(mScriptFile).get(),
|
|
|
|
nsnull, mScriptLine, 0,
|
|
|
|
nsIScriptError::errorFlag, "Web Socket",
|
|
|
|
mInnerWindowID);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
// print the error message directly to the JS console
|
2011-12-21 13:51:29 -08:00
|
|
|
rv = console->LogMessage(errorObject);
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsresult
|
2012-01-31 20:41:43 -08:00
|
|
|
nsWebSocket::CloseConnection(PRUint16 aReasonCode,
|
|
|
|
const nsACString& aReasonString)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2012-06-04 16:38:32 -07:00
|
|
|
if (mReadyState == nsIWebSocket::CLOSING ||
|
|
|
|
mReadyState == nsIWebSocket::CLOSED) {
|
2011-06-08 05:27:11 -07:00
|
|
|
return NS_OK;
|
2012-06-04 16:38:32 -07:00
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
// The common case...
|
|
|
|
if (mChannel) {
|
|
|
|
mReadyState = nsIWebSocket::CLOSING;
|
|
|
|
return mChannel->Close(aReasonCode, aReasonString);
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
// No channel, but not disconnected: canceled or failed early
|
|
|
|
//
|
|
|
|
MOZ_ASSERT(mReadyState == nsIWebSocket::CONNECTING,
|
|
|
|
"Should only get here for early websocket cancel/error");
|
2011-05-21 18:27:52 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
// Server won't be sending us a close code, so use what's passed in here.
|
|
|
|
mCloseEventCode = aReasonCode;
|
|
|
|
CopyUTF8toUTF16(aReasonString, mCloseEventReason);
|
|
|
|
|
|
|
|
mReadyState = nsIWebSocket::CLOSING;
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
// Can be called from Cancel() or Init() codepaths, so need to dispatch
|
|
|
|
// onerror/onclose asynchronously
|
|
|
|
ScheduleConnectionCloseEvents(
|
|
|
|
nsnull,
|
|
|
|
(aReasonCode == nsIWebSocketChannel::CLOSE_NORMAL ||
|
|
|
|
aReasonCode == nsIWebSocketChannel::CLOSE_GOING_AWAY) ?
|
|
|
|
NS_OK : NS_ERROR_FAILURE,
|
|
|
|
false);
|
|
|
|
|
|
|
|
return NS_OK;
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsresult
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::ConsoleError()
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
|
|
|
nsresult rv;
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsCAutoString targetSpec;
|
2011-10-20 01:27:13 -07:00
|
|
|
rv = mURI->GetSpec(targetSpec);
|
2011-05-21 18:27:52 -07:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
NS_WARNING("Failed to get targetSpec");
|
|
|
|
} else {
|
|
|
|
NS_ConvertUTF8toUTF16 specUTF16(targetSpec);
|
|
|
|
const PRUnichar *formatStrings[] = { specUTF16.get() };
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
if (mReadyState < nsIWebSocket::OPEN) {
|
2011-05-21 18:27:52 -07:00
|
|
|
PrintErrorOnConsole("chrome://global/locale/appstrings.properties",
|
|
|
|
NS_LITERAL_STRING("connectionFailure").get(),
|
2011-10-10 22:50:08 -07:00
|
|
|
formatStrings, ArrayLength(formatStrings));
|
2011-05-21 18:27:52 -07:00
|
|
|
} else {
|
|
|
|
PrintErrorOnConsole("chrome://global/locale/appstrings.properties",
|
|
|
|
NS_LITERAL_STRING("netInterrupt").get(),
|
2011-10-10 22:50:08 -07:00
|
|
|
formatStrings, ArrayLength(formatStrings));
|
2011-05-21 18:27:52 -07:00
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
2011-08-02 16:55:17 -07:00
|
|
|
/// todo some specific errors - like for message too large
|
2011-05-21 18:27:52 -07:00
|
|
|
return rv;
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsresult
|
2012-01-31 20:41:43 -08:00
|
|
|
nsWebSocket::FailConnection(PRUint16 aReasonCode,
|
|
|
|
const nsACString& aReasonString)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
ConsoleError();
|
|
|
|
mFailed = true;
|
2012-02-21 14:57:10 -08:00
|
|
|
CloseConnection(aReasonCode, aReasonString);
|
2011-10-20 01:27:13 -07:00
|
|
|
|
|
|
|
return NS_OK;
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsresult
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::Disconnect()
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-10-20 01:27:13 -07:00
|
|
|
if (mDisconnected)
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
nsCOMPtr<nsILoadGroup> loadGroup;
|
|
|
|
GetLoadGroup(getter_AddRefs(loadGroup));
|
|
|
|
if (loadGroup)
|
|
|
|
loadGroup->RemoveRequest(this, nsnull, NS_OK);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-02-21 14:57:10 -08:00
|
|
|
nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
|
|
|
|
if (os) {
|
|
|
|
os->RemoveObserver(this, DOM_WINDOW_DESTROYED_TOPIC);
|
|
|
|
os->RemoveObserver(this, DOM_WINDOW_FROZEN_TOPIC);
|
|
|
|
}
|
|
|
|
|
2011-10-20 01:27:13 -07:00
|
|
|
// DontKeepAliveAnyMore() can release the object. So hold a reference to this
|
|
|
|
// until the end of the method.
|
|
|
|
nsRefPtr<nsWebSocket> kungfuDeathGrip = this;
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-10-20 01:27:13 -07:00
|
|
|
DontKeepAliveAnyMore();
|
2011-12-15 15:19:01 -08:00
|
|
|
mChannel = nsnull;
|
2011-10-20 01:27:13 -07:00
|
|
|
mDisconnected = true;
|
2011-06-08 05:27:11 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
return NS_OK;
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
2011-10-20 01:27:13 -07:00
|
|
|
// nsWebSocket::nsIWebSocketListener methods:
|
2010-06-17 11:34:24 -07:00
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
nsresult
|
|
|
|
nsWebSocket::DoOnMessageAvailable(const nsACString & aMsg, bool isBinary)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2012-06-04 16:38:32 -07:00
|
|
|
|
|
|
|
if (mReadyState == nsIWebSocket::CLOSED) {
|
|
|
|
NS_ERROR("Received message after CLOSED");
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
if (mReadyState == nsIWebSocket::OPEN) {
|
2011-12-20 00:20:12 -08:00
|
|
|
// Dispatch New Message
|
|
|
|
nsresult rv = CreateAndDispatchMessageEvent(aMsg, isBinary);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
NS_WARNING("Failed to dispatch the message event");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// CLOSING should be the only other state where it's possible to get msgs
|
|
|
|
// from channel: Spec says to drop them.
|
2012-06-04 16:38:32 -07:00
|
|
|
MOZ_ASSERT(mReadyState == nsIWebSocket::CLOSING,
|
|
|
|
"Received message while CONNECTING or CLOSED");
|
2010-06-17 11:36:01 -07:00
|
|
|
}
|
2011-12-15 15:19:01 -08:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2010-06-17 11:36:01 -07:00
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::OnMessageAvailable(nsISupports *aContext, const nsACString & aMsg)
|
|
|
|
{
|
|
|
|
return DoOnMessageAvailable(aMsg, false);
|
|
|
|
}
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::OnBinaryMessageAvailable(nsISupports *aContext,
|
|
|
|
const nsACString & aMsg)
|
2011-05-21 18:27:52 -07:00
|
|
|
{
|
2011-12-20 00:20:12 -08:00
|
|
|
return DoOnMessageAvailable(aMsg, true);
|
2011-05-21 18:27:52 -07:00
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::OnStart(nsISupports *aContext)
|
2011-05-21 18:27:52 -07:00
|
|
|
{
|
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2012-06-04 16:38:32 -07:00
|
|
|
|
|
|
|
// This is the only function that sets OPEN, and should be called only once
|
|
|
|
MOZ_ASSERT(mReadyState != nsIWebSocket::OPEN,
|
|
|
|
"readyState already OPEN! OnStart called twice?");
|
|
|
|
|
|
|
|
// Nothing to do if we've already closed/closing
|
|
|
|
if (mReadyState != nsIWebSocket::CONNECTING) {
|
2011-05-21 18:27:52 -07:00
|
|
|
return NS_OK;
|
2012-06-04 16:38:32 -07:00
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-02-21 14:57:10 -08:00
|
|
|
// Attempt to kill "ghost" websocket: but usually too early for check to fail
|
|
|
|
nsresult rv = CheckInnerWindowCorrectness();
|
|
|
|
if (NS_FAILED(rv)) {
|
2012-06-04 16:38:32 -07:00
|
|
|
CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
|
2012-02-21 14:57:10 -08:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
if (!mRequestedProtocolList.IsEmpty()) {
|
|
|
|
mChannel->GetProtocol(mEstablishedProtocol);
|
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
mChannel->GetExtensions(mEstablishedExtensions);
|
2011-12-15 15:23:00 -08:00
|
|
|
UpdateURI();
|
2011-08-03 20:46:13 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
mReadyState = nsIWebSocket::OPEN;
|
|
|
|
|
|
|
|
// Call 'onopen'
|
|
|
|
rv = CreateAndDispatchSimpleEvent(NS_LITERAL_STRING("open"));
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
NS_WARNING("Failed to dispatch the open event");
|
|
|
|
}
|
|
|
|
|
|
|
|
UpdateMustKeepAlive();
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::OnStop(nsISupports *aContext, nsresult aStatusCode)
|
2012-06-04 16:38:32 -07:00
|
|
|
{
|
|
|
|
// We can be CONNECTING here if connection failed.
|
|
|
|
// We can be OPEN if we have encountered a fatal protocol error
|
|
|
|
// We can be CLOSING if close() was called and/or server initiated close.
|
|
|
|
MOZ_ASSERT(mReadyState != nsIWebSocket::CLOSED,
|
|
|
|
"Shouldn't already be CLOSED when OnStop called");
|
|
|
|
|
|
|
|
// called by network stack, not JS, so can dispatch JS events synchronously
|
|
|
|
return ScheduleConnectionCloseEvents(aContext, aStatusCode, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsWebSocket::ScheduleConnectionCloseEvents(nsISupports *aContext,
|
|
|
|
nsresult aStatusCode,
|
|
|
|
bool sync)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
// no-op if some other code has already initiated close event
|
|
|
|
if (!mOnCloseScheduled) {
|
|
|
|
mCloseEventWasClean = NS_SUCCEEDED(aStatusCode);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
if (aStatusCode == NS_BASE_STREAM_CLOSED) {
|
|
|
|
// don't generate an error event just because of an unclean close
|
|
|
|
aStatusCode = NS_OK;
|
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
if (NS_FAILED(aStatusCode)) {
|
|
|
|
ConsoleError();
|
|
|
|
mFailed = true;
|
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
mOnCloseScheduled = true;
|
|
|
|
|
|
|
|
if (sync) {
|
|
|
|
DispatchConnectionCloseEvents();
|
|
|
|
} else {
|
|
|
|
NS_DispatchToMainThread(new CallDispatchConnectionCloseEvents(this),
|
|
|
|
NS_DISPATCH_NORMAL);
|
|
|
|
}
|
|
|
|
}
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::OnAcknowledge(nsISupports *aContext, PRUint32 aSize)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
if (aSize > mOutgoingBufferedAmount)
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
mOutgoingBufferedAmount -= aSize;
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::OnServerClose(nsISupports *aContext, PRUint16 aCode,
|
|
|
|
const nsACString &aReason)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
MOZ_ASSERT(mReadyState != nsIWebSocket::CONNECTING,
|
|
|
|
"Received server close before connected?");
|
|
|
|
MOZ_ASSERT(mReadyState != nsIWebSocket::CLOSED,
|
|
|
|
"Received server close after already closed!");
|
2012-02-21 14:57:13 -08:00
|
|
|
|
2012-01-31 20:41:43 -08:00
|
|
|
// store code/string for onclose DOM event
|
|
|
|
mCloseEventCode = aCode;
|
|
|
|
CopyUTF8toUTF16(aReason, mCloseEventReason);
|
|
|
|
|
2012-02-21 14:57:13 -08:00
|
|
|
if (mReadyState == nsIWebSocket::OPEN) {
|
2012-06-04 16:38:32 -07:00
|
|
|
// Server initiating close.
|
2012-05-16 17:09:42 -07:00
|
|
|
// RFC 6455, 5.5.1: "When sending a Close frame in response, the endpoint
|
|
|
|
// typically echos the status code it received".
|
|
|
|
// But never send certain codes, per section 7.4.1
|
|
|
|
if (aCode == 1005 || aCode == 1006 || aCode == 1015) {
|
|
|
|
CloseConnection(0, EmptyCString());
|
|
|
|
} else {
|
|
|
|
CloseConnection(aCode, aReason);
|
|
|
|
}
|
2012-02-21 14:57:13 -08:00
|
|
|
} else {
|
2012-06-04 16:38:32 -07:00
|
|
|
// We initiated close, and server has replied: OnStop does rest of the work.
|
|
|
|
MOZ_ASSERT(mReadyState == nsIWebSocket::CLOSING, "unknown state");
|
2012-02-21 14:57:13 -08:00
|
|
|
}
|
2012-01-31 20:41:43 -08:00
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
2011-10-20 01:27:13 -07:00
|
|
|
// nsWebSocket::nsIInterfaceRequestor
|
2010-06-17 11:34:24 -07:00
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::GetInterface(const nsIID &aIID, void **aResult)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
if (mReadyState == nsIWebSocket::CLOSED)
|
2011-06-08 05:27:11 -07:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIAuthPrompt)) ||
|
|
|
|
aIID.Equals(NS_GET_IID(nsIAuthPrompt2))) {
|
|
|
|
nsresult rv;
|
|
|
|
|
2012-03-12 17:56:07 -07:00
|
|
|
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
|
2010-06-17 11:34:24 -07:00
|
|
|
nsCOMPtr<nsIDocument> doc =
|
2012-03-12 17:56:07 -07:00
|
|
|
nsContentUtils::GetDocumentFromScriptContext(sc);
|
2011-10-20 01:27:13 -07:00
|
|
|
if (!doc)
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPromptFactory> wwatch =
|
|
|
|
do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> outerWindow = doc->GetWindow();
|
|
|
|
return wwatch->GetPrompt(outerWindow, aIID, aResult);
|
|
|
|
}
|
|
|
|
|
2012-02-21 14:57:10 -08:00
|
|
|
return QueryInterface(aIID, aResult);
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsWebSocket
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2011-10-17 07:59:28 -07:00
|
|
|
nsWebSocket::nsWebSocket() : mKeepingAlive(false),
|
|
|
|
mCheckMustKeepAlive(true),
|
2012-06-04 16:38:32 -07:00
|
|
|
mOnCloseScheduled(false),
|
|
|
|
mFailed(false),
|
2011-10-20 01:27:13 -07:00
|
|
|
mDisconnected(false),
|
2012-01-31 20:41:43 -08:00
|
|
|
mCloseEventWasClean(false),
|
|
|
|
mCloseEventCode(nsIWebSocketChannel::CLOSE_ABNORMAL),
|
2011-12-20 00:20:12 -08:00
|
|
|
mReadyState(nsIWebSocket::CONNECTING),
|
2010-12-21 09:05:34 -08:00
|
|
|
mOutgoingBufferedAmount(0),
|
2011-12-15 15:19:01 -08:00
|
|
|
mBinaryType(WS_BINARY_TYPE_BLOB),
|
2010-12-21 09:05:34 -08:00
|
|
|
mScriptLine(0),
|
2011-08-24 13:44:35 -07:00
|
|
|
mInnerWindowID(0)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2011-10-20 01:27:13 -07:00
|
|
|
nsLayoutStatics::AddRef();
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
nsWebSocket::~nsWebSocket()
|
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2011-12-08 00:31:14 -08:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
// If we threw during Init we never called disconnect
|
|
|
|
if (!mDisconnected) {
|
|
|
|
Disconnect();
|
|
|
|
}
|
2011-10-20 01:27:13 -07:00
|
|
|
nsLayoutStatics::Release();
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(nsWebSocket)
|
|
|
|
|
2012-01-26 07:55:30 -08:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsWebSocket)
|
2012-02-16 08:45:25 -08:00
|
|
|
bool isBlack = tmp->IsBlack();
|
|
|
|
if (isBlack|| tmp->mKeepingAlive) {
|
2012-01-26 07:55:30 -08:00
|
|
|
if (tmp->mListenerManager) {
|
|
|
|
tmp->mListenerManager->UnmarkGrayJSListeners();
|
|
|
|
NS_UNMARK_LISTENER_WRAPPER(Open)
|
|
|
|
NS_UNMARK_LISTENER_WRAPPER(Error)
|
|
|
|
NS_UNMARK_LISTENER_WRAPPER(Message)
|
|
|
|
NS_UNMARK_LISTENER_WRAPPER(Close)
|
|
|
|
}
|
2012-03-14 07:22:10 -07:00
|
|
|
if (!isBlack && tmp->PreservingWrapper()) {
|
|
|
|
xpc_UnmarkGrayObject(tmp->GetWrapperPreserveColor());
|
2012-02-16 08:45:25 -08:00
|
|
|
}
|
2012-01-26 07:55:30 -08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsWebSocket)
|
|
|
|
return tmp->IsBlack();
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsWebSocket)
|
|
|
|
return tmp->IsBlack();
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(nsWebSocket,
|
2012-02-07 18:53:33 -08:00
|
|
|
nsDOMEventTargetHelper)
|
2012-01-26 07:55:30 -08:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_END
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsWebSocket,
|
2012-02-07 18:53:33 -08:00
|
|
|
nsDOMEventTargetHelper)
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOnOpenListener)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOnMessageListener)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOnCloseListener)
|
2010-06-19 02:00:57 -07:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOnErrorListener)
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mPrincipal)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mURI)
|
2011-12-15 15:19:01 -08:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mChannel)
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsWebSocket,
|
2012-02-07 18:53:33 -08:00
|
|
|
nsDOMEventTargetHelper)
|
2011-10-20 01:27:13 -07:00
|
|
|
tmp->Disconnect();
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mOnOpenListener)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mOnMessageListener)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mOnCloseListener)
|
2010-06-19 02:00:57 -07:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mOnErrorListener)
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mPrincipal)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mURI)
|
2011-12-15 15:19:01 -08:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mChannel)
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
DOMCI_DATA(WebSocket, nsWebSocket)
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsWebSocket)
|
2011-12-20 00:20:12 -08:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIWebSocket)
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIJSNativeInitializer)
|
2011-10-20 01:27:13 -07:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIWebSocketListener)
|
2012-02-21 14:57:10 -08:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIObserver)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
2011-10-20 01:27:13 -07:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIRequest)
|
2011-12-20 00:20:12 -08:00
|
|
|
NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(WebSocket)
|
2012-02-07 18:53:33 -08:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsDOMEventTargetHelper)
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-02-07 18:53:33 -08:00
|
|
|
NS_IMPL_ADDREF_INHERITED(nsWebSocket, nsDOMEventTargetHelper)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsWebSocket, nsDOMEventTargetHelper)
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-03-12 17:56:07 -07:00
|
|
|
void
|
|
|
|
nsWebSocket::DisconnectFromOwner()
|
|
|
|
{
|
|
|
|
nsDOMEventTargetHelper::DisconnectFromOwner();
|
|
|
|
NS_DISCONNECT_EVENT_HANDLER(Open)
|
|
|
|
NS_DISCONNECT_EVENT_HANDLER(Message)
|
|
|
|
NS_DISCONNECT_EVENT_HANDLER(Close)
|
|
|
|
NS_DISCONNECT_EVENT_HANDLER(Error)
|
2012-06-04 16:38:32 -07:00
|
|
|
CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
|
2012-03-12 17:56:07 -07:00
|
|
|
DontKeepAliveAnyMore();
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// nsWebSocket::nsIJSNativeInitializer methods:
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This Initialize method is called from XPConnect via nsIJSNativeInitializer.
|
|
|
|
* It is used for constructing our nsWebSocket from JavaScript. It expects a URL
|
2011-08-03 09:42:02 -07:00
|
|
|
* string parameter and an optional protocol parameter which may be a string or
|
|
|
|
* an array of strings. It also initializes the principal, the script context and
|
|
|
|
* the window owner.
|
2010-06-17 11:34:24 -07:00
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::Initialize(nsISupports* aOwner,
|
2010-06-17 11:36:01 -07:00
|
|
|
JSContext* aContext,
|
|
|
|
JSObject* aObject,
|
|
|
|
PRUint32 aArgc,
|
2012-05-11 08:46:26 -07:00
|
|
|
JS::Value* aArgv)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2011-08-03 09:42:02 -07:00
|
|
|
nsAutoString urlParam;
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2010-12-08 14:12:51 -08:00
|
|
|
if (!PrefEnabled()) {
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:36:01 -07:00
|
|
|
if (aArgc != 1 && aArgc != 2) {
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:36:01 -07:00
|
|
|
JSAutoRequest ar(aContext);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2010-06-17 11:36:01 -07:00
|
|
|
JSString* jsstr = JS_ValueToString(aContext, aArgv[0]);
|
2010-06-17 11:34:24 -07:00
|
|
|
if (!jsstr) {
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
}
|
2010-12-03 00:24:17 -08:00
|
|
|
|
2011-05-05 14:16:44 -07:00
|
|
|
JS::Anchor<JSString *> deleteProtector(jsstr);
|
2010-12-03 00:24:17 -08:00
|
|
|
size_t length;
|
|
|
|
const jschar *chars = JS_GetStringCharsAndLength(aContext, jsstr, &length);
|
|
|
|
if (!chars) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
urlParam.Assign(chars, length);
|
2011-05-05 14:16:44 -07:00
|
|
|
deleteProtector.clear();
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> ownerWindow = do_QueryInterface(aOwner);
|
|
|
|
NS_ENSURE_STATE(ownerWindow);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aOwner);
|
|
|
|
NS_ENSURE_STATE(sgo);
|
|
|
|
nsCOMPtr<nsIScriptContext> scriptContext = sgo->GetContext();
|
|
|
|
NS_ENSURE_STATE(scriptContext);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIScriptObjectPrincipal> scriptPrincipal(do_QueryInterface(aOwner));
|
|
|
|
NS_ENSURE_STATE(scriptPrincipal);
|
|
|
|
nsCOMPtr<nsIPrincipal> principal = scriptPrincipal->GetPrincipal();
|
|
|
|
NS_ENSURE_STATE(principal);
|
|
|
|
|
2011-08-03 09:42:02 -07:00
|
|
|
nsTArray<nsString> protocolArray;
|
|
|
|
|
|
|
|
if (aArgc == 2) {
|
2012-05-11 08:46:26 -07:00
|
|
|
if (aArgv[1].isObject() &&
|
|
|
|
JS_IsArrayObject(aContext, &aArgv[1].toObject())) {
|
|
|
|
JSObject* jsobj = &aArgv[1].toObject();
|
2011-08-03 09:42:02 -07:00
|
|
|
|
2012-03-06 15:52:55 -08:00
|
|
|
uint32_t len;
|
2011-08-03 09:42:02 -07:00
|
|
|
JS_GetArrayLength(aContext, jsobj, &len);
|
|
|
|
|
|
|
|
for (PRUint32 index = 0; index < len; ++index) {
|
|
|
|
jsval value;
|
|
|
|
|
|
|
|
if (!JS_GetElement(aContext, jsobj, index, &value))
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
|
|
|
|
jsstr = JS_ValueToString(aContext, value);
|
|
|
|
if (!jsstr)
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
|
|
|
|
deleteProtector.set(jsstr);
|
|
|
|
chars = JS_GetStringCharsAndLength(aContext, jsstr, &length);
|
|
|
|
if (!chars)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
nsDependentString protocolElement(chars, length);
|
|
|
|
if (protocolElement.IsEmpty())
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
if (protocolArray.Contains(protocolElement))
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
if (protocolElement.FindChar(',') != -1) /* interferes w/list */
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
protocolArray.AppendElement(protocolElement);
|
|
|
|
deleteProtector.clear();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
jsstr = JS_ValueToString(aContext, aArgv[1]);
|
|
|
|
if (!jsstr)
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
|
|
|
|
deleteProtector.set(jsstr);
|
|
|
|
chars = JS_GetStringCharsAndLength(aContext, jsstr, &length);
|
|
|
|
if (!chars)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
nsDependentString protocolElement(chars, length);
|
|
|
|
if (protocolElement.IsEmpty())
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
if (protocolElement.FindChar(',') != -1) /* interferes w/list */
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
protocolArray.AppendElement(protocolElement);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Init(principal, scriptContext, ownerWindow, urlParam, protocolArray);
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// nsWebSocket methods:
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
2011-10-20 01:27:13 -07:00
|
|
|
class nsAutoCloseWS
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsAutoCloseWS(nsWebSocket *aWebSocket)
|
|
|
|
: mWebSocket(aWebSocket)
|
|
|
|
{}
|
|
|
|
|
|
|
|
~nsAutoCloseWS()
|
|
|
|
{
|
2011-12-15 15:19:01 -08:00
|
|
|
if (!mWebSocket->mChannel) {
|
2012-01-31 20:41:43 -08:00
|
|
|
mWebSocket->CloseConnection(nsIWebSocketChannel::CLOSE_INTERNAL_ERROR);
|
2011-10-20 01:27:13 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
nsRefPtr<nsWebSocket> mWebSocket;
|
|
|
|
};
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
nsresult
|
|
|
|
nsWebSocket::EstablishConnection()
|
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2011-12-15 15:19:01 -08:00
|
|
|
NS_ABORT_IF_FALSE(!mChannel, "mChannel should be null");
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
|
2011-10-20 01:27:13 -07:00
|
|
|
nsCOMPtr<nsIWebSocketChannel> wsChannel;
|
|
|
|
nsAutoCloseWS autoClose(this);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-10-20 01:27:13 -07:00
|
|
|
if (mSecure) {
|
|
|
|
wsChannel =
|
|
|
|
do_CreateInstance("@mozilla.org/network/protocol;1?name=wss", &rv);
|
|
|
|
} else {
|
|
|
|
wsChannel =
|
|
|
|
do_CreateInstance("@mozilla.org/network/protocol;1?name=ws", &rv);
|
|
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = wsChannel->SetNotificationCallbacks(this);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// add ourselves to the document's load group and
|
|
|
|
// provide the http stack the loadgroup info too
|
|
|
|
nsCOMPtr<nsILoadGroup> loadGroup;
|
|
|
|
rv = GetLoadGroup(getter_AddRefs(loadGroup));
|
|
|
|
if (loadGroup) {
|
|
|
|
rv = wsChannel->SetLoadGroup(loadGroup);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = loadGroup->AddRequest(this, nsnull);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mRequestedProtocolList.IsEmpty()) {
|
|
|
|
rv = wsChannel->SetProtocol(mRequestedProtocolList);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2011-08-02 16:55:17 -07:00
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-10-20 01:27:13 -07:00
|
|
|
nsCString asciiOrigin;
|
|
|
|
rv = nsContentUtils::GetASCIIOrigin(mPrincipal, asciiOrigin);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
ToLowerCase(asciiOrigin);
|
|
|
|
|
|
|
|
rv = wsChannel->AsyncOpen(mURI, asciiOrigin, this, nsnull);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
mChannel = wsChannel;
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
void
|
|
|
|
nsWebSocket::DispatchConnectionCloseEvents()
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2012-06-04 16:38:32 -07:00
|
|
|
nsresult rv;
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
mReadyState = nsIWebSocket::CLOSED;
|
|
|
|
|
|
|
|
// Call 'onerror' if needed
|
|
|
|
if (mFailed) {
|
|
|
|
nsresult rv = CreateAndDispatchSimpleEvent(NS_LITERAL_STRING("error"));
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
NS_WARNING("Failed to dispatch the error event");
|
|
|
|
}
|
2010-06-17 11:36:01 -07:00
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
rv = CreateAndDispatchCloseEvent(mCloseEventWasClean, mCloseEventCode,
|
|
|
|
mCloseEventReason);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
NS_WARNING("Failed to dispatch the close event");
|
|
|
|
}
|
|
|
|
|
|
|
|
UpdateMustKeepAlive();
|
|
|
|
Disconnect();
|
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2010-06-17 11:36:01 -07:00
|
|
|
nsresult
|
|
|
|
nsWebSocket::CreateAndDispatchSimpleEvent(const nsString& aName)
|
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:34:24 -07:00
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
rv = CheckInnerWindowCorrectness();
|
2010-06-17 11:36:01 -07:00
|
|
|
if (NS_FAILED(rv)) {
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMEvent> event;
|
|
|
|
rv = NS_NewDOMEvent(getter_AddRefs(event), nsnull, nsnull);
|
2010-06-17 11:36:01 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
// it doesn't bubble, and it isn't cancelable
|
2011-10-17 07:59:28 -07:00
|
|
|
rv = event->InitEvent(aName, false, false);
|
2010-06-17 11:36:01 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2012-06-10 16:44:50 -07:00
|
|
|
rv = event->SetTrusted(true);
|
2010-06-17 11:36:01 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return DispatchDOMEvent(nsnull, event, nsnull, nsnull);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
2011-12-15 15:19:01 -08:00
|
|
|
nsWebSocket::CreateAndDispatchMessageEvent(const nsACString& aData,
|
|
|
|
bool isBinary)
|
2010-06-17 11:36:01 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:36:01 -07:00
|
|
|
nsresult rv;
|
2011-10-20 01:27:13 -07:00
|
|
|
|
2010-06-17 11:36:01 -07:00
|
|
|
rv = CheckInnerWindowCorrectness();
|
2011-12-15 15:19:01 -08:00
|
|
|
if (NS_FAILED(rv))
|
2010-06-17 11:36:01 -07:00
|
|
|
return NS_OK;
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
// Get the JSContext
|
2012-03-12 17:56:07 -07:00
|
|
|
nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(GetOwner());
|
2011-05-23 11:53:31 -07:00
|
|
|
NS_ENSURE_TRUE(sgo, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsIScriptContext* scriptContext = sgo->GetContext();
|
|
|
|
NS_ENSURE_TRUE(scriptContext, NS_ERROR_FAILURE);
|
|
|
|
|
2011-09-18 02:22:17 -07:00
|
|
|
JSContext* cx = scriptContext->GetNativeContext();
|
2011-05-23 11:53:31 -07:00
|
|
|
NS_ENSURE_TRUE(cx, NS_ERROR_FAILURE);
|
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
// Create appropriate JS object for message
|
2011-05-23 11:53:31 -07:00
|
|
|
jsval jsData;
|
|
|
|
{
|
|
|
|
JSAutoRequest ar(cx);
|
2011-12-15 15:19:01 -08:00
|
|
|
if (isBinary) {
|
|
|
|
if (mBinaryType == WS_BINARY_TYPE_BLOB) {
|
|
|
|
rv = CreateResponseBlob(aData, cx, jsData);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
} else if (mBinaryType == WS_BINARY_TYPE_ARRAYBUFFER) {
|
|
|
|
JSObject *arrayBuf;
|
|
|
|
rv = nsContentUtils::CreateArrayBuffer(cx, aData, &arrayBuf);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
jsData = OBJECT_TO_JSVAL(arrayBuf);
|
|
|
|
} else {
|
|
|
|
NS_RUNTIMEABORT("Unknown binary type!");
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// JS string
|
|
|
|
NS_ConvertUTF8toUTF16 utf16Data(aData);
|
|
|
|
JSString* jsString;
|
|
|
|
jsString = JS_NewUCStringCopyN(cx, utf16Data.get(), utf16Data.Length());
|
|
|
|
NS_ENSURE_TRUE(jsString, NS_ERROR_FAILURE);
|
2011-05-23 11:53:31 -07:00
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
jsData = STRING_TO_JSVAL(jsString);
|
|
|
|
}
|
2011-05-23 11:53:31 -07:00
|
|
|
}
|
|
|
|
|
2010-06-17 11:36:01 -07:00
|
|
|
// create an event that uses the MessageEvent interface,
|
|
|
|
// which does not bubble, is not cancelable, and has no default action
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMEvent> event;
|
|
|
|
rv = NS_NewDOMMessageEvent(getter_AddRefs(event), nsnull, nsnull);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMMessageEvent> messageEvent = do_QueryInterface(event);
|
|
|
|
rv = messageEvent->InitMessageEvent(NS_LITERAL_STRING("message"),
|
2011-10-17 07:59:28 -07:00
|
|
|
false, false,
|
2011-05-23 11:53:31 -07:00
|
|
|
jsData,
|
2011-05-21 18:27:52 -07:00
|
|
|
mUTF16Origin,
|
2010-06-17 11:36:01 -07:00
|
|
|
EmptyString(), nsnull);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2012-06-10 16:44:50 -07:00
|
|
|
rv = event->SetTrusted(true);
|
2010-06-17 11:36:01 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2010-06-17 11:36:01 -07:00
|
|
|
return DispatchDOMEvent(nsnull, event, nsnull, nsnull);
|
|
|
|
}
|
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
// Initial implementation: only stores to RAM, not file
|
|
|
|
// TODO: bug 704447: large file support
|
|
|
|
nsresult
|
|
|
|
nsWebSocket::CreateResponseBlob(const nsACString& aData, JSContext *aCx,
|
|
|
|
jsval &jsData)
|
|
|
|
{
|
|
|
|
PRUint32 blobLen = aData.Length();
|
|
|
|
void *blobData = PR_Malloc(blobLen);
|
|
|
|
nsCOMPtr<nsIDOMBlob> blob;
|
|
|
|
if (blobData) {
|
|
|
|
memcpy(blobData, aData.BeginReading(), blobLen);
|
|
|
|
blob = new nsDOMMemoryFile(blobData, blobLen, EmptyString());
|
|
|
|
} else {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
JSObject* scope = JS_GetGlobalForScopeChain(aCx);
|
|
|
|
return nsContentUtils::WrapNative(aCx, scope, blob, &jsData, nsnull, true);
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:36:01 -07:00
|
|
|
nsresult
|
2011-09-28 23:19:26 -07:00
|
|
|
nsWebSocket::CreateAndDispatchCloseEvent(bool aWasClean,
|
2011-08-03 12:15:25 -07:00
|
|
|
PRUint16 aCode,
|
|
|
|
const nsString &aReason)
|
2010-06-17 11:36:01 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:36:01 -07:00
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
rv = CheckInnerWindowCorrectness();
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// create an event that uses the CloseEvent interface,
|
|
|
|
// which does not bubble, is not cancelable, and has no default action
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMEvent> event;
|
|
|
|
rv = NS_NewDOMCloseEvent(getter_AddRefs(event), nsnull, nsnull);
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2010-06-17 11:36:01 -07:00
|
|
|
nsCOMPtr<nsIDOMCloseEvent> closeEvent = do_QueryInterface(event);
|
|
|
|
rv = closeEvent->InitCloseEvent(NS_LITERAL_STRING("close"),
|
2011-10-17 07:59:28 -07:00
|
|
|
false, false,
|
2011-08-03 12:15:25 -07:00
|
|
|
aWasClean, aCode, aReason);
|
2010-06-17 11:36:01 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2012-06-10 16:44:50 -07:00
|
|
|
rv = event->SetTrusted(true);
|
2010-06-17 11:36:01 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return DispatchDOMEvent(nsnull, event, nsnull, nsnull);
|
|
|
|
}
|
|
|
|
|
2011-09-28 23:19:26 -07:00
|
|
|
bool
|
2010-12-08 14:12:51 -08:00
|
|
|
nsWebSocket::PrefEnabled()
|
|
|
|
{
|
2011-09-28 23:19:26 -07:00
|
|
|
return Preferences::GetBool("network.websocket.enabled", true);
|
2010-12-08 14:12:51 -08:00
|
|
|
}
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
nsresult
|
|
|
|
nsWebSocket::ParseURL(const nsString& aURL)
|
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
NS_ENSURE_TRUE(!aURL.IsEmpty(), NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
rv = NS_NewURI(getter_AddRefs(uri), aURL);
|
|
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIURL> parsedURL(do_QueryInterface(uri, &rv));
|
|
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
nsCAutoString fragment;
|
|
|
|
rv = parsedURL->GetRef(fragment);
|
|
|
|
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && fragment.IsEmpty(),
|
|
|
|
NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
nsCAutoString scheme;
|
|
|
|
rv = parsedURL->GetScheme(scheme);
|
|
|
|
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && !scheme.IsEmpty(),
|
|
|
|
NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
nsCAutoString host;
|
|
|
|
rv = parsedURL->GetAsciiHost(host);
|
|
|
|
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && !host.IsEmpty(), NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
PRInt32 port;
|
|
|
|
rv = parsedURL->GetPort(&port);
|
|
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
rv = NS_CheckPortSafety(port, scheme.get());
|
|
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
nsCAutoString filePath;
|
|
|
|
rv = parsedURL->GetFilePath(filePath);
|
|
|
|
if (filePath.IsEmpty()) {
|
|
|
|
filePath.AssignLiteral("/");
|
|
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
nsCAutoString query;
|
|
|
|
rv = parsedURL->GetQuery(query);
|
|
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
|
|
|
if (scheme.LowerCaseEqualsLiteral("ws")) {
|
2011-10-17 07:59:28 -07:00
|
|
|
mSecure = false;
|
2010-06-17 11:34:24 -07:00
|
|
|
mPort = (port == -1) ? DEFAULT_WS_SCHEME_PORT : port;
|
|
|
|
} else if (scheme.LowerCaseEqualsLiteral("wss")) {
|
2011-10-17 07:59:28 -07:00
|
|
|
mSecure = true;
|
2010-06-17 11:34:24 -07:00
|
|
|
mPort = (port == -1) ? DEFAULT_WSS_SCHEME_PORT : port;
|
|
|
|
} else {
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
}
|
|
|
|
|
2011-08-03 17:32:23 -07:00
|
|
|
rv = nsContentUtils::GetUTFOrigin(parsedURL, mUTF16Origin);
|
|
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
mAsciiHost = host;
|
|
|
|
ToLowerCase(mAsciiHost);
|
|
|
|
|
|
|
|
mResource = filePath;
|
|
|
|
if (!query.IsEmpty()) {
|
|
|
|
mResource.AppendLiteral("?");
|
|
|
|
mResource.Append(query);
|
|
|
|
}
|
|
|
|
PRUint32 length = mResource.Length();
|
|
|
|
PRUint32 i;
|
|
|
|
for (i = 0; i < length; ++i) {
|
|
|
|
if (mResource[i] < static_cast<PRUnichar>(0x0021) ||
|
|
|
|
mResource[i] > static_cast<PRUnichar>(0x007E)) {
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mOriginalURL = aURL;
|
|
|
|
mURI = parsedURL;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-06-27 14:09:29 -07:00
|
|
|
//-----------------------------------------------------------------------------
|
2010-07-21 09:05:56 -07:00
|
|
|
// Methods that keep alive the WebSocket object when:
|
|
|
|
// 1. the object has registered event listeners that can be triggered
|
|
|
|
// ("strong event listeners");
|
|
|
|
// 2. there are outgoing not sent messages.
|
2010-06-27 14:09:29 -07:00
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
void
|
|
|
|
nsWebSocket::UpdateMustKeepAlive()
|
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-07-21 09:05:56 -07:00
|
|
|
if (!mCheckMustKeepAlive) {
|
2010-06-27 14:09:29 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-09-28 23:19:26 -07:00
|
|
|
bool shouldKeepAlive = false;
|
2010-07-21 09:05:56 -07:00
|
|
|
|
|
|
|
if (mListenerManager) {
|
|
|
|
switch (mReadyState)
|
|
|
|
{
|
2011-12-20 00:20:12 -08:00
|
|
|
case nsIWebSocket::CONNECTING:
|
2010-07-21 09:05:56 -07:00
|
|
|
{
|
|
|
|
if (mListenerManager->HasListenersFor(NS_LITERAL_STRING("open")) ||
|
|
|
|
mListenerManager->HasListenersFor(NS_LITERAL_STRING("message")) ||
|
2011-10-20 01:27:13 -07:00
|
|
|
mListenerManager->HasListenersFor(NS_LITERAL_STRING("error")) ||
|
2010-07-21 09:05:56 -07:00
|
|
|
mListenerManager->HasListenersFor(NS_LITERAL_STRING("close"))) {
|
2011-10-17 07:59:28 -07:00
|
|
|
shouldKeepAlive = true;
|
2010-07-21 09:05:56 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
case nsIWebSocket::OPEN:
|
|
|
|
case nsIWebSocket::CLOSING:
|
2010-07-21 09:05:56 -07:00
|
|
|
{
|
|
|
|
if (mListenerManager->HasListenersFor(NS_LITERAL_STRING("message")) ||
|
2011-10-20 01:27:13 -07:00
|
|
|
mListenerManager->HasListenersFor(NS_LITERAL_STRING("error")) ||
|
2010-07-21 09:05:56 -07:00
|
|
|
mListenerManager->HasListenersFor(NS_LITERAL_STRING("close")) ||
|
2011-10-20 01:27:13 -07:00
|
|
|
mOutgoingBufferedAmount != 0) {
|
2011-10-17 07:59:28 -07:00
|
|
|
shouldKeepAlive = true;
|
2010-07-21 09:05:56 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
case nsIWebSocket::CLOSED:
|
2010-07-21 09:05:56 -07:00
|
|
|
{
|
2012-06-04 16:38:32 -07:00
|
|
|
shouldKeepAlive = false;
|
2010-07-21 09:05:56 -07:00
|
|
|
}
|
2010-06-27 14:09:29 -07:00
|
|
|
}
|
|
|
|
}
|
2010-07-21 09:05:56 -07:00
|
|
|
|
|
|
|
if (mKeepingAlive && !shouldKeepAlive) {
|
2011-10-17 07:59:28 -07:00
|
|
|
mKeepingAlive = false;
|
2011-06-23 19:18:00 -07:00
|
|
|
static_cast<nsIDOMEventTarget*>(this)->Release();
|
2010-07-21 09:05:56 -07:00
|
|
|
} else if (!mKeepingAlive && shouldKeepAlive) {
|
2011-10-17 07:59:28 -07:00
|
|
|
mKeepingAlive = true;
|
2011-06-23 19:18:00 -07:00
|
|
|
static_cast<nsIDOMEventTarget*>(this)->AddRef();
|
2010-07-21 09:05:56 -07:00
|
|
|
}
|
2010-06-27 14:09:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsWebSocket::DontKeepAliveAnyMore()
|
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-07-21 09:05:56 -07:00
|
|
|
if (mKeepingAlive) {
|
2011-10-17 07:59:28 -07:00
|
|
|
mKeepingAlive = false;
|
2011-06-23 19:18:00 -07:00
|
|
|
static_cast<nsIDOMEventTarget*>(this)->Release();
|
2010-06-27 14:09:29 -07:00
|
|
|
}
|
2011-10-17 07:59:28 -07:00
|
|
|
mCheckMustKeepAlive = false;
|
2010-06-27 14:09:29 -07:00
|
|
|
}
|
|
|
|
|
2011-12-15 15:23:00 -08:00
|
|
|
nsresult
|
|
|
|
nsWebSocket::UpdateURI()
|
|
|
|
{
|
|
|
|
// Check for Redirections
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
nsresult rv = mChannel->GetURI(getter_AddRefs(uri));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsCAutoString spec;
|
|
|
|
rv = uri->GetSpec(spec);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
CopyUTF8toUTF16(spec, mEffectiveURL);
|
|
|
|
|
|
|
|
bool isWSS = false;
|
|
|
|
rv = uri->SchemeIs("wss", &isWSS);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mSecure = isWSS ? true : false;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-06-27 14:09:29 -07:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::RemoveEventListener(const nsAString& aType,
|
|
|
|
nsIDOMEventListener* aListener,
|
2011-09-28 23:19:26 -07:00
|
|
|
bool aUseCapture)
|
2010-06-27 14:09:29 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-27 14:09:29 -07:00
|
|
|
nsresult rv = nsDOMEventTargetHelper::RemoveEventListener(aType,
|
|
|
|
aListener,
|
|
|
|
aUseCapture);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
UpdateMustKeepAlive();
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::AddEventListener(const nsAString& aType,
|
|
|
|
nsIDOMEventListener *aListener,
|
2011-09-28 23:19:26 -07:00
|
|
|
bool aUseCapture,
|
|
|
|
bool aWantsUntrusted,
|
2010-06-27 14:09:29 -07:00
|
|
|
PRUint8 optional_argc)
|
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-27 14:09:29 -07:00
|
|
|
nsresult rv = nsDOMEventTargetHelper::AddEventListener(aType,
|
|
|
|
aListener,
|
|
|
|
aUseCapture,
|
|
|
|
aWantsUntrusted,
|
|
|
|
optional_argc);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
UpdateMustKeepAlive();
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
//-----------------------------------------------------------------------------
|
2011-12-20 00:20:12 -08:00
|
|
|
// nsWebSocket::nsIWebSocket methods:
|
2010-06-17 11:34:24 -07:00
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2010-06-21 12:56:03 -07:00
|
|
|
nsWebSocket::GetUrl(nsAString& aURL)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-12-15 15:23:00 -08:00
|
|
|
if (mEffectiveURL.IsEmpty()) {
|
|
|
|
aURL = mOriginalURL;
|
|
|
|
} else {
|
|
|
|
aURL = mEffectiveURL;
|
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-08-03 20:46:13 -07:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::GetExtensions(nsAString& aExtensions)
|
|
|
|
{
|
|
|
|
CopyUTF8toUTF16(mEstablishedExtensions, aExtensions);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::GetProtocol(nsAString& aProtocol)
|
|
|
|
{
|
2011-08-03 09:42:02 -07:00
|
|
|
CopyUTF8toUTF16(mEstablishedProtocol, aProtocol);
|
2011-05-21 18:27:52 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMETHODIMP
|
2010-06-17 11:36:01 -07:00
|
|
|
nsWebSocket::GetReadyState(PRUint16 *aReadyState)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
|
|
|
*aReadyState = mReadyState;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::GetBufferedAmount(PRUint32 *aBufferedAmount)
|
|
|
|
{
|
2011-10-20 01:27:13 -07:00
|
|
|
*aBufferedAmount = mOutgoingBufferedAmount;
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::GetBinaryType(nsAString& aBinaryType)
|
|
|
|
{
|
|
|
|
switch (mBinaryType) {
|
|
|
|
case WS_BINARY_TYPE_ARRAYBUFFER:
|
|
|
|
aBinaryType.AssignLiteral("arraybuffer");
|
|
|
|
break;
|
|
|
|
case WS_BINARY_TYPE_BLOB:
|
|
|
|
aBinaryType.AssignLiteral("blob");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
NS_ERROR("Should not happen");
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::SetBinaryType(const nsAString& aBinaryType)
|
|
|
|
{
|
|
|
|
if (aBinaryType.EqualsLiteral("arraybuffer")) {
|
|
|
|
mBinaryType = WS_BINARY_TYPE_ARRAYBUFFER;
|
|
|
|
} else if (aBinaryType.EqualsLiteral("blob")) {
|
|
|
|
mBinaryType = WS_BINARY_TYPE_BLOB;
|
|
|
|
} else {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
#define NS_WEBSOCKET_IMPL_DOMEVENTLISTENER(_eventlistenername, _eventlistener) \
|
|
|
|
NS_IMETHODIMP \
|
|
|
|
nsWebSocket::GetOn##_eventlistenername(nsIDOMEventListener * *aEventListener)\
|
|
|
|
{ \
|
|
|
|
return GetInnerEventListener(_eventlistener, aEventListener); \
|
|
|
|
} \
|
|
|
|
\
|
|
|
|
NS_IMETHODIMP \
|
|
|
|
nsWebSocket::SetOn##_eventlistenername(nsIDOMEventListener * aEventListener) \
|
|
|
|
{ \
|
|
|
|
return RemoveAddEventListener(NS_LITERAL_STRING(#_eventlistenername), \
|
|
|
|
_eventlistener, aEventListener); \
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_WEBSOCKET_IMPL_DOMEVENTLISTENER(open, mOnOpenListener)
|
2010-06-17 11:36:01 -07:00
|
|
|
NS_WEBSOCKET_IMPL_DOMEVENTLISTENER(error, mOnErrorListener)
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_WEBSOCKET_IMPL_DOMEVENTLISTENER(message, mOnMessageListener)
|
|
|
|
NS_WEBSOCKET_IMPL_DOMEVENTLISTENER(close, mOnCloseListener)
|
|
|
|
|
2011-08-03 12:15:25 -07:00
|
|
|
NS_IMETHODIMP
|
2012-01-14 09:43:00 -08:00
|
|
|
nsWebSocket::Send(nsIVariant *aData, JSContext *aCx)
|
2011-08-03 12:15:25 -07:00
|
|
|
{
|
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
if (mReadyState == nsIWebSocket::CONNECTING) {
|
2011-08-03 12:15:25 -07:00
|
|
|
return NS_ERROR_DOM_INVALID_STATE_ERR;
|
|
|
|
}
|
|
|
|
|
2011-12-15 15:19:01 -08:00
|
|
|
nsCString msgString;
|
|
|
|
nsCOMPtr<nsIInputStream> msgStream;
|
|
|
|
bool isBinary;
|
|
|
|
PRUint32 msgLen;
|
2012-01-14 09:43:00 -08:00
|
|
|
nsresult rv = GetSendParams(aData, msgString, msgStream, isBinary, msgLen, aCx);
|
2011-12-15 15:19:01 -08:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// Always increment outgoing buffer len, even if closed
|
|
|
|
mOutgoingBufferedAmount += msgLen;
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
if (mReadyState == nsIWebSocket::CLOSING ||
|
|
|
|
mReadyState == nsIWebSocket::CLOSED) {
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
MOZ_ASSERT(mReadyState == nsIWebSocket::OPEN,
|
|
|
|
"Unknown state in nsWebSocket::Send");
|
2011-12-15 15:19:01 -08:00
|
|
|
|
|
|
|
if (msgStream) {
|
|
|
|
rv = mChannel->SendBinaryStream(msgStream, msgLen);
|
|
|
|
} else {
|
|
|
|
if (isBinary) {
|
|
|
|
rv = mChannel->SendBinaryMsg(msgString);
|
|
|
|
} else {
|
|
|
|
rv = mChannel->SendMsg(msgString);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
UpdateMustKeepAlive();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsWebSocket::GetSendParams(nsIVariant *aData, nsCString &aStringOut,
|
|
|
|
nsCOMPtr<nsIInputStream> &aStreamOut,
|
2012-01-14 09:43:00 -08:00
|
|
|
bool &aIsBinary, PRUint32 &aOutgoingLength,
|
|
|
|
JSContext *aCx)
|
2011-12-15 15:19:01 -08:00
|
|
|
{
|
|
|
|
// Get type of data (arraybuffer, blob, or string)
|
|
|
|
PRUint16 dataType;
|
|
|
|
nsresult rv = aData->GetDataType(&dataType);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
if (dataType == nsIDataType::VTYPE_INTERFACE ||
|
|
|
|
dataType == nsIDataType::VTYPE_INTERFACE_IS) {
|
|
|
|
nsCOMPtr<nsISupports> supports;
|
|
|
|
nsID *iid;
|
|
|
|
rv = aData->GetAsInterface(&iid, getter_AddRefs(supports));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsMemory::Free(iid);
|
|
|
|
|
|
|
|
// ArrayBuffer?
|
|
|
|
jsval realVal;
|
|
|
|
JSObject* obj;
|
|
|
|
nsresult rv = aData->GetAsJSVal(&realVal);
|
|
|
|
if (NS_SUCCEEDED(rv) && !JSVAL_IS_PRIMITIVE(realVal) &&
|
|
|
|
(obj = JSVAL_TO_OBJECT(realVal)) &&
|
2012-01-14 09:43:00 -08:00
|
|
|
(JS_IsArrayBufferObject(obj, aCx))) {
|
|
|
|
PRInt32 len = JS_GetArrayBufferByteLength(obj, aCx);
|
|
|
|
char* data = reinterpret_cast<char*>(JS_GetArrayBufferData(obj, aCx));
|
2011-12-15 15:19:01 -08:00
|
|
|
|
|
|
|
aStringOut.Assign(data, len);
|
|
|
|
aIsBinary = true;
|
|
|
|
aOutgoingLength = len;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Blob?
|
|
|
|
nsCOMPtr<nsIDOMBlob> blob = do_QueryInterface(supports);
|
|
|
|
if (blob) {
|
|
|
|
rv = blob->GetInternalStream(getter_AddRefs(aStreamOut));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// GetSize() should not perform blocking I/O (unlike Available())
|
|
|
|
PRUint64 blobLen;
|
|
|
|
rv = blob->GetSize(&blobLen);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (blobLen > PR_UINT32_MAX) {
|
|
|
|
return NS_ERROR_FILE_TOO_BIG;
|
|
|
|
}
|
|
|
|
aOutgoingLength = static_cast<PRUint32>(blobLen);
|
|
|
|
|
|
|
|
aIsBinary = true;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Text message: if not already a string, turn it into one.
|
|
|
|
// TODO: bug 704444: Correctly coerce any JS type to string
|
|
|
|
//
|
|
|
|
PRUnichar* data = nsnull;
|
|
|
|
PRUint32 len = 0;
|
|
|
|
rv = aData->GetAsWStringWithSize(&len, &data);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsString text;
|
|
|
|
text.Adopt(data, len);
|
|
|
|
|
2012-07-09 17:31:01 -07:00
|
|
|
CopyUTF16toUTF8(text, aStringOut);
|
2011-12-15 15:19:01 -08:00
|
|
|
|
|
|
|
aIsBinary = false;
|
|
|
|
aOutgoingLength = aStringOut.Length();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMETHODIMP
|
2011-08-03 12:15:25 -07:00
|
|
|
nsWebSocket::Close(PRUint16 code, const nsAString & reason, PRUint8 argc)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2011-08-03 12:15:25 -07:00
|
|
|
|
|
|
|
// the reason code is optional, but if provided it must be in a specific range
|
2012-01-31 20:41:43 -08:00
|
|
|
PRUint16 closeCode = 0;
|
2011-08-03 12:15:25 -07:00
|
|
|
if (argc >= 1) {
|
2012-01-31 20:41:43 -08:00
|
|
|
if (code != 1000 && (code < 3000 || code > 4999)) {
|
2011-08-03 12:15:25 -07:00
|
|
|
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
|
2012-01-31 20:41:43 -08:00
|
|
|
}
|
|
|
|
closeCode = code;
|
2011-08-03 12:15:25 -07:00
|
|
|
}
|
|
|
|
|
2012-01-31 20:41:43 -08:00
|
|
|
nsCAutoString closeReason;
|
2011-08-03 12:15:25 -07:00
|
|
|
if (argc >= 2) {
|
2012-01-31 20:41:43 -08:00
|
|
|
CopyUTF16toUTF8(reason, closeReason);
|
2011-08-03 12:15:25 -07:00
|
|
|
|
|
|
|
// The API requires the UTF-8 string to be 123 or less bytes
|
2012-01-31 20:41:43 -08:00
|
|
|
if (closeReason.Length() > 123) {
|
2011-08-03 12:15:25 -07:00
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
2012-01-31 20:41:43 -08:00
|
|
|
}
|
2011-08-03 12:15:25 -07:00
|
|
|
}
|
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
if (mReadyState == nsIWebSocket::CLOSING ||
|
|
|
|
mReadyState == nsIWebSocket::CLOSED) {
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
if (mReadyState == nsIWebSocket::CONNECTING) {
|
2012-01-31 20:41:43 -08:00
|
|
|
FailConnection(closeCode, closeReason);
|
2010-06-17 11:36:01 -07:00
|
|
|
return NS_OK;
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
2011-12-20 00:20:12 -08:00
|
|
|
// mReadyState == nsIWebSocket::OPEN
|
2012-01-31 20:41:43 -08:00
|
|
|
CloseConnection(closeCode, closeReason);
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This Init method should only be called by C++ consumers.
|
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::Init(nsIPrincipal* aPrincipal,
|
|
|
|
nsIScriptContext* aScriptContext,
|
|
|
|
nsPIDOMWindow* aOwnerWindow,
|
|
|
|
const nsAString& aURL,
|
2011-08-03 09:42:02 -07:00
|
|
|
nsTArray<nsString> & protocolArray)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:34:24 -07:00
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
NS_ENSURE_ARG(aPrincipal);
|
|
|
|
|
2010-12-08 14:12:51 -08:00
|
|
|
if (!PrefEnabled()) {
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
mPrincipal = aPrincipal;
|
|
|
|
if (aOwnerWindow) {
|
2012-03-12 17:56:07 -07:00
|
|
|
BindToOwner(aOwnerWindow->IsOuterWindow() ?
|
|
|
|
aOwnerWindow->GetCurrentInnerWindow() : aOwnerWindow);
|
2011-10-20 01:27:13 -07:00
|
|
|
} else {
|
2012-03-12 17:56:07 -07:00
|
|
|
BindToOwner(aOwnerWindow);
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
2012-02-21 14:57:10 -08:00
|
|
|
// Attempt to kill "ghost" websocket: but usually too early for check to fail
|
|
|
|
rv = CheckInnerWindowCorrectness();
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// Shut down websocket if window is frozen or destroyed (only needed for
|
|
|
|
// "ghost" websockets--see bug 696085)
|
|
|
|
nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
|
|
|
|
NS_ENSURE_STATE(os);
|
|
|
|
rv = os->AddObserver(this, DOM_WINDOW_DESTROYED_TOPIC, true);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = os->AddObserver(this, DOM_WINDOW_FROZEN_TOPIC, true);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2010-12-21 09:05:34 -08:00
|
|
|
nsCOMPtr<nsIJSContextStack> stack =
|
|
|
|
do_GetService("@mozilla.org/js/xpc/ContextStack;1");
|
|
|
|
JSContext* cx = nsnull;
|
|
|
|
if (stack && NS_SUCCEEDED(stack->Peek(&cx)) && cx) {
|
2012-03-06 15:33:12 -08:00
|
|
|
unsigned lineno;
|
|
|
|
JSScript *script;
|
2010-12-21 09:05:34 -08:00
|
|
|
|
2012-03-06 15:33:12 -08:00
|
|
|
if (JS_DescribeScriptedCaller(cx, &script, &lineno)) {
|
|
|
|
mScriptFile = JS_GetScriptFilename(cx, script);
|
|
|
|
mScriptLine = lineno;
|
2010-12-21 09:05:34 -08:00
|
|
|
}
|
|
|
|
|
2011-08-24 13:44:35 -07:00
|
|
|
mInnerWindowID = nsJSUtils::GetCurrentlyRunningCodeInnerWindowID(cx);
|
2010-12-21 09:05:34 -08:00
|
|
|
}
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
// parses the url
|
|
|
|
rv = ParseURL(PromiseFlatString(aURL));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2012-03-12 17:56:07 -07:00
|
|
|
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
|
2011-12-07 15:19:43 -08:00
|
|
|
nsCOMPtr<nsIDocument> originDoc =
|
2012-03-12 17:56:07 -07:00
|
|
|
nsContentUtils::GetDocumentFromScriptContext(sc);
|
2011-12-07 15:19:43 -08:00
|
|
|
|
2011-07-10 09:31:41 -07:00
|
|
|
// Don't allow https:// to open ws://
|
2011-10-20 01:27:13 -07:00
|
|
|
if (!mSecure &&
|
2011-07-10 09:31:41 -07:00
|
|
|
!Preferences::GetBool("network.websocket.allowInsecureFromHTTPS",
|
2011-09-28 23:19:26 -07:00
|
|
|
false)) {
|
2011-07-19 06:17:39 -07:00
|
|
|
// Confirmed we are opening plain ws:// and want to prevent this from a
|
|
|
|
// secure context (e.g. https). Check the security context of the document
|
|
|
|
// associated with this script, which is the same as associated with mOwner.
|
|
|
|
if (originDoc && originDoc->GetSecurityInfo())
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2011-07-10 09:31:41 -07:00
|
|
|
}
|
|
|
|
|
2011-08-03 09:42:02 -07:00
|
|
|
// Assign the sub protocol list and scan it for illegal values
|
|
|
|
for (PRUint32 index = 0; index < protocolArray.Length(); ++index) {
|
|
|
|
for (PRUint32 i = 0; i < protocolArray[index].Length(); ++i) {
|
|
|
|
if (protocolArray[index][i] < static_cast<PRUnichar>(0x0021) ||
|
|
|
|
protocolArray[index][i] > static_cast<PRUnichar>(0x007E))
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mRequestedProtocolList.IsEmpty())
|
|
|
|
mRequestedProtocolList.Append(NS_LITERAL_CSTRING(", "));
|
|
|
|
AppendUTF16toUTF8(protocolArray[index], mRequestedProtocolList);
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
2011-12-07 15:19:43 -08:00
|
|
|
// Check content policy.
|
|
|
|
PRInt16 shouldLoad = nsIContentPolicy::ACCEPT;
|
|
|
|
rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_WEBSOCKET,
|
|
|
|
mURI,
|
|
|
|
mPrincipal,
|
|
|
|
originDoc,
|
|
|
|
EmptyCString(),
|
|
|
|
nsnull,
|
|
|
|
&shouldLoad,
|
|
|
|
nsContentUtils::GetContentPolicy(),
|
|
|
|
nsContentUtils::GetSecurityManager());
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (NS_CP_REJECTED(shouldLoad)) {
|
|
|
|
// Disallowed by content policy.
|
|
|
|
return NS_ERROR_CONTENT_BLOCKED;
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:34:24 -07:00
|
|
|
// the constructor should throw a SYNTAX_ERROR only if it fails to parse the
|
2012-07-09 18:20:25 -07:00
|
|
|
// url parameter, so don't throw if EstablishConnection fails, and call
|
|
|
|
// onerror/onclose asynchronously
|
|
|
|
if (NS_FAILED(EstablishConnection())) {
|
|
|
|
FailConnection(nsIWebSocketChannel::CLOSE_ABNORMAL);
|
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-02-21 14:57:10 -08:00
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// nsWebSocket::nsIObserver
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebSocket::Observe(nsISupports* aSubject,
|
|
|
|
const char* aTopic,
|
|
|
|
const PRUnichar* aData)
|
|
|
|
{
|
|
|
|
if ((mReadyState == nsIWebSocket::CLOSING) ||
|
|
|
|
(mReadyState == nsIWebSocket::CLOSED)) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(aSubject);
|
2012-03-12 17:56:07 -07:00
|
|
|
if (!GetOwner() || window != GetOwner()) {
|
2012-02-21 14:57:10 -08:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((strcmp(aTopic, DOM_WINDOW_FROZEN_TOPIC) == 0) ||
|
|
|
|
(strcmp(aTopic, DOM_WINDOW_DESTROYED_TOPIC) == 0))
|
|
|
|
{
|
2012-06-04 16:38:32 -07:00
|
|
|
CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
|
2012-02-21 14:57:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
//-----------------------------------------------------------------------------
|
2011-10-20 01:27:13 -07:00
|
|
|
// nsWebSocket::nsIRequest
|
2011-05-21 18:27:52 -07:00
|
|
|
//-----------------------------------------------------------------------------
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::GetName(nsACString &aName)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-10-20 01:27:13 -07:00
|
|
|
CopyUTF16toUTF8(mOriginalURL, aName);
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::IsPending(bool *aValue)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2012-06-04 16:38:32 -07:00
|
|
|
*aValue = (mReadyState != nsIWebSocket::CLOSED);
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::GetStatus(nsresult *aStatus)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
*aStatus = NS_OK;
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-08-07 06:44:19 -07:00
|
|
|
// Window closed, stop/reload button pressed, user navigated away from page, etc.
|
2010-06-17 11:34:24 -07:00
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::Cancel(nsresult aStatus)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2012-06-04 16:38:32 -07:00
|
|
|
if (mReadyState == CLOSING || mReadyState == CLOSED) {
|
2011-05-21 18:27:52 -07:00
|
|
|
return NS_OK;
|
2012-06-04 16:38:32 -07:00
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
ConsoleError();
|
2012-06-04 16:38:32 -07:00
|
|
|
|
2012-01-31 20:41:43 -08:00
|
|
|
return CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::Suspend()
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::Resume()
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
2010-06-17 11:34:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::GetLoadGroup(nsILoadGroup **aLoadGroup)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
*aLoadGroup = nsnull;
|
|
|
|
|
2012-03-12 17:56:07 -07:00
|
|
|
nsresult rv;
|
|
|
|
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
|
2011-05-21 18:27:52 -07:00
|
|
|
nsCOMPtr<nsIDocument> doc =
|
2012-03-12 17:56:07 -07:00
|
|
|
nsContentUtils::GetDocumentFromScriptContext(sc);
|
2011-05-21 18:27:52 -07:00
|
|
|
|
|
|
|
if (doc) {
|
|
|
|
*aLoadGroup = doc->GetDocumentLoadGroup().get(); // already_AddRefed
|
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-05-21 18:27:52 -07:00
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::SetLoadGroup(nsILoadGroup *aLoadGroup)
|
2011-05-21 18:27:52 -07:00
|
|
|
{
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
2010-06-17 11:34:24 -07:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::GetLoadFlags(nsLoadFlags *aLoadFlags)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
*aLoadFlags = nsIRequest::LOAD_BACKGROUND;
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-10-20 01:27:13 -07:00
|
|
|
nsWebSocket::SetLoadFlags(nsLoadFlags aLoadFlags)
|
2010-06-17 11:34:24 -07:00
|
|
|
{
|
2011-05-21 18:27:52 -07:00
|
|
|
// we won't change the load flags at all.
|
2010-06-17 11:34:24 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|