The Tor Browser: dom/network/src/TCPSocketChild.cpp@b8a032363ba2 (annotated)

dom/network/src/TCPSocketChild.cpp@b8a032363ba2 (annotated)

dom/network/src/TCPSocketChild.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* 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/net/NeckoChild.h"
 #include "mozilla/dom/PBrowserChild.h"
 #include "mozilla/dom/TabChild.h"
 #include "nsIDOMTCPSocket.h"
 #include "nsJSUtils.h"
 #include "nsContentUtils.h"
 #include "jsapi.h"
 #include "jsfriendapi.h"
 #include "jswrapper.h"
 using mozilla::net::gNeckoChild;
 namespace IPC {
 bool
 DeserializeArrayBuffer(JS::Handle<JSObject*> aObj,
                        const InfallibleTArray<uint8_t>& aBuffer,
                        JS::MutableHandle<JS::Value> aVal)
 {
   mozilla::AutoSafeJSContext cx;
   JSAutoCompartment ac(cx, aObj);
   JS::Rooted<JSObject*> obj(cx, JS_NewArrayBuffer(cx, aBuffer.Length()));
   if (!obj)
     return false;
   uint8_t* data = JS_GetArrayBufferData(obj);
   if (!data)
     return false;
   memcpy(data, aBuffer.Elements(), aBuffer.Length());
   aVal.set(OBJECT_TO_JSVAL(obj));
   return true;
 }
 } // namespace IPC
 namespace mozilla {
 namespace dom {
 NS_IMPL_CYCLE_COLLECTION(TCPSocketChildBase, mSocket)
 NS_IMPL_CYCLE_COLLECTING_ADDREF(TCPSocketChildBase)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(TCPSocketChildBase)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TCPSocketChildBase)
   NS_INTERFACE_MAP_ENTRY(nsITCPSocketChild)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 TCPSocketChildBase::TCPSocketChildBase()
 : mIPCOpen(false)
 {
 }
 TCPSocketChildBase::~TCPSocketChildBase()
 {
 }
 NS_IMETHODIMP_(MozExternalRefCountType) TCPSocketChild::Release(void)
 {
   nsrefcnt refcnt = TCPSocketChildBase::Release();
   if (refcnt == 1 && mIPCOpen) {
     PTCPSocketChild::SendRequestDelete();
     return 1;
   }
   return refcnt;
 }
 TCPSocketChild::TCPSocketChild()
 : mWindowObj(nullptr)
 {
 }
 NS_IMETHODIMP
 TCPSocketChild::SendOpen(nsITCPSocketInternal* aSocket,
                          const nsAString& aHost, uint16_t aPort,
                          bool aUseSSL, const nsAString& aBinaryType,
                          nsIDOMWindow* aWindow, JS::Handle<JS::Value> aWindowObj,
                          JSContext* aCx)
 {
   mSocket = aSocket;
   MOZ_ASSERT(aWindowObj.isObject());
   mWindowObj = js::CheckedUnwrap(&aWindowObj.toObject());
   if (!mWindowObj) {
     return NS_ERROR_FAILURE;
   }
   AddIPDLReference();
   gNeckoChild->SendPTCPSocketConstructor(this);
   PTCPSocketChild::SendOpen(nsString(aHost), aPort,
                             aUseSSL, nsString(aBinaryType));
   return NS_OK;
 }
 void
 TCPSocketChildBase::ReleaseIPDLReference()
 {
   MOZ_ASSERT(mIPCOpen);
   mIPCOpen = false;
   this->Release();
 }
 void
 TCPSocketChildBase::AddIPDLReference()
 {
   MOZ_ASSERT(!mIPCOpen);
   mIPCOpen = true;
   this->AddRef();
 }
 TCPSocketChild::~TCPSocketChild()
 {
 }
 bool
 TCPSocketChild::RecvUpdateBufferedAmount(const uint32_t& aBuffered,
                                          const uint32_t& aTrackingNumber)
 {
   if (NS_FAILED(mSocket->UpdateBufferedAmount(aBuffered, aTrackingNumber))) {
     NS_ERROR("Shouldn't fail!");
   }
   return true;
 }
 bool
 TCPSocketChild::RecvCallback(const nsString& aType,
                              const CallbackData& aData,
                              const nsString& aReadyState)
 {
   if (NS_FAILED(mSocket->UpdateReadyState(aReadyState)))
     NS_ERROR("Shouldn't fail!");
   nsresult rv = NS_ERROR_FAILURE;
   if (aData.type() == CallbackData::Tvoid_t) {
     rv = mSocket->CallListenerVoid(aType);
   } else if (aData.type() == CallbackData::TTCPError) {
     const TCPError& err(aData.get_TCPError());
     rv = mSocket->CallListenerError(aType, err.name());
   } else if (aData.type() == CallbackData::TSendableData) {
     const SendableData& data = aData.get_SendableData();
     if (data.type() == SendableData::TArrayOfuint8_t) {
       JSContext* cx = nsContentUtils::GetSafeJSContext();
       JSAutoRequest ar(cx);
       JS::Rooted<JS::Value> val(cx);
       JS::Rooted<JSObject*> window(cx, mWindowObj);
       bool ok = IPC::DeserializeArrayBuffer(window, data.get_ArrayOfuint8_t(), &val);
       NS_ENSURE_TRUE(ok, true);
       rv = mSocket->CallListenerArrayBuffer(aType, val);
     } else if (data.type() == SendableData::TnsString) {
       rv = mSocket->CallListenerData(aType, data.get_nsString());
     } else {
       MOZ_CRASH("Invalid callback data type!");
     }
   } else {
     MOZ_CRASH("Invalid callback type!");
   }
   NS_ENSURE_SUCCESS(rv, true);
   return true;
 }
 NS_IMETHODIMP
 TCPSocketChild::SendStartTLS()
 {
   PTCPSocketChild::SendStartTLS();
   return NS_OK;
 }
 NS_IMETHODIMP
 TCPSocketChild::SendSuspend()
 {
   PTCPSocketChild::SendSuspend();
   return NS_OK;
 }
 NS_IMETHODIMP
 TCPSocketChild::SendResume()
 {
   PTCPSocketChild::SendResume();
   return NS_OK;
 }
 NS_IMETHODIMP
 TCPSocketChild::SendClose()
 {
   PTCPSocketChild::SendClose();
   return NS_OK;
 }
 NS_IMETHODIMP
 TCPSocketChild::SendSend(JS::Handle<JS::Value> aData,
                          uint32_t aByteOffset,
                          uint32_t aByteLength,
                          uint32_t aTrackingNumber,
                          JSContext* aCx)
 {
   if (aData.isString()) {
     JSString* jsstr = aData.toString();
     nsDependentJSString str;
     bool ok = str.init(aCx, jsstr);
     NS_ENSURE_TRUE(ok, NS_ERROR_FAILURE);
     SendData(str, aTrackingNumber);
   } else {
     NS_ENSURE_TRUE(aData.isObject(), NS_ERROR_FAILURE);
     JS::Rooted<JSObject*> obj(aCx, &aData.toObject());
     NS_ENSURE_TRUE(JS_IsArrayBufferObject(obj), NS_ERROR_FAILURE);
     uint32_t buflen = JS_GetArrayBufferByteLength(obj);
     aByteOffset = std::min(buflen, aByteOffset);
     uint32_t nbytes = std::min(buflen - aByteOffset, aByteLength);
     uint8_t* data = JS_GetArrayBufferData(obj);
     if (!data) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
     FallibleTArray<uint8_t> fallibleArr;
     if (!fallibleArr.InsertElementsAt(0, data + aByteOffset, nbytes)) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
     InfallibleTArray<uint8_t> arr;
     arr.SwapElements(fallibleArr);
     SendData(arr, aTrackingNumber);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 TCPSocketChild::SetSocketAndWindow(nsITCPSocketInternal *aSocket,
                                    JS::Handle<JS::Value> aWindowObj,
                                    JSContext* aCx)
 {
   mSocket = aSocket;
   MOZ_ASSERT(aWindowObj.isObject());
   mWindowObj = js::CheckedUnwrap(&aWindowObj.toObject());
   if (!mWindowObj) {
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 bool
 TCPSocketChild::RecvRequestDelete()
 {
   mozilla::unused << Send__delete__(this);
   return true;
 }
 } // namespace dom
 } // namespace mozilla

The Tor Browser / annotate

dom/network/src/TCPSocketChild.cpp@b8a032363ba2 (annotated)

dom/network/src/TCPSocketChild.cpp