dom/base/nsDOMDataChannel.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsDOMDataChannel.h"
   8
   9 #include "base/basictypes.h"
  10 #include "mozilla/Logging.h"
  11
  12 #include "nsDOMDataChannelDeclarations.h"
  13 #include "mozilla/DOMEventTargetHelper.h"
  14 #include "mozilla/EventListenerManager.h"
  15 #include "mozilla/dom/File.h"
  16 #include "mozilla/dom/MessageEvent.h"
  17 #include "mozilla/dom/MessageEventBinding.h"
  18 #include "mozilla/dom/ScriptSettings.h"
  19 #include "mozilla/dom/ToJSValue.h"
  20 #include "mozilla/dom/Blob.h"
  21
  22 #include "nsError.h"
  23 #include "nsContentUtils.h"
  24 #include "nsCycleCollectionParticipant.h"
  25 #include "nsIScriptContext.h"
  26 #include "nsIScriptObjectPrincipal.h"
  27 #include "nsProxyRelease.h"
  28
  29 #include "DataChannel.h"
  30 #include "DataChannelLog.h"
  31
  32 // Since we've moved the windows.h include down here, we have to explicitly
  33 // undef GetBinaryType, otherwise we'll get really odd conflicts
  34 #ifdef GetBinaryType
  35 #  undef GetBinaryType
  36 #endif
  37
  38 using namespace mozilla;
  39 using namespace mozilla::dom;
  40
  41 nsDOMDataChannel::~nsDOMDataChannel() {
  42   // Don't call us anymore!  Likely isn't an issue (or maybe just less of
  43   // one) once we block GC until all the (appropriate) onXxxx handlers
  44   // are dropped. (See WebRTC spec)
  45   DC_DEBUG(("%p: Close()ing %p", this, mDataChannel.get()));
  46   mDataChannel->SetListener(nullptr, nullptr);
  47   mDataChannel->Close();
  48 }
  49
  50 /* virtual */
  51 JSObject* nsDOMDataChannel::WrapObject(JSContext* aCx,
  52                                        JS::Handle<JSObject*> aGivenProto) {
  53   return RTCDataChannel_Binding::Wrap(aCx, this, aGivenProto);
  54 }
  55
  56 NS_IMPL_CYCLE_COLLECTION_CLASS(nsDOMDataChannel)
  57
  58 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsDOMDataChannel,
  59                                                   DOMEventTargetHelper)
  60 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  61
  62 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsDOMDataChannel,
  63                                                 DOMEventTargetHelper)
  64 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  65
  66 NS_IMPL_ADDREF_INHERITED(nsDOMDataChannel, DOMEventTargetHelper)
  67 NS_IMPL_RELEASE_INHERITED(nsDOMDataChannel, DOMEventTargetHelper)
  68
  69 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsDOMDataChannel)
  70 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
  71
  72 nsDOMDataChannel::nsDOMDataChannel(
  73     already_AddRefed<mozilla::DataChannel>& aDataChannel,
  74     nsPIDOMWindowInner* aWindow)
  75     : DOMEventTargetHelper(aWindow),
  76       mDataChannel(aDataChannel),
  77       mBinaryType(DC_BINARY_TYPE_BLOB),
  78       mCheckMustKeepAlive(true),
  79       mSentClose(false) {}
  80
  81 nsresult nsDOMDataChannel::Init(nsPIDOMWindowInner* aDOMWindow) {
  82   nsresult rv;
  83   nsAutoString urlParam;
  84
  85   MOZ_ASSERT(mDataChannel);
  86   mDataChannel->SetListener(this, nullptr);
  87
  88   // Now grovel through the objects to get a usable origin for onMessage
  89   nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aDOMWindow);
  90   NS_ENSURE_STATE(sgo);
  91   nsCOMPtr<nsIScriptContext> scriptContext = sgo->GetContext();
  92   NS_ENSURE_STATE(scriptContext);
  93
  94   nsCOMPtr<nsIScriptObjectPrincipal> scriptPrincipal(
  95       do_QueryInterface(aDOMWindow));
  96   NS_ENSURE_STATE(scriptPrincipal);
  97   nsCOMPtr<nsIPrincipal> principal = scriptPrincipal->GetPrincipal();
  98   NS_ENSURE_STATE(principal);
  99
 100   // Attempt to kill "ghost" DataChannel (if one can happen): but usually too
 101   // early for check to fail
 102   rv = CheckCurrentGlobalCorrectness();
 103   NS_ENSURE_SUCCESS(rv, rv);
 104
 105   rv = nsContentUtils::GetWebExposedOriginSerialization(principal, mOrigin);
 106   DC_DEBUG(("%s: origin = %s\n", __FUNCTION__,
 107             NS_LossyConvertUTF16toASCII(mOrigin).get()));
 108   return rv;
 109 }
 110
 111 // Most of the GetFoo()/SetFoo()s don't need to touch shared resources and
 112 // are safe after Close()
 113 void nsDOMDataChannel::GetLabel(nsAString& aLabel) {
 114   mDataChannel->GetLabel(aLabel);
 115 }
 116
 117 void nsDOMDataChannel::GetProtocol(nsAString& aProtocol) {
 118   mDataChannel->GetProtocol(aProtocol);
 119 }
 120
 121 mozilla::dom::Nullable<uint16_t> nsDOMDataChannel::GetId() const {
 122   mozilla::dom::Nullable<uint16_t> result = mDataChannel->GetStream();
 123   if (result.Value() == 65535) {
 124     result.SetNull();
 125   }
 126   return result;
 127 }
 128
 129 // XXX should be GetType()?  Open question for the spec
 130 bool nsDOMDataChannel::Reliable() const {
 131   return mDataChannel->GetType() == mozilla::DataChannelConnection::RELIABLE;
 132 }
 133
 134 mozilla::dom::Nullable<uint16_t> nsDOMDataChannel::GetMaxPacketLifeTime()
 135     const {
 136   return mDataChannel->GetMaxPacketLifeTime();
 137 }
 138
 139 mozilla::dom::Nullable<uint16_t> nsDOMDataChannel::GetMaxRetransmits() const {
 140   return mDataChannel->GetMaxRetransmits();
 141 }
 142
 143 bool nsDOMDataChannel::Negotiated() const {
 144   return mDataChannel->GetNegotiated();
 145 }
 146
 147 bool nsDOMDataChannel::Ordered() const { return mDataChannel->GetOrdered(); }
 148
 149 RTCDataChannelState nsDOMDataChannel::ReadyState() const {
 150   return static_cast<RTCDataChannelState>(mDataChannel->GetReadyState());
 151 }
 152
 153 uint32_t nsDOMDataChannel::BufferedAmount() const {
 154   if (!mSentClose) {
 155     return mDataChannel->GetBufferedAmount();
 156   }
 157   return 0;
 158 }
 159
 160 uint32_t nsDOMDataChannel::BufferedAmountLowThreshold() const {
 161   return mDataChannel->GetBufferedAmountLowThreshold();
 162 }
 163
 164 void nsDOMDataChannel::SetBufferedAmountLowThreshold(uint32_t aThreshold) {
 165   mDataChannel->SetBufferedAmountLowThreshold(aThreshold);
 166 }
 167
 168 void nsDOMDataChannel::Close() {
 169   mDataChannel->Close();
 170   UpdateMustKeepAlive();
 171 }
 172
 173 // All of the following is copy/pasted from WebSocket.cpp.
 174 void nsDOMDataChannel::Send(const nsAString& aData, ErrorResult& aRv) {
 175   if (!CheckReadyState(aRv)) {
 176     return;
 177   }
 178
 179   nsAutoCString msgString;
 180   if (!AppendUTF16toUTF8(aData, msgString, mozilla::fallible_t())) {
 181     aRv.Throw(NS_ERROR_FILE_TOO_BIG);
 182     return;
 183   }
 184
 185   mDataChannel->SendMsg(msgString, aRv);
 186 }
 187
 188 void nsDOMDataChannel::Send(Blob& aData, ErrorResult& aRv) {
 189   MOZ_ASSERT(NS_IsMainThread(), "Not running on main thread");
 190
 191   if (!CheckReadyState(aRv)) {
 192     return;
 193   }
 194
 195   nsCOMPtr<nsIInputStream> msgStream;
 196   aData.CreateInputStream(getter_AddRefs(msgStream), aRv);
 197   if (NS_WARN_IF(aRv.Failed())) {
 198     return;
 199   }
 200
 201   uint64_t msgLength = aData.GetSize(aRv);
 202   if (NS_WARN_IF(aRv.Failed())) {
 203     return;
 204   }
 205
 206   if (msgLength > UINT32_MAX) {
 207     aRv.Throw(NS_ERROR_FILE_TOO_BIG);
 208     return;
 209   }
 210
 211   mDataChannel->SendBinaryBlob(aData, aRv);
 212 }
 213
 214 void nsDOMDataChannel::Send(const ArrayBuffer& aData, ErrorResult& aRv) {
 215   MOZ_ASSERT(NS_IsMainThread(), "Not running on main thread");
 216
 217   if (!CheckReadyState(aRv)) {
 218     return;
 219   }
 220
 221   nsCString msgString;
 222   if (!aData.AppendDataTo(msgString)) {
 223     aRv.Throw(NS_ERROR_FILE_TOO_BIG);
 224     return;
 225   }
 226
 227   mDataChannel->SendBinaryMsg(msgString, aRv);
 228 }
 229
 230 void nsDOMDataChannel::Send(const ArrayBufferView& aData, ErrorResult& aRv) {
 231   MOZ_ASSERT(NS_IsMainThread(), "Not running on main thread");
 232
 233   if (!CheckReadyState(aRv)) {
 234     return;
 235   }
 236
 237   nsCString msgString;
 238   if (!aData.AppendDataTo(msgString)) {
 239     aRv.Throw(NS_ERROR_FILE_TOO_BIG);
 240     return;
 241   }
 242
 243   mDataChannel->SendBinaryMsg(msgString, aRv);
 244 }
 245
 246 bool nsDOMDataChannel::CheckReadyState(ErrorResult& aRv) {
 247   MOZ_ASSERT(NS_IsMainThread());
 248   uint16_t state = mozilla::DataChannel::CLOSED;
 249   if (!mSentClose) {
 250     state = mDataChannel->GetReadyState();
 251   }
 252
 253   // In reality, the DataChannel protocol allows this, but we want it to
 254   // look like WebSockets
 255   if (state == mozilla::DataChannel::CONNECTING) {
 256     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
 257     return false;
 258   }
 259
 260   if (state == mozilla::DataChannel::CLOSING ||
 261       state == mozilla::DataChannel::CLOSED) {
 262     return false;
 263   }
 264
 265   MOZ_ASSERT(state == mozilla::DataChannel::OPEN,
 266              "Unknown state in nsDOMDataChannel::Send");
 267
 268   return true;
 269 }
 270
 271 nsresult nsDOMDataChannel::DoOnMessageAvailable(const nsACString& aData,
 272                                                 bool aBinary) {
 273   MOZ_ASSERT(NS_IsMainThread());
 274
 275   DC_VERBOSE((
 276       "DoOnMessageAvailable%s\n",
 277       aBinary ? ((mBinaryType == DC_BINARY_TYPE_BLOB) ? " (blob)" : " (binary)")
 278               : ""));
 279
 280   nsresult rv = CheckCurrentGlobalCorrectness();
 281   if (NS_FAILED(rv)) {
 282     return NS_OK;
 283   }
 284
 285   AutoJSAPI jsapi;
 286   if (NS_WARN_IF(!jsapi.Init(GetOwner()))) {
 287     return NS_ERROR_FAILURE;
 288   }
 289   JSContext* cx = jsapi.cx();
 290
 291   JS::Rooted<JS::Value> jsData(cx);
 292
 293   if (aBinary) {
 294     if (mBinaryType == DC_BINARY_TYPE_BLOB) {
 295       RefPtr<Blob> blob =
 296           Blob::CreateStringBlob(GetOwnerGlobal(), aData, u""_ns);
 297       if (NS_WARN_IF(!blob)) {
 298         return NS_ERROR_FAILURE;
 299       }
 300
 301       if (!ToJSValue(cx, blob, &jsData)) {
 302         return NS_ERROR_FAILURE;
 303       }
 304     } else if (mBinaryType == DC_BINARY_TYPE_ARRAYBUFFER) {
 305       JS::Rooted<JSObject*> arrayBuf(cx);
 306       rv = nsContentUtils::CreateArrayBuffer(cx, aData, arrayBuf.address());
 307       NS_ENSURE_SUCCESS(rv, rv);
 308       jsData.setObject(*arrayBuf);
 309     } else {
 310       MOZ_CRASH("Unknown binary type!");
 311       return NS_ERROR_UNEXPECTED;
 312     }
 313   } else {
 314     NS_ConvertUTF8toUTF16 utf16data(aData);
 315     JSString* jsString =
 316         JS_NewUCStringCopyN(cx, utf16data.get(), utf16data.Length());
 317     NS_ENSURE_TRUE(jsString, NS_ERROR_FAILURE);
 318
 319     jsData.setString(jsString);
 320   }
 321
 322   RefPtr<MessageEvent> event = new MessageEvent(this, nullptr, nullptr);
 323
 324   event->InitMessageEvent(nullptr, u"message"_ns, CanBubble::eNo,
 325                           Cancelable::eNo, jsData, mOrigin, u""_ns, nullptr,
 326                           Sequence<OwningNonNull<MessagePort>>());
 327   event->SetTrusted(true);
 328
 329   DC_DEBUG(
 330       ("%p(%p): %s - Dispatching\n", this, (void*)mDataChannel, __FUNCTION__));
 331   ErrorResult err;
 332   DispatchEvent(*event, err);
 333   if (err.Failed()) {
 334     DC_ERROR(("%p(%p): %s - Failed to dispatch message", this,
 335               (void*)mDataChannel, __FUNCTION__));
 336     NS_WARNING("Failed to dispatch the message event!!!");
 337   }
 338   return err.StealNSResult();
 339 }
 340
 341 nsresult nsDOMDataChannel::OnMessageAvailable(nsISupports* aContext,
 342                                               const nsACString& aMessage) {
 343   MOZ_ASSERT(NS_IsMainThread());
 344   return DoOnMessageAvailable(aMessage, false);
 345 }
 346
 347 nsresult nsDOMDataChannel::OnBinaryMessageAvailable(
 348     nsISupports* aContext, const nsACString& aMessage) {
 349   MOZ_ASSERT(NS_IsMainThread());
 350   return DoOnMessageAvailable(aMessage, true);
 351 }
 352
 353 nsresult nsDOMDataChannel::OnSimpleEvent(nsISupports* aContext,
 354                                          const nsAString& aName) {
 355   MOZ_ASSERT(NS_IsMainThread());
 356
 357   nsresult rv = CheckCurrentGlobalCorrectness();
 358   if (NS_FAILED(rv)) {
 359     return NS_OK;
 360   }
 361
 362   RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
 363
 364   event->InitEvent(aName, CanBubble::eNo, Cancelable::eNo);
 365   event->SetTrusted(true);
 366
 367   ErrorResult err;
 368   DispatchEvent(*event, err);
 369   return err.StealNSResult();
 370 }
 371
 372 nsresult nsDOMDataChannel::OnChannelConnected(nsISupports* aContext) {
 373   DC_DEBUG(
 374       ("%p(%p): %s - Dispatching\n", this, (void*)mDataChannel, __FUNCTION__));
 375
 376   return OnSimpleEvent(aContext, u"open"_ns);
 377 }
 378
 379 nsresult nsDOMDataChannel::OnChannelClosed(nsISupports* aContext) {
 380   nsresult rv;
 381   // so we don't have to worry if we're notified from different paths in
 382   // the underlying code
 383   if (!mSentClose) {
 384     // Ok, we're done with it.
 385     mDataChannel->ReleaseConnection();
 386     DC_DEBUG(("%p(%p): %s - Dispatching\n", this, (void*)mDataChannel,
 387               __FUNCTION__));
 388
 389     rv = OnSimpleEvent(aContext, u"close"_ns);
 390     // no more events can happen
 391     mSentClose = true;
 392   } else {
 393     rv = NS_OK;
 394   }
 395   DontKeepAliveAnyMore();
 396   return rv;
 397 }
 398
 399 nsresult nsDOMDataChannel::OnBufferLow(nsISupports* aContext) {
 400   DC_DEBUG(
 401       ("%p(%p): %s - Dispatching\n", this, (void*)mDataChannel, __FUNCTION__));
 402
 403   return OnSimpleEvent(aContext, u"bufferedamountlow"_ns);
 404 }
 405
 406 nsresult nsDOMDataChannel::NotBuffered(nsISupports* aContext) {
 407   // In the rare case that we held off GC to let the buffer drain
 408   UpdateMustKeepAlive();
 409   return NS_OK;
 410 }
 411
 412 //-----------------------------------------------------------------------------
 413 // Methods that keep alive the DataChannel object when:
 414 //   1. the object has registered event listeners that can be triggered
 415 //      ("strong event listeners");
 416 //   2. there are outgoing not sent messages.
 417 //-----------------------------------------------------------------------------
 418
 419 void nsDOMDataChannel::UpdateMustKeepAlive() {
 420   MOZ_ASSERT(NS_IsMainThread());
 421
 422   if (!mCheckMustKeepAlive) {
 423     return;
 424   }
 425
 426   bool shouldKeepAlive = false;
 427   uint16_t readyState = mDataChannel->GetReadyState();
 428
 429   switch (readyState) {
 430     case DataChannel::CONNECTING: {
 431       if (mListenerManager &&
 432           (mListenerManager->HasListenersFor(nsGkAtoms::onopen) ||
 433            mListenerManager->HasListenersFor(nsGkAtoms::onmessage) ||
 434            mListenerManager->HasListenersFor(nsGkAtoms::onerror) ||
 435            mListenerManager->HasListenersFor(nsGkAtoms::onbufferedamountlow) ||
 436            mListenerManager->HasListenersFor(nsGkAtoms::onclose))) {
 437         shouldKeepAlive = true;
 438       }
 439     } break;
 440
 441     case DataChannel::OPEN:
 442     case DataChannel::CLOSING: {
 443       if (mDataChannel->GetBufferedAmount() != 0 ||
 444           (mListenerManager &&
 445            (mListenerManager->HasListenersFor(nsGkAtoms::onmessage) ||
 446             mListenerManager->HasListenersFor(nsGkAtoms::onerror) ||
 447             mListenerManager->HasListenersFor(nsGkAtoms::onbufferedamountlow) ||
 448             mListenerManager->HasListenersFor(nsGkAtoms::onclose)))) {
 449         shouldKeepAlive = true;
 450       }
 451     } break;
 452
 453     case DataChannel::CLOSED: {
 454       shouldKeepAlive = false;
 455     }
 456   }
 457
 458   if (mSelfRef && !shouldKeepAlive) {
 459     ReleaseSelf();
 460   } else if (!mSelfRef && shouldKeepAlive) {
 461     mSelfRef = this;
 462   }
 463 }
 464
 465 void nsDOMDataChannel::DontKeepAliveAnyMore() {
 466   MOZ_ASSERT(NS_IsMainThread());
 467
 468   if (mSelfRef) {
 469     // Since we're on MainThread, force an eventloop trip to avoid deleting
 470     // ourselves.
 471     ReleaseSelf();
 472   }
 473
 474   mCheckMustKeepAlive = false;
 475 }
 476
 477 void nsDOMDataChannel::ReleaseSelf() {
 478   // release our self-reference (safely) by putting it in an event (always)
 479   NS_ReleaseOnMainThread("nsDOMDataChannel::mSelfRef", mSelfRef.forget(), true);
 480 }
 481
 482 void nsDOMDataChannel::EventListenerAdded(nsAtom* aType) {
 483   MOZ_ASSERT(NS_IsMainThread());
 484   UpdateMustKeepAlive();
 485 }
 486
 487 void nsDOMDataChannel::EventListenerRemoved(nsAtom* aType) {
 488   MOZ_ASSERT(NS_IsMainThread());
 489   UpdateMustKeepAlive();
 490 }
 491
 492 /* static */
 493 nsresult NS_NewDOMDataChannel(
 494     already_AddRefed<mozilla::DataChannel>&& aDataChannel,
 495     nsPIDOMWindowInner* aWindow, nsDOMDataChannel** aDomDataChannel) {
 496   RefPtr<nsDOMDataChannel> domdc = new nsDOMDataChannel(aDataChannel, aWindow);
 497
 498   nsresult rv = domdc->Init(aWindow);
 499   NS_ENSURE_SUCCESS(rv, rv);
 500
 501   domdc.forget(aDomDataChannel);
 502   return NS_OK;
 503 }