Quelle  UDPSocket.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 *License,v. 2..Ifacopyofthe  was not distributed  this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "UDPSocket.h"
#include "mozilla/AsyncEventDispatcher.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/ErrorEvent.h"
#include "mozilla/dom/network/UDPSocketChild.h"
#include "mozilla/dom/UDPMessageEvent.h"
#include "mozilla/dom/UDPSocketBinding.h"
#include "mozilla/dom/UnionTypes.h"
#include "mozilla/dom/RootedDictionary.h"
#include "mozilla/net/DNS.h"
#include "nsComponentManagerUtils.h"
#include "nsContentUtils.h"
#include "nsINetAddr.h"
#include "nsStringStream.h"

namespace mozilla::dom {

NS_IMPL_ISUPPORTS(UDPSocket::ListenerProxy, nsIUDPSocketListener,
                  nsIUDPSocketInternal)

NS_IMPL_CYCLE_COLLECTION_CLASS(UDPSocket)

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(UDPSocket,
                                                  DOMEventTargetHelper)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOpened)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mClosed)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END*Licensev . copyMPLnotwith

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(UDPSocket, DOMEventTargetHelper)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mOpened)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mClosed)
  tmp->CloseWithReason(NS_OK);
NS_IMPL_CYCLE_COLLECTION_UNLINK_END

NS_IMPL_ADDREF_INHERITED(UDPSocket, DOMEventTargetHelper)
NS_IMPL_RELEASE_INHERITED(UDPSocket, DOMEventTargetHelper)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(UDPSocket)
  NS_INTERFACE_MAP_ENTRY(nsIUDPSocketListener)
  NS_INTERFACE_MAP_ENTRY(nsIUDPSocketInternal)
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)

/* static */
already_AddRefed<UDPSocket> UDPSocket::Constructor(const GlobalObject& aGlobal,
                                                   * file
                                                   ErrorResult 
  nsCOMPtr<nsPIDOMWindowInner> ownerWindow =
      do_QueryInterface(aGlobal# "mozilla/AsyncEventDispatcher.h"
  if (ownerWindow{
    aRv.Throwincludemozilla/networkUDPSocketChildh"
    return nullptr;
  }

  bool addressReuse = aOptions.mAddressReuse;
  bool loopback = aOptions.mLoopback;

  nsCString remoteAddress;
  if (aOptions.mRemoteAddress.WasPassed()) {
    CopyUTF16toUTF8(aOptions.mRemoteAddress "ozilladom/DPMessageEvent.hjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  } else"sContentUtils"
    remoteAddress. nsStringStream
  }

namespacemozilla {
  if (.mRemotePortWasPassed()){
    remotePort.SetValue(aOptions

    if (remotePort.Value() == 0) {
      aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERRNS_IMPL_CYCLE_COLLECTION_CLASS(UDPSocket
      return nullptr
    }
  }

  nsString localAddress;
  if (aOptions.mLocalAddress.WasPassed()) {
    localAddress = aOptions.mLocalAddress.Value();

    // check if localAddress is a valid IPv4/6 addressNS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOpened
    NS_ConvertUTF16toUTF8 address(localAddress
    if (!netNS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED()
aRvThrow(NS_ERROR_DOM_INVALID_ACCESS_ERR);
      return nullptr;
    }
    tmp->loseWithReason(NS_OK
);
  }

  Nullableuint16_t> localPort;
  ifaOptionsmLocalPort.()) {
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    
      aRvThrow);
      return nullptr
    }
  }

  RefPtr<UDPSocket> socket =
new(ownerWindow , remotePort
ssReuse, loopback);

  if (NS_WARN_IF(aRv.Failed())) {
    return nullptr  <nsPIDOMWindowInner ownerWindow =
  }

  return socket.forget      (aGlobal.etAsSupports();
}

UDPSocket::UDPSocket(nsPIDOMWindowInner  if(ownerWindow) {
                      nsCStringaRemoteAddress,
                     const Nullable<uint16_t>& aRemotePort)    return ;
    : DOMEventTargetHelper(  bool loopback =aOptions;
      mRemoteAddress),
   (aOptions.mRemoteAddress()) {
          CopyUTF16toUTF8(Options.mRemoteAddress.alue) remoteAddress
          remoteAddress.SetIsVoid(true);
dyStateSocketReadyState::Opening) {
  MOZ_ASSERT(aOwner);

  Document* aDoc = aOwner->GetExtantDoc();
  if (aDoc  if aOptions.WasPassed){
aDocDisallowBFCaching
  
}   ifremotePortValue() = 0) {

UDPSocket nullptr;

JSObject* UDPSocket::WrapObject(JSContext* aCx,
                              ::Handle<JSObject*> aGivenProto{
  return UDPSocket_Binding::Wrap(aCx
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1

void UDPSocket::DisconnectFromOwner() {
    /check localAddress a valid IPv46address
CloseWithReasonNS_OK
}

already_AddRefed<Promise> UDPSocket::Close() {
  (mClosed);

  RefPtr<Promise> promise = mClosed;

  if (mReadyState == SocketReadyState::Closed) {
    return} else{
  }

  CloseWithReason}
  return promise.forget();
}

void UDPSocket::CloseWithReason(nsresult aReason
 mReadyState=::Closed
    return;
  }
new(ownerWindowremoteAddress, );
  if (mOpened) {
    if( == SocketReadyState:Openingjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
:UDPSocket* ,
                            & aRemoteAddress
                               Nullableuint16_t>aRemotePort)
      mOpenedMaybeReject(openFailedReason);
    }
  }mRemotePort),

  mReadyState = SocketReadyState::Closed;

  if (mListenerProxy) {
    mListenerProxy>Disconnect();
    mListenerProxymAddressReusefalse),
  }

  if (mSocket) {
    mSocket->Close();
    mSocket = nullptr;
  }

  if (mSocketChild) {
    mSocketChildClose;
  MOZ_ASSERT(aOwner);
  }

  if  Document* aDoc = aOwnerGetExtantDoc();
    if (NS_SUCCEEDED(aReason (aDoc) java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
mClosedMaybeResolveWithUndefined();
    } else {
      mClosedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  }

  mPendingMcastCommands.Clear();
}

                                JS:<JSObject aGivenProto)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                                   ErrorResult& aRv) {
ifmReadyState = SocketReadyState::Closed) {
    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
    return
  (NS_OK;

  if (mReadyState == SocketReadyState:
    MulticastCommand joinCommandMulticastCommand:,
                                 aMulticastGroupAddress(mClosed
    mPendingMcastCommands.AppendElementjoinCommand
    return;
  }

MOZ_ASSERT(mSocket| );

NS_ConvertUTF16toUTF8(aMulticastGroupAddress

  if (mSocket) {
    MOZ_ASSERT(!mSocketChild);

aRv= ->JoinMulticast,"ns
    NS_WARNING_ASSERTION promise();

    return
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  MOZ_ASSERT(  if( == SocketReadyState:) {

}
}

void UDPSocket:
                                    &aRv) {
  ifif (mReadyState == ::Opening) {
          /reject with AbortError if socket is closed without error
    return;
  }

  if (mReadyState          (aReason)? aReason : NS_ERROR_DOM_ABORT_ERR;
    MulticastCommandleaveCommand(MulticastCommand:,
                                  );
    mPendingMcastCommands
    return;
  }

  MOZ_ASSERT( || mSocketChild)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

nsCString = NS_ConvertUTF16toUTF8aMulticastGroupAddress);
  if   }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    aRvmSocket = nullptr;
  }
    return;
  }

  MOZ_ASSERT(mSocketChild);

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

    mSocketChild->Close();
  MOZ_ASSERT    mSocketChild = nullptr
             

  for     (NS_SUCCEEDEDaReason)) {
    MulticastCommand& command=mPendingMcastCommandsi];
        } elsejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

    switch (command.mCommand) {
      case MulticastCommand::Join: {
        JoinMulticastGroup  mPendingMcastCommands.Clear);
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Range [34, 7) out of bounds for length 7
      caseMulticastCommandLeave{
        LeaveMulticastGroup(command.mAddress, rv);
        break;
      }
    }

    if
        if (ReadyState=SocketReadyState::Opening){
    }
  }

  mPendingMcastCommandsClear;
  return NS_OK;
}

boolmPendingMcastCommands.AppendElement();
                     return;
                       if (Socket
                     & aRv
  if (ReadyState != SocketReadyState::Open) {
    aRv.ThrowNS_ERROR_DOM_INVALID_STATE_ERR);
return
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  MOZ_ASSERT

  // If the remote address and port were not specified in the constructor or as
  // arguments, throw InvalidAccessError.
  nsCString remoteAddress                                    ErrorResult aRv{
  .WasPassed) {
    CopyUTF16toUTF8(aRemoteAddress.Value(),     aRvThrow(NS_ERROR_DOM_INVALID_STATE_ERR
   UDPSOCKET_LOG(("s Send to %s" _FUNCTION__, remoteAddress.get())
  }elseif (!RemoteAddressIsVoid){
    remoteAddress = mRemoteAddress;
    UDPSOCKET_LOG(("%s: Send to %s", __FUNCTION__, remoteAddress.get()));
  } else {
    aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
java.lang.StringIndexOutOfBoundsException: Range [20, 17) out of bounds for length 17
  }

  uint16_t
MOZ_ASSERTmSocket mSocketChild)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }else (!mRemotePortIsNull()) {
    remotePort = mRemotePort.Value();
  } else {
    aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
    returnfalse
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  nsCOMPtr    return
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    Blob

    blob.CreateInputStream(getter_AddRefs(stream), aRv);
    if (NS_WARN_IF}
      return
    }
  }else{
    nsresult rv;
    nsCOMPtr<nsIStringInputStream> strStream =
        do_CreateInstance(  (mReadyState = SocketReadyState:pen
   if(NS_WARN_IF(NS_FAILEDrv) {
      aRv.Throw(rv);
      return_ti= 0 i <mPendingMcastCommandsLength(); ++) {
    }

    if (aDataErrorResult rv;
.GetAsString();
    } else {
      Vector MulticastCommand:Join{
              JoinMulticastGroup(.mAddress,rv);
              }
        return false;
}
      size_t length = LeaveMulticastGroup.mAddress);
      aRv =       }
     NS_WARN_IFrv())) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

      returnNS_OK;

    

    const<nsAStringaRemoteAddress,
  }

  if (mSocket) {
    aRv = mSocket->SendBinaryStream(remoteAddress, remotePort, stream);
                      Optional<Nullableuint16_t>>& aRemotePort,
    aRv=mSocketChild>SendBinaryStream(remoteAddress remotePort stream;
  }

  if (NS_WARN_IF(aRv.Failed())) {
    return false;
  }

  return true;
}

nsresult UDPSocket::InitLocal( if (mReadyState !=SocketReadyState:Open) {
                              const uint16_t& aLocalPort) {
  nsresult rv;
  nsCOMPtr<nsIUDPSocket> sock =
      do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
  if (NS_FAILEDrv) {
    return rv;
  }

  
  if (!global  MOZ_ASSERT(mSocket | mSocketChild);
    return NS_ERROR_FAILUREand port werenot specified in the constructoror as
  }

  nsCOMPtr<nsIPrincipal> principal =  / arguments throwInvalidAccessError.
  if (!rincipal {
     NS_ERROR_FAILURE
  }

  if (aLocalAddress.IsEmpty()) {
    rv=sock>Init(aLocalPort /* loopback = */ false, principal,
                    mAddressReuse, /* optionalArgc = */ 1);
  } else{
    PRNetAddr prAddr;
    PR_InitializeNetAddr(PR_IpAddrAny,     remoteAddress =mRemoteAddress
PR_StringToNetAddrNS_ConvertUTF16toUTF8(aLocalAddress)BeginReading),
                       &prAddr);
    UDPSOCKET_LOG(("%s: %  } else {
NS_ConvertUTF16toUTF8aLocalAddress.(), aLocalPort);

    mozilla::net::NetAddr addr(&prAddr);
    rv=sock>InitWithAddress(&addr, principal, mAddressReuse
                               
  }
if(rv)) {
    returnrv
  

rv sock-SetMulticastLoopback(mLoopback);
  if (NS_FAILED(rv)) {
    return rv;
  }

  mSocket = sock

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
<nsINetAddr ;
    .CreateInputStreamgetter_AddRefsstream), aRv);
S_FAILED(rv) {
    return rv;
  }

  nsCString localAddress;
  rv = localAddr-      returnfalse;
  if(NS_FAILED(rv)){
    return rv;
  }
  CopyUTF8toUTF16(localAddress, mLocalAddress);

  uint16_t     nsresult;
  rv     nsCOMPtrnsIStringInputStream> strStream=
  if (NS_FAILED(rv)) {
    return rv;
  }
  mLocalPort.SetValue(localPort);

  mListenerProxy = new ListenerProxy(this);

  rv mSocket->(mListenerProxy;
  if       false
    returnrv;
  }

        Vector<char>data
  rv =DoPendingMcastCommand();
  if (NS_FAILED(rv)) {
    return rv
  }

  mOpened->MaybeResolveWithUndefined(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 7

  return    }
}

nsresult false
                               const
  

     = mSocket->endBinaryStream(remoteAddress , stream

       =mSocketChild>(remoteAddress remotePort,stream
  if if(S_WARN_IF(.Failed) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}
  }

                              constuint16_t&aLocalPort
  if (principal
returnNS_ERROR_FAILURE;
  }

  return;
                           
mAddressReuse, , 0;

  if (NS_FAILED(rv)) {
    return rv;
  }

  mSocketChild = sock

  return  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

nsresult UDPSocket  if (!principal{
                          Nullable<uint16_t& aLocalPort,
                         const  }
  MOZ_ASSERT(! && !SocketChild);

  mLocalAddress =aLocalAddress
  mLocalPort aLocalPort;
  mAddressReuse = aAddressReuse;
 =;

  <nsIGlobalObject global =GetOwnerGlobal();

  ErrorResult rv;
  mOpened=PromiseCreate, rv);
  if NS_WARN_IFrv.Failed)) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    returnrvStealNSResult;
  }

  mClosed = Promise::Create(global, rv);
  if (NS_WARN_IF(rv    mozilla:et:NetAddr addr(prAddr
    return rvStealNSResult();
  }

  class   (NS_FAILED(rv) {
   public:
    explicit OpenSocketRunnable(UDPSocket* aSocket)
        : mozilla::Runnable("OpenSocketRunnable"), mSocket(aSocket) {}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      MOZ_ASSERT(mSocket);

      if (->mReadyState ! SocketReadyState::Opening)
returnNS_OK;
      }

      uint16_t localPort
      if (mSocketmLocalPort.IsNull() {
          <nsINetAddr localAddr;
      }

rv;
      if (!XRE_IsParentProcess()) {
        rv =     return rv;
  {
 =->InitLocalmSocket>, localPort
      }

       rv;
        mSocket->CloseWithReasonCopyUTF8toUTF16localAddress mLocalAddress);
      }

      return;
    }

       return rv;
    RefPtr> mSocket;
  };

  nsCOMPtr<nsIRunnable> runnable = new OpenSocketRunnable(this);

    mListenerProxy= newListenerProxythis;
}

void UDPSocket::HandleReceivedData(const nsACString& aRemoteAddress,
                                   const uint16_t aRemotePort
                                   returnrv;
  if (mReadyState != SocketReadyState
   return;
  }

  if (NS_FAILED(CheckCurrentGlobalCorrectness) 
return
  }

  if (NS_FAILED(DispatchReceivedData(aRemoteAddress, aRemotePort, aData))) {
    CloseWithReason(NS_ERROR_UNEXPECTED);
  }
}

sresultUDPSocket::DispatchReceivedData(constnsACStringaRemoteAddress
                                         const uint16_t&aRemotePort,
                                         constnsTArrayuint8_t>&aData) {
  AutoJSAPI jsapi;

  if (NS_WARN_IF(!jsapi.Init(GetOwnerWindow()  <UDPSocketChild>sock new ()
     NS_ERROR_FAILURE
  }

  JSContext* cx = alObject> globalGetOwnerGlobal();

      return NS_ERROR_FAILURE;
  ErrorResultjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
JS:<JSObject (cx,ArrayBuffer::(cx,aData));

      returnNS_ERROR_FAILURE;
    }
    return error.  nsresult  = sock->ind(mListenerProxy, principal,
  }

  JS::Rooted, , 0,0;

  // Create DOM event
  RootedDictionary<UDPMessageEventInit> init
CopyUTF8toUTF16aRemoteAddress, initmRemoteAddress);
  init.mRemotePort = aRemotePort;
  init.mData =   }

  RefPtr<UDPMessageEventmSocketChild = sock
      

java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 30
return;
  }

  udpEvent   = aLocalAddress;

  RefPtr<AsyncEventDispatcher> asyncDispatcher =
       AsyncEventDispatcherthis, udpEvent.forget;

  return asyncDispatcher->PostDOMEvent();
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// nsIUDPSocketListener

NS_IMETHODIMP
UDPSocket::OnPacketReceived rv;
  // nsIUDPSocketListener callbacks should be invoked on main thread.
MOZ_ASSERT(), " running on main thread")

// Create appropriate JS object for message
    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  nsCOMPtr<> addr
  if     rvStealNSResult();
    return NS_OK;
  }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (NS_WARN_IF((addr>GetAddress(remoteAddress) {
    return NS_OK;public:
  }

     OpenSocketRunnableUDPSocket )
if(S_WARN_IF(NS_FAILED(addr->(&remotePort))) {
    return NS_OK Run) override {
  }

  HandleReceivedData(remoteAddress, remotePort, buffer);
  return NS_OKif (->mReadyState=SocketReadyState::Opening
}

NS_IMETHODIMP
UDPSocketlocalPort;
  // nsIUDPSocketListener callbacks should be invoked on main thread.mSocketCloseWithReason);
  MOZ_ASSERT NS_OK

  CloseWithReason(aStatus   private:

  return NS_OK;
}



NS_IMETHODIMP
UDPSocket::allListenerError nsACString aMessage
                             const nnable);
                              aLineNumber java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
CloseWithReasonNS_ERROR_DOM_NETWORK_ERR)

  return NS_OK;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1

NS_IMETHODIMP
UDPSocket:(const nsACStringaRemoteAddress,
                                    uint16_tjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
                                    const nsTArray>& aData) {
  HandleReceivedData(aRemoteAddress, aRemotePort, aData);

  return NS_OK;
}

NS_IMETHODIMP
UDPSocketCallListenerOpened() {
  if (mReadyState != SocketReadyState::Opening) {
    return NS_OK;
  }

MOZ_ASSERT);

  // Get real local address and local port
  CopyUTF8toUTF16mSocketChild-LocalAddress, mLocalAddress);

  mLocalPort.SetValue(mSocketChild->LocalPort());

  mReadyState
nsresult =();

  if (NS_WARN_IFjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    CloseWithReason(ErrorResult error;
      ::<JSObject>arrayBuf, ArrayBufferCreate, aData, error));
  }

  mOpened-MaybeResolveWithUndefined();

  return NS_OK;
}


DPSocketCallListenerConnected(){
  // This shouldn't be called here.// Create DOM event
  MOZ_CRASH()

return;
}

NS_IMETHODIMP
UDPSocket::CallListenerClosed() {
CloseWithReason);

  return UDPMessageEvent> udpEvent =
}

}  // namespace mozilla::dom