gecko-dev/dom/network/TCPSocketParent.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.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 "TCPSocketParent.h"
#include "jsapi.h"
#include "jsfriendapi.h"
#include "nsJSUtils.h"
#include "mozilla/Unused.h"
#include "mozilla/net/NeckoCommon.h"
#include "mozilla/net/PNeckoParent.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/ScriptSettings.h"
#include "mozilla/dom/TabParent.h"
#include "mozilla/HoldDropJSObjects.h"
#include "nsISocketTransportService.h"
#include "nsISocketTransport.h"
#include "nsIScriptSecurityManager.h"
#include "nsNetUtil.h"

namespace IPC {

//Defined in TCPSocketChild.cpp
extern bool
DeserializeArrayBuffer(JSContext* aCx,
                       const InfallibleTArray<uint8_t>& aBuffer,
                       JS::MutableHandle<JS::Value> aVal);

} // namespace IPC

namespace mozilla {

namespace net {
//
// set MOZ_LOG=TCPSocket:5
//
extern LazyLogModule gTCPSocketLog;
#define TCPSOCKET_LOG(args)     MOZ_LOG(gTCPSocketLog, LogLevel::Debug, args)
#define TCPSOCKET_LOG_ENABLED() MOZ_LOG_TEST(gTCPSocketLog, LogLevel::Debug)
} // namespace net

namespace dom {

static void
FireInteralError(mozilla::net::PTCPSocketParent* aActor, uint32_t aLineNo)
{
  mozilla::Unused <<
      aActor->SendCallback(NS_LITERAL_STRING("onerror"),
                           TCPError(NS_LITERAL_STRING("InvalidStateError"), NS_LITERAL_STRING("Internal error")),
                           static_cast<uint32_t>(TCPReadyState::Connecting));
}

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TCPSocketParentBase)
  NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END

NS_IMPL_CYCLE_COLLECTION(TCPSocketParentBase, mSocket)
NS_IMPL_CYCLE_COLLECTING_ADDREF(TCPSocketParentBase)
NS_IMPL_CYCLE_COLLECTING_RELEASE(TCPSocketParentBase)

TCPSocketParentBase::TCPSocketParentBase()
: mIPCOpen(false)
{
}

TCPSocketParentBase::~TCPSocketParentBase()
{
}

void
TCPSocketParentBase::ReleaseIPDLReference()
{
  MOZ_ASSERT(mIPCOpen);
  mIPCOpen = false;
  this->Release();
}

void
TCPSocketParentBase::AddIPDLReference()
{
  MOZ_ASSERT(!mIPCOpen);
  mIPCOpen = true;
  this->AddRef();
}

NS_IMETHODIMP_(MozExternalRefCountType) TCPSocketParent::Release(void)
{
  nsrefcnt refcnt = TCPSocketParentBase::Release();
  if (refcnt == 1 && mIPCOpen) {
    mozilla::Unused << PTCPSocketParent::SendRequestDelete();
    return 1;
  }
  return refcnt;
}

mozilla::ipc::IPCResult
TCPSocketParent::RecvOpen(const nsString& aHost, const uint16_t& aPort, const bool& aUseSSL,
                          const bool& aUseArrayBuffers)
{
  mSocket = new TCPSocket(nullptr, aHost, aPort, aUseSSL, aUseArrayBuffers);
  mSocket->SetSocketBridgeParent(this);
  NS_ENSURE_SUCCESS(mSocket->Init(), IPC_OK());
  return IPC_OK();
}

mozilla::ipc::IPCResult
TCPSocketParent::RecvOpenBind(const nsCString& aRemoteHost,
                              const uint16_t& aRemotePort,
                              const nsCString& aLocalAddr,
                              const uint16_t& aLocalPort,
                              const bool&     aUseSSL,
                              const bool&     aReuseAddrPort,
                              const bool&     aUseArrayBuffers,
                              const nsCString& aFilter)
{
  nsresult rv;
  nsCOMPtr<nsISocketTransportService> sts =
    do_GetService("@mozilla.org/network/socket-transport-service;1", &rv);
  if (NS_FAILED(rv)) {
    FireInteralError(this, __LINE__);
    return IPC_OK();
  }

  nsCOMPtr<nsISocketTransport> socketTransport;
  if (aUseSSL) {
    const char* socketTypes[1];
    socketTypes[0] = "ssl";
    rv = sts->CreateTransport(socketTypes, 1,
                              aRemoteHost, aRemotePort,
                              nullptr, getter_AddRefs(socketTransport));
  } else {
    rv = sts->CreateTransport(nullptr, 0,
                              aRemoteHost, aRemotePort,
                              nullptr, getter_AddRefs(socketTransport));
  }

  if (NS_FAILED(rv)) {
    FireInteralError(this, __LINE__);
    return IPC_OK();
  }

  // in most cases aReuseAddrPort is false, but ICE TCP needs
  // sockets options set that allow addr/port reuse
  socketTransport->SetReuseAddrPort(aReuseAddrPort);

  PRNetAddr prAddr;
  if (PR_SUCCESS != PR_InitializeNetAddr(PR_IpAddrAny, aLocalPort, &prAddr)) {
    FireInteralError(this, __LINE__);
    return IPC_OK();
  }
  if (PR_SUCCESS != PR_StringToNetAddr(aLocalAddr.BeginReading(), &prAddr)) {
    FireInteralError(this, __LINE__);
    return IPC_OK();
  }

  mozilla::net::NetAddr addr;
  PRNetAddrToNetAddr(&prAddr, &addr);
  rv = socketTransport->Bind(&addr);
  if (NS_FAILED(rv)) {
    FireInteralError(this, __LINE__);
    return IPC_OK();
  }

  if (!aFilter.IsEmpty()) {
    nsAutoCString contractId(NS_NETWORK_TCP_SOCKET_FILTER_HANDLER_PREFIX);
    contractId.Append(aFilter);
    nsCOMPtr<nsISocketFilterHandler> filterHandler =
      do_GetService(contractId.get());
    if (!filterHandler) {
      NS_ERROR("Content doesn't have a valid filter");
      FireInteralError(this, __LINE__);
      return IPC_OK();
    }
    rv = filterHandler->NewFilter(getter_AddRefs(mFilter));
    if (NS_FAILED(rv)) {
      NS_ERROR("Cannot create filter that content specified");
      FireInteralError(this, __LINE__);
      return IPC_OK();
    }
  }

  mSocket = new TCPSocket(nullptr, NS_ConvertUTF8toUTF16(aRemoteHost), aRemotePort, aUseSSL, aUseArrayBuffers);
  mSocket->SetSocketBridgeParent(this);
  rv = mSocket->InitWithUnconnectedTransport(socketTransport);
  NS_ENSURE_SUCCESS(rv, IPC_OK());
  return IPC_OK();
}

mozilla::ipc::IPCResult
TCPSocketParent::RecvStartTLS()
{
  NS_ENSURE_TRUE(mSocket, IPC_OK());
  ErrorResult rv;
  mSocket->UpgradeToSecure(rv);
  if (NS_WARN_IF(rv.Failed())) {
    rv.SuppressException();
  }

  return IPC_OK();
}

mozilla::ipc::IPCResult
TCPSocketParent::RecvSuspend()
{
  NS_ENSURE_TRUE(mSocket, IPC_OK());
  mSocket->Suspend();
  return IPC_OK();
}

mozilla::ipc::IPCResult
TCPSocketParent::RecvResume()
{
  NS_ENSURE_TRUE(mSocket, IPC_OK());
  ErrorResult rv;
  mSocket->Resume(rv);
  if (NS_WARN_IF(rv.Failed())) {
    rv.SuppressException();
  }

  return IPC_OK();
}

mozilla::ipc::IPCResult
TCPSocketParent::RecvData(const SendableData& aData,
                          const uint32_t& aTrackingNumber)
{
  ErrorResult rv;

  if (mFilter) {
    mozilla::net::NetAddr addr; // dummy value
    bool allowed;
    MOZ_ASSERT(aData.type() == SendableData::TArrayOfuint8_t,
               "Unsupported data type for filtering");
    const InfallibleTArray<uint8_t>& data(aData.get_ArrayOfuint8_t());
    nsresult nsrv = mFilter->FilterPacket(&addr, data.Elements(),
                                          data.Length(),
                                          nsISocketFilter::SF_OUTGOING,
                                          &allowed);

    // Reject sending of unallowed data
    if (NS_WARN_IF(NS_FAILED(nsrv)) || !allowed) {
      TCPSOCKET_LOG(("%s: Dropping outgoing TCP packet", __FUNCTION__));
      return IPC_FAIL_NO_REASON(this);
    }
  }

  switch (aData.type()) {
    case SendableData::TArrayOfuint8_t: {
      AutoSafeJSContext autoCx;
      JS::Rooted<JS::Value> val(autoCx);
      const nsTArray<uint8_t>& buffer = aData.get_ArrayOfuint8_t();
      bool ok = IPC::DeserializeArrayBuffer(autoCx, buffer, &val);
      NS_ENSURE_TRUE(ok, IPC_OK());
      RootedSpiderMonkeyInterface<ArrayBuffer> data(autoCx);
      data.Init(&val.toObject());
      Optional<uint32_t> byteLength(buffer.Length());
      mSocket->SendWithTrackingNumber(autoCx, data, 0, byteLength, aTrackingNumber, rv);
      break;
    }

    case SendableData::TnsCString: {
      const nsCString& strData = aData.get_nsCString();
      mSocket->SendWithTrackingNumber(strData, aTrackingNumber, rv);
      break;
    }

    default:
      MOZ_CRASH("unexpected SendableData type");
  }
  NS_ENSURE_SUCCESS(rv.StealNSResult(), IPC_OK());
  return IPC_OK();
}

mozilla::ipc::IPCResult
TCPSocketParent::RecvClose()
{
  NS_ENSURE_TRUE(mSocket, IPC_OK());
  mSocket->Close();
  return IPC_OK();
}

void
TCPSocketParent::FireErrorEvent(const nsAString& aName, const nsAString& aType, TCPReadyState aReadyState)
{
  SendEvent(NS_LITERAL_STRING("error"), TCPError(nsString(aName), nsString(aType)), aReadyState);
}

void
TCPSocketParent::FireEvent(const nsAString& aType, TCPReadyState aReadyState)
{
  return SendEvent(aType, mozilla::void_t(), aReadyState);
}

void
TCPSocketParent::FireArrayBufferDataEvent(nsTArray<uint8_t>& aBuffer, TCPReadyState aReadyState)
{
  InfallibleTArray<uint8_t> arr;
  arr.SwapElements(aBuffer);

  if (mFilter) {
    bool allowed;
    mozilla::net::NetAddr addr;
    nsresult nsrv = mFilter->FilterPacket(&addr, arr.Elements(), arr.Length(),
                                          nsISocketFilter::SF_INCOMING,
                                          &allowed);
    // receiving unallowed data, drop it.
    if (NS_WARN_IF(NS_FAILED(nsrv)) || !allowed) {
      TCPSOCKET_LOG(("%s: Dropping incoming TCP packet", __FUNCTION__));
      return;
    }
  }

  SendableData data(arr);
  SendEvent(NS_LITERAL_STRING("data"), data, aReadyState);
}

void
TCPSocketParent::FireStringDataEvent(const nsACString& aData, TCPReadyState aReadyState)
{
  SendableData data((nsCString(aData)));

  MOZ_ASSERT(!mFilter, "Socket filtering doesn't support nsCString");

  SendEvent(NS_LITERAL_STRING("data"), data, aReadyState);
}

void
TCPSocketParent::SendEvent(const nsAString& aType, CallbackData aData, TCPReadyState aReadyState)
{
  if (mIPCOpen) {
    mozilla::Unused << PTCPSocketParent::SendCallback(nsString(aType),
                                                      aData,
                                                      static_cast<uint32_t>(aReadyState));
  }
}

void
TCPSocketParent::SetSocket(TCPSocket *socket)
{
  mSocket = socket;
}

nsresult
TCPSocketParent::GetHost(nsAString& aHost)
{
  if (!mSocket) {
    NS_ERROR("No internal socket instance mSocket!");
    return NS_ERROR_FAILURE;
  }
  mSocket->GetHost(aHost);
  return NS_OK;
}

nsresult
TCPSocketParent::GetPort(uint16_t* aPort)
{
  if (!mSocket) {
    NS_ERROR("No internal socket instance mSocket!");
    return NS_ERROR_FAILURE;
  }
  *aPort = mSocket->Port();
  return NS_OK;
}

void
TCPSocketParent::ActorDestroy(ActorDestroyReason why)
{
  if (mSocket) {
    mSocket->Close();
  }
  mSocket = nullptr;
}

mozilla::ipc::IPCResult
TCPSocketParent::RecvRequestDelete()
{
  mozilla::Unused << Send__delete__(this);
  return IPC_OK();
}

} // namespace dom
} // namespace mozilla