/* -*- 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 <algorithm>

#include "TCPSocketChild.h"

#include "mozilla/Unused.h"

#include "mozilla/UniquePtr.h"

#include "mozilla/net/NeckoChild.h"

#include "mozilla/dom/PBrowserChild.h"

#include "mozilla/dom/TabChild.h"

#include "nsITCPSocketCallback.h"

#include "TCPSocket.h"

#include "nsContentUtils.h"

#include "jsapi.h"

#include "jsfriendapi.h"

using mozilla::net::gNeckoChild;

namespace IPC {

bool

DeserializeArrayBuffer(JSContext* cx,

                       const InfallibleTArray<uint8_t>& aBuffer,

                       JS::MutableHandle<JS::Value> aVal)

{

  mozilla::UniquePtr<uint8_t[], JS::FreePolicy> data(

    js_pod_arena_malloc<uint8_t>(js::ArrayBufferContentsArena, aBuffer.Length()));

  if (!data)

      return false;

  memcpy(data.get(), aBuffer.Elements(), aBuffer.Length());

  JSObject* obj = JS_NewArrayBufferWithContents(cx, aBuffer.Length(), data.get());

  if (!obj)

      return false;

  // If JS_NewArrayBufferWithContents returns non-null, the ownership of

  // the data is transfered to obj, so we release the ownership here.

  mozilla::Unused << data.release();

  aVal.setObject(*obj);

  return true;

}

} // namespace IPC

namespace mozilla {

namespace dom {

NS_IMPL_CYCLE_COLLECTION_CLASS(TCPSocketChildBase)

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(TCPSocketChildBase)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSocket)

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(TCPSocketChildBase)

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mSocket)

NS_IMPL_CYCLE_COLLECTION_UNLINK_END

NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(TCPSocketChildBase)

NS_IMPL_CYCLE_COLLECTION_TRACE_END

NS_IMPL_CYCLE_COLLECTING_ADDREF(TCPSocketChildBase)

NS_IMPL_CYCLE_COLLECTING_RELEASE(TCPSocketChildBase)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TCPSocketChildBase)

  NS_INTERFACE_MAP_ENTRY(nsISupports)

NS_INTERFACE_MAP_END

TCPSocketChildBase::TCPSocketChildBase()

: mIPCOpen(false)

{

  mozilla::HoldJSObjects(this);

}

TCPSocketChildBase::~TCPSocketChildBase()

{

  mozilla::DropJSObjects(this);

}

NS_IMETHODIMP_(MozExternalRefCountType) TCPSocketChild::Release(void)

{

  nsrefcnt refcnt = TCPSocketChildBase::Release();

  if (refcnt == 1 && mIPCOpen) {

    PTCPSocketChild::SendRequestDelete();

    return 1;

  }

  return refcnt;

}

TCPSocketChild::TCPSocketChild(const nsAString& aHost,

                               const uint16_t& aPort,

                               nsIEventTarget* aTarget)

: mHost(aHost)

, mPort(aPort)

, mIPCEventTarget(aTarget)

{

}

void

TCPSocketChild::SendOpen(nsITCPSocketCallback* aSocket, bool aUseSSL, bool aUseArrayBuffers)

{

  mSocket = aSocket;

  if (mIPCEventTarget) {

    gNeckoChild->SetEventTargetForActor(this, mIPCEventTarget);

  }

  AddIPDLReference();

  gNeckoChild->SendPTCPSocketConstructor(this, mHost, mPort);

  MOZ_ASSERT(mFilterName.IsEmpty()); // Currently nobody should use this

  PTCPSocketChild::SendOpen(mHost, mPort, aUseSSL, aUseArrayBuffers);

}

void

TCPSocketChild::SendWindowlessOpenBind(nsITCPSocketCallback* aSocket,

                                       const nsACString& aRemoteHost, uint16_t aRemotePort,

                                       const nsACString& aLocalHost, uint16_t aLocalPort,

                                       bool aUseSSL, bool aReuseAddrPort)

{

  mSocket = aSocket;

  if (mIPCEventTarget) {

    gNeckoChild->SetEventTargetForActor(this, mIPCEventTarget);

  }

  AddIPDLReference();

  gNeckoChild->SendPTCPSocketConstructor(this,

                                         NS_ConvertUTF8toUTF16(aRemoteHost),

                                         aRemotePort);

  PTCPSocketChild::SendOpenBind(nsCString(aRemoteHost), aRemotePort,

                                nsCString(aLocalHost), aLocalPort,

                                aUseSSL, aReuseAddrPort,

                                true, mFilterName);

}

void

TCPSocketChildBase::ReleaseIPDLReference()

{

  MOZ_ASSERT(mIPCOpen);

  mIPCOpen = false;

  mSocket = nullptr;

  this->Release();

}

void

TCPSocketChildBase::AddIPDLReference()

{

  MOZ_ASSERT(!mIPCOpen);

  mIPCOpen = true;

  this->AddRef();

}

TCPSocketChild::~TCPSocketChild()

{

}

mozilla::ipc::IPCResult

TCPSocketChild::RecvUpdateBufferedAmount(const uint32_t& aBuffered,

                                         const uint32_t& aTrackingNumber)

{

  mSocket->UpdateBufferedAmount(aBuffered, aTrackingNumber);

  return IPC_OK();

}

mozilla::ipc::IPCResult

TCPSocketChild::RecvCallback(const nsString& aType,

                             const CallbackData& aData,

                             const uint32_t& aReadyState)

{

  mSocket->UpdateReadyState(aReadyState);

  if (aData.type() == CallbackData::Tvoid_t) {

    mSocket->FireEvent(aType);

  } else if (aData.type() == CallbackData::TTCPError) {

    const TCPError& err(aData.get_TCPError());

    mSocket->FireErrorEvent(err.name(), err.message());

  } else if (aData.type() == CallbackData::TSendableData) {

    const SendableData& data = aData.get_SendableData();

    if (data.type() == SendableData::TArrayOfuint8_t) {

      mSocket->FireDataArrayEvent(aType, data.get_ArrayOfuint8_t());

    } else if (data.type() == SendableData::TnsCString) {

      mSocket->FireDataStringEvent(aType, data.get_nsCString());

    } else {

      MOZ_CRASH("Invalid callback data type!");

    }

  } else {

    MOZ_CRASH("Invalid callback type!");

  }

  return IPC_OK();

}

void

TCPSocketChild::SendSend(const nsACString& aData, uint32_t aTrackingNumber)

{

  SendData(nsCString(aData), aTrackingNumber);

}

nsresult

TCPSocketChild::SendSend(const ArrayBuffer& aData,

                         uint32_t aByteOffset,

                         uint32_t aByteLength,

                         uint32_t aTrackingNumber)

{

  uint32_t buflen = aData.Length();

  uint32_t offset = std::min(buflen, aByteOffset);

  uint32_t nbytes = std::min(buflen - aByteOffset, aByteLength);

  FallibleTArray<uint8_t> fallibleArr;

  if (!fallibleArr.InsertElementsAt(0, aData.Data() + offset, nbytes, fallible)) {

    return NS_ERROR_OUT_OF_MEMORY;

  }

  InfallibleTArray<uint8_t> arr;

  arr.SwapElements(fallibleArr);

  SendData(arr, aTrackingNumber);

  return NS_OK;

}

NS_IMETHODIMP

TCPSocketChild::SendSendArray(nsTArray<uint8_t>& aArray, uint32_t aTrackingNumber)

{

  SendData(aArray, aTrackingNumber);

  return NS_OK;

}

void

TCPSocketChild::SetSocket(TCPSocket* aSocket)

{

  mSocket = aSocket;

}

void

TCPSocketChild::GetHost(nsAString& aHost)

{

  aHost = mHost;

}

void

TCPSocketChild::GetPort(uint16_t* aPort)

{

  *aPort = mPort;

}

nsresult

TCPSocketChild::SetFilterName(const nsACString& aFilterName)

{

  if (!mFilterName.IsEmpty()) {

    // filter name can only be set once.

    return NS_ERROR_FAILURE;

  }

  mFilterName = aFilterName;

  return NS_OK;

}

mozilla::ipc::IPCResult

TCPSocketChild::RecvRequestDelete()

{

  mozilla::Unused << Send__delete__(this);

  return IPC_OK();

}

} // namespace dom

} // namespace mozilla