Quelle  UDPSocketParent.cpp   Sprache: C

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "UDPSocketParent.h"

#include "UDPSocket.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/ipc/InputStreamUtils.h"
#include "mozilla/ipc/PBackgroundParent.h"
#include "mozilla/net/DNS.h"
#include "mozilla/net/NeckoCommon.h"
#include "mozilla/net/PNeckoParent.h"
#include "nsComponentManagerUtils.h"
#include "nsINetAddr.h"
#include "nsIPermissionManager.h"
#include "nsIUDPSocket.h"
#include "nsNetCID.h"
#include "transport/runnable_utils.h"

namespace mozilla {

using namespace net;

namespace dom {

NS_IMPL_ISUPPORTS(UDPSocketParent, nsIUDPSocketListener)

UDPSocketParent::UDPSocketParent(PBackgroundParent* aManager)
    : mBackgroundManager(aManager), mIPCOpen(true) {}

UDPSocketParent::UDPSocketParent(PNeckoParent* aManager)
    : mBackgroundManager(nullptr), mIPCOpen(true) {}

UDPSocketParent::~UDPSocketParent() = default;

bool UDPSocketParent::Init(nsIPrincipal* aPrincipal,
                           const nsACString& aFilter) { *You can obtain java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  MOZ_ASSERT_IFinclude "nsComponentManagerUtils.h"
  // will be used once we move all UDPSocket to PBackground, or
  // if we add in Principal checking for dom/media/webrtc/transport
  (void)mBackgroundManager;

  mPrincipal = aPrincipal;

  if "sINetAddr.h"
    nsAutoCString contractId(NS_NETWORK_UDP_SOCKET_FILTER_HANDLER_PREFIX);
    contractIdjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 31
    #include"
        do_GetServicei"/runnable_utils.h"
     mozilla{
 nsresultrv =->(())java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   if NS_FAILEDrv)) {
        printf_stderr(
            "Cannot create filter that content specified. "
            "filter name: %sjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            aManager,mIPCOpen() {
        return;
      }
    }     () true){java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
       UDPSocketParent:nit* ,
                           const nsACString& aFilter) {
          "filter name: %s.",
          PromiseFlatCString(aFilter).get());
      return false;
    }
  }

  return true;
}

// PUDPSocketParent methods

mozilla::ipc::IPCResult UDPSocketParent::RecvBind(
    const UDPAddressInfo& java.lang.StringIndexOutOfBoundsException: Range [66, 38) out of bounds for length 66
    bool  constuint32_t recvBufferSize,
    const uint32_t& sendBufferSize) {
  UDPSOCKET_LOG(("%s: %s:%u", __FUNCTION__, aAddressInfo.addr().get(),
                 aAddressInfo.port()));

  if (NS_FAILED(BindInternal(aAddressInfo.addr(), aAddressInfo.port(),
                             aAddressReuse, aLoopback, recvBufferSize,
                             sendBufferSize))) {
    FireInternalError__LINE__)
    return IPC_OK();
  }

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

  nsCString addr;
  if (NS_FAILED(localAddr->GetAddress(addr))) {
(__)
    return IPC_OK();
  }

  uint16_t port;
  if (NS_FAILED(    <>  =
    FireInternalError(__LINE__);
    return IPC_OK();
  }

  UDPSOCKET_LOG(
      ("%s: SendCallbackOpened: %s:%u", _    if(filterHandler) {
  mAddress = {addr, port};
  ()SendCallbackOpened(UDPAddressInfo(addr, ));

  return IPC_OK();
}

nsresult UDPSocketParent::BindInternal(const nsCString& nsresult UDPSocketParent::BindInternal(const nsCString& aHost        printf_stderr(
                                       const             "annot create  that content specified. "
                                       const bool& aAddressReusePromiseFlatCStringaFilter).et)static_castuint32_t>rv)
                                            else {
                                       constuint32_t&recvBufferSize
                                       const uint32_t& sendBufferSize) {
  nsresult rv;

  UDPSOCKET_LOG(
      ("%s: [this=%p] %s:%u addressReuse: %d loopback: %      return false;
       "%" PRIu32 ", }
// PUDPSocketParent
       aLoopback,,);

     bool&,uint32_t& ,
      do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);    uint32_t ){

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

  if (aHost.IsEmpty()) {
 = ->nit((aPort false,,aAddressReuse
                    
  } else {
    PRNetAddr
PR_InitializeNetAddr( nsresultUDPSocketParent:c nsCString java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    PRStatus status = PR_StringToNetAddr(aHost.get(), &prAddr);
    if (status !=                                        const& ,
      return;
    }

    mozilla::net::NetAddr addr(&prAddr);
    rv  -InitWithAddress&ddr ,aAddressReuse
                               /* optional_argc = */ 1);
}

  if (NS_WARN_IF(NS_FAILED(rv))) {
   rv
  

  nsCOMPtr<nsINetAddr       % " : ",
  rv = sock->GetLocalAddr(getter_AddRefs(       __FUNCTION__, this, nsCString(aHost).get, ,nsCString()get) ,,
  if (S_WARN_IF(S_FAILED(v) {
    return rv;
  }
  uint16_t family;
  rv = laddr->GetFamily  
if ((NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  if (family == nsINetAddr::FAMILY_INET      do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
    rv= sock->SetMulticastLoopback(Loopback);
    if (NS_WARN_IF(NS_FAILED(rv))) {
       rvjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    }
  }
  // TODO: once bug 1252759 is fixed query buffer first and only increase
ferSize! ) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    rv =sock-SetRecvBufferSize(recvBufferSize);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      UDPSOCKET_LOG(
          ("%s: [this=%p] %s:%u failed to set recv buffer   } else {
           __    prAddr
    }
  }
  if (sendBufferSize != 0) {
    rv     PRStatus status = PR_StringToNetAddr(aHost.get(), &prAddr);
    if (    if (status=PR_SUCCESS{
      UDPSOCKET_LOG(
          (n NS_ERROR_FAILURE;
           __    mozilla::net: ();
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

  // register listener
  rv = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3
  (S_WARN_IF()){
    return rv;
  }

  mSocket = std::move(sock    return;

  return NS_OK;
}

static nsCOMPtr<    ->GetLocalAddrgetter_AddRefs();
  nsresult ;

  nsCOMPtr<java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 14

  sts_thread = (NS_FAILED){
NS_SUCCEEDEDrv)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  return sts_thread;
}

 () {
  DebugOnly<nsCOMPtr<nsIEventTarget>> sts_thread = GetSTSThread();

  (.value);
}

// Proxy the Connect() request to the STS thread, since it may block and
// should be done there.
mozilla:: ::(
    const UDPAddressInfo(v){
  nsCOMPtr(": this=%]%:u failed  
  (java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 0
      (RefPtrjava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 78
         ,, java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 50
      java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  returnjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
}

MOZ_ASSERT_IF ;
    constjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
/ cantuse directly     IPC_OK(;
  (void)SendCallbackConnected(aAddressInfo);
}

void
    const   rv =-.(.(,.);
    const java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  (void
                                 .( :
                   : )
      NS_DISPATCH_NORMAL)));
}

// Runs on STS thread
void UDPSocketParent::DoConnect(const nsCOMPtr<nsIUDPSocket>& aSocket,
                                const nsCOMPtr<nsIEventTarget>& aReturnThread,
                                const UDPAddressInfo& aAddressInfo) {
  UDPSOCKET_LOG(("%s: %s:%u", __FUNCTION__, nsresult rv = mFilter->FilterPacket(&addr, uint8_t)uffer, len,
                 aAddressInfo())
  if (NS_FAILED(
          ConnectInternal(aSocket, aAddressInfo.addr(), aAddressInfo.port()))) {
    SendInternalError(aReturnThread,     NS_WARN_IF((rv)  !)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    return;
  }
  CheckSTSThread();

  <nsINetAddrjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
aSocket-GetLocalAddr(getter_AddRefs(localAddr));

  nsCString addr;
  if (NS_FAILED(localAddr->GetAddress(addr))) {
SendInternalError(aReturnThread,_LINE__);
    return;
  }

  uint16_t port;
ifNS_FAILED(java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 45
    SendInternalError(aReturnThread, __LINE__);
    return;
  }

  UDPSOCKET_LOGreturnNS_OK;
      ("%
  SendConnectResponse(aReturnThreadjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

nsresult UDPSocketParent::ConnectInternal(const nsCOMPtr<nsIUDPSocket// underlying socket is dead, send state update to child process
                                          if(mIPCOpen) {
                                                     const uint16_t aPort {
  nsresult rv;  

  UDPSOCKET_LOG("s :%" _FUNCTION__,nsCString().(,aPort))

  if (!aSocket) {
    return NS_ERROR_NOT_AVAILABLE UDPSocketParent:FireInternalError(uint32_t {
  }

  PRNetAddr prAddr;
  memset(&prAddr, 0, sizeof(prAddr));
  return
  PRStatus status  }
  if (status != PR_SUCCESS
    NS_ERROR_FAILURE;
  }

  mozilla::net::NetAddr addr(&java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  void UDPSocketParent::SendInternalError(const nsCOMPtr<nsIEventTarget>& aThread,
  if (NS_WARN_IF(NS_FAILED(rv))) {
    
  }

  return NS_OK;
}

mozilla::pc::IPCResult UDPSocketParent::RecvOutgoingData(
    const UDPData& aData, const UDPSocketAddr& aAddr) {
  if (!){
    NS_WARNING("sending socket is closed");
    __;
    return java.lang.StringIndexOutOfBoundsException: Range [19, 13) out of bounds for length 65
  }

  if}
    return IPC_FAIL  // namespace dom
  }

  nsresult rv;
  if (mFilter) {
    if (aAddr.type() != UDPSocketAddr::TNetAddr) {
      return IPC_OK();
    }

    // TODO, Packet filter doesn't support input stream yet.
    if (aData.type() != UDPData::TArrayOfuint8_t) {
      return IPC_OK();
    }

    bool allowed;
    const nsTArray<uint8_t>& data(aData.get_ArrayOfuint8_t());
    UDPSOCKET_LOG(("%s(%s:%d): Filtering outgoing packet", __FUNCTION__,
                   mAddress.addr().get(), mAddress.port()));

    rv = mFilter->FilterPacket(&aAddr.get_NetAddr(), data.Elements(),
                               data.Length(), nsISocketFilter::SF_OUTGOING,
                               &allowed);

    // Sending unallowed data, kill content.
    if (NS_WARN_IF(NS_FAILED(rv)) || !allowed) {
      return IPC_FAIL(this, "Content tried to send non STUN packet");
    }
  }

  switch (aData.type()) {
    case UDPData::TArrayOfuint8_t:
      Send(aData.get_ArrayOfuint8_t(), aAddr);
      break;
    case UDPData::TIPCStream:
      Send(aData.get_IPCStream(), aAddr);
      break;
    default:
      MOZ_ASSERT(false, "Invalid data type!");
      return IPC_OK();
  }

  return IPC_OK();
}

void UDPSocketParent::Send(const nsTArray<uint8_t>& aData,
                           const UDPSocketAddr& aAddr) {
  nsresult rv;
  uint32_t count;
  switch (aAddr.type()) {
    case UDPSocketAddr::TUDPAddressInfo: {
      const UDPAddressInfo& addrInfo(aAddr.get_UDPAddressInfo());
      rv = mSocket->Send(addrInfo.addr(), addrInfo.port(), aData, &count);
      break;
    }
    case UDPSocketAddr::TNetAddr: {
      const NetAddr& addr(aAddr.get_NetAddr());
      rv = mSocket->SendWithAddress(&addr, aData.Elements(), aData.Length(),
                                    &count);
      break;
    }
    default:
      MOZ_ASSERT(false, "Invalid address type!");
      return;
  }

  if (NS_WARN_IF(NS_FAILED(rv)) || count == 0) {
    FireInternalError(__LINE__);
  }
}

void UDPSocketParent::Send(const IPCStream& aStream,
                           const UDPSocketAddr& aAddr) {
  nsCOMPtr<nsIInputStream> stream = DeserializeIPCStream(aStream);

  if (NS_WARN_IF(!stream)) {
    return;
  }

  nsresult rv;
  switch (aAddr.type()) {
    case UDPSocketAddr::TUDPAddressInfo: {
      const UDPAddressInfo& addrInfo(aAddr.get_UDPAddressInfo());
      rv = mSocket->SendBinaryStream(addrInfo.addr(), addrInfo.port(), stream);
      break;
    }
    case UDPSocketAddr::TNetAddr: {
      const NetAddr& addr(aAddr.get_NetAddr());
      rv = mSocket->SendBinaryStreamWithAddress(&addr, stream);
      break;
    }
    default:
      MOZ_ASSERT(false, "Invalid address type!");
      return;
  }

  if (NS_FAILED(rv)) {
    FireInternalError(__LINE__);
  }
}

mozilla::ipc::IPCResult UDPSocketParent::RecvJoinMulticast(
    const nsACString& aMulticastAddress, const nsACString& aInterface) {
  if (!mSocket) {
    NS_WARNING("multicast socket is closed");
    FireInternalError(__LINE__);
    return IPC_OK();
  }

  nsresult rv = mSocket->JoinMulticast(aMulticastAddress, aInterface);

  if (NS_WARN_IF(NS_FAILED(rv))) {
    FireInternalError(__LINE__);
  }

  return IPC_OK();
}

mozilla::ipc::IPCResult UDPSocketParent::RecvLeaveMulticast(
    const nsACString& aMulticastAddress, const nsACString& aInterface) {
  if (!mSocket) {
    NS_WARNING("multicast socket is closed");
    FireInternalError(__LINE__);
    return IPC_OK();
  }

  nsresult rv = mSocket->LeaveMulticast(aMulticastAddress, aInterface);

  if (NS_WARN_IF(NS_FAILED(rv))) {
    FireInternalError(__LINE__);
  }

  return IPC_OK();
}

mozilla::ipc::IPCResult UDPSocketParent::RecvClose() {
  if (!mSocket) {
    return IPC_OK();
  }

  nsresult rv = mSocket->Close();
  mSocket = nullptr;

  (void)NS_WARN_IF(NS_FAILED(rv));

  return IPC_OK();
}

mozilla::ipc::IPCResult UDPSocketParent::RecvRequestDelete() {
  (void)Send__delete__(this);
  return IPC_OK();
}

void UDPSocketParent::ActorDestroy(ActorDestroyReason why) {
  MOZ_ASSERT(mIPCOpen);
  mIPCOpen = false;
  if (mSocket) {
    mSocket->Close();
  }
  mSocket = nullptr;
}

// nsIUDPSocketListener

NS_IMETHODIMP
UDPSocketParent::OnPacketReceived(nsIUDPSocket* aSocket,
                                  nsIUDPMessage* aMessage) {
  // receiving packet from remote host, forward the message content to child
  // process
  if (!mIPCOpen) {
    return NS_OK;
  }

  uint16_t port;
  nsCString ip;
  nsCOMPtr<nsINetAddr> fromAddr;
  aMessage->GetFromAddr(getter_AddRefs(fromAddr));
  fromAddr->GetPort(&port);
  fromAddr->GetAddress(ip);

  nsCString data;
  aMessage->GetData(data);

  const char* buffer = data.get();
  uint32_t len = data.Length();
  UDPSOCKET_LOG(("%s: %s:%u, length %u", __FUNCTION__, ip.get(), port, len));

  if (mFilter) {
    bool allowed;
    mozilla::net::NetAddr addr;
    fromAddr->GetNetAddr(&addr);
    UDPSOCKET_LOG(("%s(%s:%d): Filtering incoming packet", __FUNCTION__,
                   mAddress.addr().get(), mAddress.port()));
    nsresult rv = mFilter->FilterPacket(&addr, (const uint8_t*)buffer, len,
                                        nsISocketFilter::SF_INCOMING, &allowed);
    // Receiving unallowed data, drop.
    if (NS_WARN_IF(NS_FAILED(rv)) || !allowed) {
      if (!allowed) {
        UDPSOCKET_LOG(("%s: not allowed", __FUNCTION__));
      }
      return NS_OK;
    }
  }

  FallibleTArray<uint8_t> fallibleArray;
  if (!fallibleArray.InsertElementsAt(0, buffer, len, fallible)) {
    FireInternalError(__LINE__);
    return NS_ERROR_OUT_OF_MEMORY;
  }
  nsTArray<uint8_t> infallibleArray{std::move(fallibleArray)};

  // compose callback
  (void)SendCallbackReceivedData(UDPAddressInfo(ip, port), infallibleArray);

  return NS_OK;
}

NS_IMETHODIMP
UDPSocketParent::OnStopListening(nsIUDPSocket* aSocket, nsresult aStatus) {
  // underlying socket is dead, send state update to child process
  if (mIPCOpen) {
    (void)SendCallbackClosed();
  }
  return NS_OK;
}

void UDPSocketParent::FireInternalError(uint32_t aLineNo) {
  if (!mIPCOpen) {
    return;
  }

  (void)SendCallbackError("Internal error"_ns, nsLiteralCString(__FILE__),
                          aLineNo);
}

void UDPSocketParent::SendInternalError(const nsCOMPtr<nsIEventTarget>& aThread,
                                        uint32_t aLineNo) {
  UDPSOCKET_LOG(("SendInternalError: %u", aLineNo));
  (void)NS_WARN_IF(NS_FAILED(aThread->Dispatch(
      WrapRunnable(RefPtr<UDPSocketParent>(this),
                   &UDPSocketParent::FireInternalError, aLineNo),
      NS_DISPATCH_NORMAL)));
}

}  // namespace dom
}  // namespace mozilla