dom/network/UDPSocket.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 "UDPSocket.h"
   8 #include "mozilla/AsyncEventDispatcher.h"
   9 #include "mozilla/dom/File.h"
  10 #include "mozilla/dom/ErrorEvent.h"
  11 #include "mozilla/dom/network/UDPSocketChild.h"
  12 #include "mozilla/dom/UDPMessageEvent.h"
  13 #include "mozilla/dom/UDPSocketBinding.h"
  14 #include "mozilla/dom/UnionTypes.h"
  15 #include "mozilla/dom/RootedDictionary.h"
  16 #include "mozilla/net/DNS.h"
  17 #include "nsComponentManagerUtils.h"
  18 #include "nsContentUtils.h"
  19 #include "nsINetAddr.h"
  20 #include "nsStringStream.h"
  21
  22 namespace mozilla::dom {
  23
  24 NS_IMPL_ISUPPORTS(UDPSocket::ListenerProxy, nsIUDPSocketListener,
  25                   nsIUDPSocketInternal)
  26
  27 NS_IMPL_CYCLE_COLLECTION_CLASS(UDPSocket)
  28
  29 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(UDPSocket,
  30                                                   DOMEventTargetHelper)
  31   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOpened)
  32   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mClosed)
  33 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  34
  35 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(UDPSocket, DOMEventTargetHelper)
  36   NS_IMPL_CYCLE_COLLECTION_UNLINK(mOpened)
  37   NS_IMPL_CYCLE_COLLECTION_UNLINK(mClosed)
  38   tmp->CloseWithReason(NS_OK);
  39 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  40
  41 NS_IMPL_ADDREF_INHERITED(UDPSocket, DOMEventTargetHelper)
  42 NS_IMPL_RELEASE_INHERITED(UDPSocket, DOMEventTargetHelper)
  43
  44 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(UDPSocket)
  45   NS_INTERFACE_MAP_ENTRY(nsIUDPSocketListener)
  46   NS_INTERFACE_MAP_ENTRY(nsIUDPSocketInternal)
  47 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
  48
  49 /* static */
  50 already_AddRefed<UDPSocket> UDPSocket::Constructor(const GlobalObject& aGlobal,
  51                                                    const UDPOptions& aOptions,
  52                                                    ErrorResult& aRv) {
  53   nsCOMPtr<nsPIDOMWindowInner> ownerWindow =
  54       do_QueryInterface(aGlobal.GetAsSupports());
  55   if (!ownerWindow) {
  56     aRv.Throw(NS_ERROR_FAILURE);
  57     return nullptr;
  58   }
  59
  60   bool addressReuse = aOptions.mAddressReuse;
  61   bool loopback = aOptions.mLoopback;
  62
  63   nsCString remoteAddress;
  64   if (aOptions.mRemoteAddress.WasPassed()) {
  65     CopyUTF16toUTF8(aOptions.mRemoteAddress.Value(), remoteAddress);
  66   } else {
  67     remoteAddress.SetIsVoid(true);
  68   }
  69
  70   Nullable<uint16_t> remotePort;
  71   if (aOptions.mRemotePort.WasPassed()) {
  72     remotePort.SetValue(aOptions.mRemotePort.Value());
  73
  74     if (remotePort.Value() == 0) {
  75       aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
  76       return nullptr;
  77     }
  78   }
  79
  80   nsString localAddress;
  81   if (aOptions.mLocalAddress.WasPassed()) {
  82     localAddress = aOptions.mLocalAddress.Value();
  83
  84     // check if localAddress is a valid IPv4/6 address
  85     NS_ConvertUTF16toUTF8 address(localAddress);
  86     if (!net::HostIsIPLiteral(address)) {
  87       aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
  88       return nullptr;
  89     }
  90   } else {
  91     SetDOMStringToNull(localAddress);
  92   }
  93
  94   Nullable<uint16_t> localPort;
  95   if (aOptions.mLocalPort.WasPassed()) {
  96     localPort.SetValue(aOptions.mLocalPort.Value());
  97
  98     if (localPort.Value() == 0) {
  99       aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
 100       return nullptr;
 101     }
 102   }
 103
 104   RefPtr<UDPSocket> socket =
 105       new UDPSocket(ownerWindow, remoteAddress, remotePort);
 106   aRv = socket->Init(localAddress, localPort, addressReuse, loopback);
 107
 108   if (NS_WARN_IF(aRv.Failed())) {
 109     return nullptr;
 110   }
 111
 112   return socket.forget();
 113 }
 114
 115 UDPSocket::UDPSocket(nsPIDOMWindowInner* aOwner,
 116                      const nsCString& aRemoteAddress,
 117                      const Nullable<uint16_t>& aRemotePort)
 118     : DOMEventTargetHelper(aOwner),
 119       mRemoteAddress(aRemoteAddress),
 120       mRemotePort(aRemotePort),
 121       mAddressReuse(false),
 122       mLoopback(false),
 123       mReadyState(SocketReadyState::Opening) {
 124   MOZ_ASSERT(aOwner);
 125
 126   Document* aDoc = aOwner->GetExtantDoc();
 127   if (aDoc) {
 128     aDoc->DisallowBFCaching();
 129   }
 130 }
 131
 132 UDPSocket::~UDPSocket() { CloseWithReason(NS_OK); }
 133
 134 JSObject* UDPSocket::WrapObject(JSContext* aCx,
 135                                 JS::Handle<JSObject*> aGivenProto) {
 136   return UDPSocket_Binding::Wrap(aCx, this, aGivenProto);
 137 }
 138
 139 void UDPSocket::DisconnectFromOwner() {
 140   DOMEventTargetHelper::DisconnectFromOwner();
 141   CloseWithReason(NS_OK);
 142 }
 143
 144 already_AddRefed<Promise> UDPSocket::Close() {
 145   MOZ_ASSERT(mClosed);
 146
 147   RefPtr<Promise> promise = mClosed;
 148
 149   if (mReadyState == SocketReadyState::Closed) {
 150     return promise.forget();
 151   }
 152
 153   CloseWithReason(NS_OK);
 154   return promise.forget();
 155 }
 156
 157 void UDPSocket::CloseWithReason(nsresult aReason) {
 158   if (mReadyState == SocketReadyState::Closed) {
 159     return;
 160   }
 161
 162   if (mOpened) {
 163     if (mReadyState == SocketReadyState::Opening) {
 164       // reject openedPromise with AbortError if socket is closed without error
 165       nsresult openFailedReason =
 166           NS_FAILED(aReason) ? aReason : NS_ERROR_DOM_ABORT_ERR;
 167       mOpened->MaybeReject(openFailedReason);
 168     }
 169   }
 170
 171   mReadyState = SocketReadyState::Closed;
 172
 173   if (mListenerProxy) {
 174     mListenerProxy->Disconnect();
 175     mListenerProxy = nullptr;
 176   }
 177
 178   if (mSocket) {
 179     mSocket->Close();
 180     mSocket = nullptr;
 181   }
 182
 183   if (mSocketChild) {
 184     mSocketChild->Close();
 185     mSocketChild = nullptr;
 186   }
 187
 188   if (mClosed) {
 189     if (NS_SUCCEEDED(aReason)) {
 190       mClosed->MaybeResolveWithUndefined();
 191     } else {
 192       mClosed->MaybeReject(aReason);
 193     }
 194   }
 195
 196   mPendingMcastCommands.Clear();
 197 }
 198
 199 void UDPSocket::JoinMulticastGroup(const nsAString& aMulticastGroupAddress,
 200                                    ErrorResult& aRv) {
 201   if (mReadyState == SocketReadyState::Closed) {
 202     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
 203     return;
 204   }
 205
 206   if (mReadyState == SocketReadyState::Opening) {
 207     MulticastCommand joinCommand(MulticastCommand::Join,
 208                                  aMulticastGroupAddress);
 209     mPendingMcastCommands.AppendElement(joinCommand);
 210     return;
 211   }
 212
 213   MOZ_ASSERT(mSocket || mSocketChild);
 214
 215   NS_ConvertUTF16toUTF8 address(aMulticastGroupAddress);
 216
 217   if (mSocket) {
 218     MOZ_ASSERT(!mSocketChild);
 219
 220     aRv = mSocket->JoinMulticast(address, ""_ns);
 221     NS_WARNING_ASSERTION(!aRv.Failed(), "JoinMulticast failed");
 222
 223     return;
 224   }
 225
 226   MOZ_ASSERT(mSocketChild);
 227
 228   mSocketChild->JoinMulticast(address, ""_ns);
 229 }
 230
 231 void UDPSocket::LeaveMulticastGroup(const nsAString& aMulticastGroupAddress,
 232                                     ErrorResult& aRv) {
 233   if (mReadyState == SocketReadyState::Closed) {
 234     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
 235     return;
 236   }
 237
 238   if (mReadyState == SocketReadyState::Opening) {
 239     MulticastCommand leaveCommand(MulticastCommand::Leave,
 240                                   aMulticastGroupAddress);
 241     mPendingMcastCommands.AppendElement(leaveCommand);
 242     return;
 243   }
 244
 245   MOZ_ASSERT(mSocket || mSocketChild);
 246
 247   nsCString address = NS_ConvertUTF16toUTF8(aMulticastGroupAddress);
 248   if (mSocket) {
 249     MOZ_ASSERT(!mSocketChild);
 250
 251     aRv = mSocket->LeaveMulticast(address, ""_ns);
 252     NS_WARNING_ASSERTION(!aRv.Failed(), "mSocket->LeaveMulticast failed");
 253     return;
 254   }
 255
 256   MOZ_ASSERT(mSocketChild);
 257
 258   mSocketChild->LeaveMulticast(address, ""_ns);
 259 }
 260
 261 nsresult UDPSocket::DoPendingMcastCommand() {
 262   MOZ_ASSERT(mReadyState == SocketReadyState::Open,
 263              "Multicast command can only be executed after socket opened");
 264
 265   for (uint32_t i = 0; i < mPendingMcastCommands.Length(); ++i) {
 266     MulticastCommand& command = mPendingMcastCommands[i];
 267     ErrorResult rv;
 268
 269     switch (command.mCommand) {
 270       case MulticastCommand::Join: {
 271         JoinMulticastGroup(command.mAddress, rv);
 272         break;
 273       }
 274       case MulticastCommand::Leave: {
 275         LeaveMulticastGroup(command.mAddress, rv);
 276         break;
 277       }
 278     }
 279
 280     if (NS_WARN_IF(rv.Failed())) {
 281       return rv.StealNSResult();
 282     }
 283   }
 284
 285   mPendingMcastCommands.Clear();
 286   return NS_OK;
 287 }
 288
 289 bool UDPSocket::Send(const StringOrBlobOrArrayBufferOrArrayBufferView& aData,
 290                      const Optional<nsAString>& aRemoteAddress,
 291                      const Optional<Nullable<uint16_t>>& aRemotePort,
 292                      ErrorResult& aRv) {
 293   if (mReadyState != SocketReadyState::Open) {
 294     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
 295     return false;
 296   }
 297
 298   MOZ_ASSERT(mSocket || mSocketChild);
 299
 300   // If the remote address and port were not specified in the constructor or as
 301   // arguments, throw InvalidAccessError.
 302   nsCString remoteAddress;
 303   if (aRemoteAddress.WasPassed()) {
 304     CopyUTF16toUTF8(aRemoteAddress.Value(), remoteAddress);
 305     UDPSOCKET_LOG(("%s: Send to %s", __FUNCTION__, remoteAddress.get()));
 306   } else if (!mRemoteAddress.IsVoid()) {
 307     remoteAddress = mRemoteAddress;
 308     UDPSOCKET_LOG(("%s: Send to %s", __FUNCTION__, remoteAddress.get()));
 309   } else {
 310     aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
 311     return false;
 312   }
 313
 314   uint16_t remotePort;
 315   if (aRemotePort.WasPassed() && !aRemotePort.Value().IsNull()) {
 316     remotePort = aRemotePort.Value().Value();
 317   } else if (!mRemotePort.IsNull()) {
 318     remotePort = mRemotePort.Value();
 319   } else {
 320     aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
 321     return false;
 322   }
 323
 324   nsCOMPtr<nsIInputStream> stream;
 325   if (aData.IsBlob()) {
 326     Blob& blob = aData.GetAsBlob();
 327
 328     blob.CreateInputStream(getter_AddRefs(stream), aRv);
 329     if (NS_WARN_IF(aRv.Failed())) {
 330       return false;
 331     }
 332   } else {
 333     nsresult rv;
 334     nsCOMPtr<nsIStringInputStream> strStream =
 335         do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID, &rv);
 336     if (NS_WARN_IF(NS_FAILED(rv))) {
 337       aRv.Throw(rv);
 338       return false;
 339     }
 340
 341     if (aData.IsString()) {
 342       NS_ConvertUTF16toUTF8 data(aData.GetAsString());
 343       aRv = strStream->SetData(data.BeginReading(), data.Length());
 344     } else {
 345       Vector<char> data;
 346       if (!AppendTypedArrayDataTo(aData, data)) {
 347         aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
 348         return false;
 349       }
 350       size_t length = data.length();
 351       aRv = strStream->AdoptData(data.extractOrCopyRawBuffer(), length);
 352     }
 353
 354     if (NS_WARN_IF(aRv.Failed())) {
 355       return false;
 356     }
 357
 358     stream = strStream;
 359   }
 360
 361   if (mSocket) {
 362     aRv = mSocket->SendBinaryStream(remoteAddress, remotePort, stream);
 363   } else if (mSocketChild) {
 364     aRv = mSocketChild->SendBinaryStream(remoteAddress, remotePort, stream);
 365   }
 366
 367   if (NS_WARN_IF(aRv.Failed())) {
 368     return false;
 369   }
 370
 371   return true;
 372 }
 373
 374 nsresult UDPSocket::InitLocal(const nsAString& aLocalAddress,
 375                               const uint16_t& aLocalPort) {
 376   nsresult rv;
 377   nsCOMPtr<nsIUDPSocket> sock =
 378       do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
 379   if (NS_FAILED(rv)) {
 380     return rv;
 381   }
 382
 383   nsCOMPtr<nsIGlobalObject> global = GetOwnerGlobal();
 384   if (!global) {
 385     return NS_ERROR_FAILURE;
 386   }
 387
 388   nsCOMPtr<nsIPrincipal> principal = global->PrincipalOrNull();
 389   if (!principal) {
 390     return NS_ERROR_FAILURE;
 391   }
 392
 393   if (aLocalAddress.IsEmpty()) {
 394     rv = sock->Init(aLocalPort, /* loopback = */ false, principal,
 395                     mAddressReuse, /* optionalArgc = */ 1);
 396   } else {
 397     PRNetAddr prAddr;
 398     PR_InitializeNetAddr(PR_IpAddrAny, aLocalPort, &prAddr);
 399     PR_StringToNetAddr(NS_ConvertUTF16toUTF8(aLocalAddress).BeginReading(),
 400                        &prAddr);
 401     UDPSOCKET_LOG(("%s: %s:%u", __FUNCTION__,
 402                    NS_ConvertUTF16toUTF8(aLocalAddress).get(), aLocalPort));
 403
 404     mozilla::net::NetAddr addr(&prAddr);
 405     rv = sock->InitWithAddress(&addr, principal, mAddressReuse,
 406                                /* optionalArgc = */ 1);
 407   }
 408   if (NS_FAILED(rv)) {
 409     return rv;
 410   }
 411
 412   rv = sock->SetMulticastLoopback(mLoopback);
 413   if (NS_FAILED(rv)) {
 414     return rv;
 415   }
 416
 417   mSocket = sock;
 418
 419   // Get real local address and local port
 420   nsCOMPtr<nsINetAddr> localAddr;
 421   rv = mSocket->GetLocalAddr(getter_AddRefs(localAddr));
 422   if (NS_FAILED(rv)) {
 423     return rv;
 424   }
 425
 426   nsCString localAddress;
 427   rv = localAddr->GetAddress(localAddress);
 428   if (NS_FAILED(rv)) {
 429     return rv;
 430   }
 431   CopyUTF8toUTF16(localAddress, mLocalAddress);
 432
 433   uint16_t localPort;
 434   rv = localAddr->GetPort(&localPort);
 435   if (NS_FAILED(rv)) {
 436     return rv;
 437   }
 438   mLocalPort.SetValue(localPort);
 439
 440   mListenerProxy = new ListenerProxy(this);
 441
 442   rv = mSocket->AsyncListen(mListenerProxy);
 443   if (NS_FAILED(rv)) {
 444     return rv;
 445   }
 446
 447   mReadyState = SocketReadyState::Open;
 448   rv = DoPendingMcastCommand();
 449   if (NS_FAILED(rv)) {
 450     return rv;
 451   }
 452
 453   mOpened->MaybeResolveWithUndefined();
 454
 455   return NS_OK;
 456 }
 457
 458 nsresult UDPSocket::InitRemote(const nsAString& aLocalAddress,
 459                                const uint16_t& aLocalPort) {
 460   RefPtr<UDPSocketChild> sock = new UDPSocketChild();
 461
 462   mListenerProxy = new ListenerProxy(this);
 463
 464   nsCOMPtr<nsIGlobalObject> global = GetOwnerGlobal();
 465   if (!global) {
 466     return NS_ERROR_FAILURE;
 467   }
 468
 469   nsCOMPtr<nsIPrincipal> principal = global->PrincipalOrNull();
 470   if (!principal) {
 471     return NS_ERROR_FAILURE;
 472   }
 473
 474   nsresult rv = sock->Bind(mListenerProxy, principal,
 475                            NS_ConvertUTF16toUTF8(aLocalAddress), aLocalPort,
 476                            mAddressReuse, mLoopback, 0, 0);
 477
 478   if (NS_FAILED(rv)) {
 479     return rv;
 480   }
 481
 482   mSocketChild = sock;
 483
 484   return NS_OK;
 485 }
 486
 487 nsresult UDPSocket::Init(const nsString& aLocalAddress,
 488                          const Nullable<uint16_t>& aLocalPort,
 489                          const bool& aAddressReuse, const bool& aLoopback) {
 490   MOZ_ASSERT(!mSocket && !mSocketChild);
 491
 492   mLocalAddress = aLocalAddress;
 493   mLocalPort = aLocalPort;
 494   mAddressReuse = aAddressReuse;
 495   mLoopback = aLoopback;
 496
 497   nsCOMPtr<nsIGlobalObject> global = GetOwnerGlobal();
 498
 499   ErrorResult rv;
 500   mOpened = Promise::Create(global, rv);
 501   if (NS_WARN_IF(rv.Failed())) {
 502     return rv.StealNSResult();
 503   }
 504
 505   mClosed = Promise::Create(global, rv);
 506   if (NS_WARN_IF(rv.Failed())) {
 507     return rv.StealNSResult();
 508   }
 509
 510   class OpenSocketRunnable final : public Runnable {
 511    public:
 512     explicit OpenSocketRunnable(UDPSocket* aSocket)
 513         : mozilla::Runnable("OpenSocketRunnable"), mSocket(aSocket) {}
 514
 515     NS_IMETHOD Run() override {
 516       MOZ_ASSERT(mSocket);
 517
 518       if (mSocket->mReadyState != SocketReadyState::Opening) {
 519         return NS_OK;
 520       }
 521
 522       uint16_t localPort = 0;
 523       if (!mSocket->mLocalPort.IsNull()) {
 524         localPort = mSocket->mLocalPort.Value();
 525       }
 526
 527       nsresult rv;
 528       if (!XRE_IsParentProcess()) {
 529         rv = mSocket->InitRemote(mSocket->mLocalAddress, localPort);
 530       } else {
 531         rv = mSocket->InitLocal(mSocket->mLocalAddress, localPort);
 532       }
 533
 534       if (NS_WARN_IF(NS_FAILED(rv))) {
 535         mSocket->CloseWithReason(NS_ERROR_DOM_NETWORK_ERR);
 536       }
 537
 538       return NS_OK;
 539     }
 540
 541    private:
 542     RefPtr<UDPSocket> mSocket;
 543   };
 544
 545   nsCOMPtr<nsIRunnable> runnable = new OpenSocketRunnable(this);
 546
 547   return NS_DispatchToMainThread(runnable);
 548 }
 549
 550 void UDPSocket::HandleReceivedData(const nsACString& aRemoteAddress,
 551                                    const uint16_t& aRemotePort,
 552                                    const nsTArray<uint8_t>& aData) {
 553   if (mReadyState != SocketReadyState::Open) {
 554     return;
 555   }
 556
 557   if (NS_FAILED(CheckCurrentGlobalCorrectness())) {
 558     return;
 559   }
 560
 561   if (NS_FAILED(DispatchReceivedData(aRemoteAddress, aRemotePort, aData))) {
 562     CloseWithReason(NS_ERROR_UNEXPECTED);
 563   }
 564 }
 565
 566 nsresult UDPSocket::DispatchReceivedData(const nsACString& aRemoteAddress,
 567                                          const uint16_t& aRemotePort,
 568                                          const nsTArray<uint8_t>& aData) {
 569   AutoJSAPI jsapi;
 570
 571   if (NS_WARN_IF(!jsapi.Init(GetOwnerWindow()))) {
 572     return NS_ERROR_FAILURE;
 573   }
 574
 575   JSContext* cx = jsapi.cx();
 576
 577   // Copy packet data to ArrayBuffer
 578   ErrorResult error;
 579   JS::Rooted<JSObject*> arrayBuf(cx, ArrayBuffer::Create(cx, aData, error));
 580
 581   if (NS_WARN_IF(error.Failed())) {
 582     return error.StealNSResult();
 583   }
 584
 585   JS::Rooted<JS::Value> jsData(cx, JS::ObjectValue(*arrayBuf));
 586
 587   // Create DOM event
 588   RootedDictionary<UDPMessageEventInit> init(cx);
 589   CopyUTF8toUTF16(aRemoteAddress, init.mRemoteAddress);
 590   init.mRemotePort = aRemotePort;
 591   init.mData = jsData;
 592
 593   RefPtr<UDPMessageEvent> udpEvent =
 594       UDPMessageEvent::Constructor(this, u"message"_ns, init);
 595
 596   if (NS_WARN_IF(!udpEvent)) {
 597     return NS_ERROR_FAILURE;
 598   }
 599
 600   udpEvent->SetTrusted(true);
 601
 602   RefPtr<AsyncEventDispatcher> asyncDispatcher =
 603       new AsyncEventDispatcher(this, udpEvent.forget());
 604
 605   return asyncDispatcher->PostDOMEvent();
 606 }
 607
 608 // nsIUDPSocketListener
 609
 610 NS_IMETHODIMP
 611 UDPSocket::OnPacketReceived(nsIUDPSocket* aSocket, nsIUDPMessage* aMessage) {
 612   // nsIUDPSocketListener callbacks should be invoked on main thread.
 613   MOZ_ASSERT(NS_IsMainThread(), "Not running on main thread");
 614
 615   // Create appropriate JS object for message
 616   FallibleTArray<uint8_t>& buffer = aMessage->GetDataAsTArray();
 617
 618   nsCOMPtr<nsINetAddr> addr;
 619   if (NS_WARN_IF(NS_FAILED(aMessage->GetFromAddr(getter_AddRefs(addr))))) {
 620     return NS_OK;
 621   }
 622
 623   nsCString remoteAddress;
 624   if (NS_WARN_IF(NS_FAILED(addr->GetAddress(remoteAddress)))) {
 625     return NS_OK;
 626   }
 627
 628   uint16_t remotePort;
 629   if (NS_WARN_IF(NS_FAILED(addr->GetPort(&remotePort)))) {
 630     return NS_OK;
 631   }
 632
 633   HandleReceivedData(remoteAddress, remotePort, buffer);
 634   return NS_OK;
 635 }
 636
 637 NS_IMETHODIMP
 638 UDPSocket::OnStopListening(nsIUDPSocket* aSocket, nsresult aStatus) {
 639   // nsIUDPSocketListener callbacks should be invoked on main thread.
 640   MOZ_ASSERT(NS_IsMainThread(), "Not running on main thread");
 641
 642   CloseWithReason(aStatus);
 643
 644   return NS_OK;
 645 }
 646
 647 // nsIUDPSocketInternal
 648
 649 NS_IMETHODIMP
 650 UDPSocket::CallListenerError(const nsACString& aMessage,
 651                              const nsACString& aFilename,
 652                              uint32_t aLineNumber) {
 653   CloseWithReason(NS_ERROR_DOM_NETWORK_ERR);
 654
 655   return NS_OK;
 656 }
 657
 658 NS_IMETHODIMP
 659 UDPSocket::CallListenerReceivedData(const nsACString& aRemoteAddress,
 660                                     uint16_t aRemotePort,
 661                                     const nsTArray<uint8_t>& aData) {
 662   HandleReceivedData(aRemoteAddress, aRemotePort, aData);
 663
 664   return NS_OK;
 665 }
 666
 667 NS_IMETHODIMP
 668 UDPSocket::CallListenerOpened() {
 669   if (mReadyState != SocketReadyState::Opening) {
 670     return NS_OK;
 671   }
 672
 673   MOZ_ASSERT(mSocketChild);
 674
 675   // Get real local address and local port
 676   CopyUTF8toUTF16(mSocketChild->LocalAddress(), mLocalAddress);
 677
 678   mLocalPort.SetValue(mSocketChild->LocalPort());
 679
 680   mReadyState = SocketReadyState::Open;
 681   nsresult rv = DoPendingMcastCommand();
 682
 683   if (NS_WARN_IF(NS_FAILED(rv))) {
 684     CloseWithReason(rv);
 685     return NS_OK;
 686   }
 687
 688   mOpened->MaybeResolveWithUndefined();
 689
 690   return NS_OK;
 691 }
 692
 693 NS_IMETHODIMP
 694 UDPSocket::CallListenerConnected() {
 695   // This shouldn't be called here.
 696   MOZ_CRASH();
 697
 698   return NS_OK;
 699 }
 700
 701 NS_IMETHODIMP
 702 UDPSocket::CallListenerClosed() {
 703   CloseWithReason(NS_OK);
 704
 705   return NS_OK;
 706 }
 707
 708 }  // namespace mozilla::dom