mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1569183: Remove some stuff from TCPSocket that NrTcpSocketIpc was the only user of. r=mayhemer 

Differential Revision: https://phabricator.services.mozilla.com/D45112

--HG--
extra : moz-landing-system : lando
This commit is contained in:
Byron Campen [:bwc] 2019-09-17 18:18:15 +00:00
Родитель 6c7a8c9a4e
Коммит 57de6c6130
7 изменённых файлов: 17 добавлений и 230 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

11
dom/network/PTCPSocket.ipdl
Просмотреть файл

@ -41,16 +41,7 @@ parent:
// |binaryType| (from TCPOption.binaryType).
async Open(nsString host, uint16_t port, bool useSSL, bool useArrayBuffers);
// Ask parent to open a socket and bind the newly-opened socket to a local
// address specified in |localAddr| and |localPort|.
async OpenBind(nsCString host, uint16_t port,
nsCString localAddr, uint16_t localPort,
bool useSSL, bool reuseAddrPort,
bool aUseArrayBuffers, nsCString aFilter);
// When child's send() is called, this message requrests parent to send
// data and update it's trackingNumber.
async Data(SendableData data, uint32_t trackingNumber);
async Data(SendableData data);
// Forward calling to child's upgradeToSecure() method to parent.
async StartTLS();

28
dom/network/TCPSocket.cpp
Просмотреть файл

@ -720,15 +720,6 @@ void TCPSocket::CloseHelper(bool waitForUnsentData) {
}
}
void TCPSocket::SendWithTrackingNumber(const nsACString& aData,
const uint32_t& aTrackingNumber,
mozilla::ErrorResult& aRv) {
MOZ_ASSERT(mSocketBridgeParent);
mTrackingNumber = aTrackingNumber;
// The JSContext isn't necessary for string values; it's a codegen limitation.
Send(nullptr, aData, aRv);
}
bool TCPSocket::Send(JSContext* aCx, const nsACString& aData,
mozilla::ErrorResult& aRv) {
if (mReadyState != TCPReadyState::Open) {
@ -739,7 +730,7 @@ bool TCPSocket::Send(JSContext* aCx, const nsACString& aData,
uint64_t byteLength;
nsCOMPtr<nsIInputStream> stream;
if (mSocketBridgeChild) {
mSocketBridgeChild->SendSend(aData, ++mTrackingNumber);
mSocketBridgeChild->SendSend(aData);
byteLength = aData.Length();
} else {
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(stream), aData);
@ -756,16 +747,6 @@ bool TCPSocket::Send(JSContext* aCx, const nsACString& aData,
return Send(stream, byteLength);
}
void TCPSocket::SendWithTrackingNumber(JSContext* aCx, const ArrayBuffer& aData,
uint32_t aByteOffset,
const Optional<uint32_t>& aByteLength,
const uint32_t& aTrackingNumber,
mozilla::ErrorResult& aRv) {
MOZ_ASSERT(mSocketBridgeParent);
mTrackingNumber = aTrackingNumber;
Send(aCx, aData, aByteOffset, aByteLength, aRv);
}
bool TCPSocket::Send(JSContext* aCx, const ArrayBuffer& aData,
uint32_t aByteOffset,
const Optional<uint32_t>& aByteLength,
@ -782,8 +763,7 @@ bool TCPSocket::Send(JSContext* aCx, const ArrayBuffer& aData,
aByteLength.WasPassed() ? aByteLength.Value() : aData.Length();
if (mSocketBridgeChild) {
nsresult rv = mSocketBridgeChild->SendSend(aData, aByteOffset, byteLength,
++mTrackingNumber);
nsresult rv = mSocketBridgeChild->SendSend(aData, aByteOffset, byteLength);
if (NS_WARN_IF(NS_FAILED(rv))) {
aRv.Throw(rv);
return false;
@ -820,6 +800,10 @@ bool TCPSocket::Send(nsIInputStream* aStream, uint32_t aByteLength) {
return !bufferFull;
}
// This is used to track how many packets we have been told to send. Signaling
// this back to the user of this API allows the user to know how many packets
// are currently in flight over IPC.
++mTrackingNumber;
if (mWaitingForStartTLS) {
// When we are waiting for starttls, newStream is added to pendingData
// and will be appended to multiplexStream after tls had been set up.

10
dom/network/TCPSocket.h
Просмотреть файл

@ -109,16 +109,6 @@ class TCPSocket final : public DOMEventTargetHelper,
const SocketOptions& aOptions,
ErrorResult& aRv);
// Perform a send operation that's asssociated with a sequence number. Used in
// IPC scenarios to track the number of bytes buffered at any given time.
void SendWithTrackingNumber(const nsACString& aData,
const uint32_t& aTrackingNumber,
ErrorResult& aRv);
void SendWithTrackingNumber(JSContext* aCx, const ArrayBuffer& aData,
uint32_t aByteOffset,
const Optional<uint32_t>& aByteLength,
const uint32_t& aTrackingNumber,
ErrorResult& aRv);
// Create a TCPSocket object from an existing low-level socket connection.
// Used by the TCPServerSocket implementation when a new connection is
// accepted.

47
dom/network/TCPSocketChild.cpp
Просмотреть файл

@ -96,30 +96,9 @@ void TCPSocketChild::SendOpen(nsITCPSocketCallback* aSocket, bool aUseSSL,
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;
@ -169,14 +148,12 @@ mozilla::ipc::IPCResult TCPSocketChild::RecvCallback(
return IPC_OK();
}
void TCPSocketChild::SendSend(const nsACString& aData,
uint32_t aTrackingNumber) {
SendData(nsCString(aData), aTrackingNumber);
void TCPSocketChild::SendSend(const nsACString& aData) {
SendData(nsCString(aData));
}
nsresult TCPSocketChild::SendSend(const ArrayBuffer& aData,
uint32_t aByteOffset, uint32_t aByteLength,
uint32_t aTrackingNumber) {
uint32_t aByteOffset, uint32_t aByteLength) {
uint32_t buflen = aData.Length();
uint32_t offset = std::min(buflen, aByteOffset);
uint32_t nbytes = std::min(buflen - aByteOffset, aByteLength);
@ -188,14 +165,7 @@ nsresult TCPSocketChild::SendSend(const ArrayBuffer& aData,
nsTArray<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);
SendData(arr);
return NS_OK;
}
@ -205,15 +175,6 @@ 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();

13
dom/network/TCPSocketChild.h
Просмотреть файл

@ -52,16 +52,9 @@ class TCPSocketChild : public mozilla::net::PTCPSocketChild,
void SendOpen(nsITCPSocketCallback* aSocket, bool aUseSSL,
bool aUseArrayBuffers);
void SendWindowlessOpenBind(nsITCPSocketCallback* aSocket,
const nsACString& aRemoteHost,
uint16_t aRemotePort,
const nsACString& aLocalHost, uint16_t aLocalPort,
bool aUseSSL, bool aUseRealtimeOptions);
NS_IMETHOD SendSendArray(nsTArray<uint8_t>& aArray, uint32_t aTrackingNumber);
void SendSend(const nsACString& aData, uint32_t aTrackingNumber);
void SendSend(const nsACString& aData);
nsresult SendSend(const ArrayBuffer& aData, uint32_t aByteOffset,
uint32_t aByteLength, uint32_t aTrackingNumber);
void SendSendArray(nsTArray<uint8_t>* arr, uint32_t trackingNumber);
uint32_t aByteLength);
void SetSocket(TCPSocket* aSocket);
void GetHost(nsAString& aHost);
@ -73,12 +66,10 @@ class TCPSocketChild : public mozilla::net::PTCPSocketChild,
mozilla::ipc::IPCResult RecvRequestDelete();
mozilla::ipc::IPCResult RecvUpdateBufferedAmount(
const uint32_t& aBufferred, const uint32_t& aTrackingNumber);
nsresult SetFilterName(const nsACString& aFilterName);
private:
nsString mHost;
uint16_t mPort;
nsCString mFilterName;
nsCOMPtr<nsIEventTarget> mIPCEventTarget;
};

126
dom/network/TCPSocketParent.cpp
Просмотреть файл

@ -43,16 +43,6 @@ using namespace net;
namespace dom {
static void FireInteralError(TCPSocketParent* aActor, uint32_t aLineNo) {
MOZ_ASSERT(aActor->IPCOpen());
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
@ -95,82 +85,6 @@ mozilla::ipc::IPCResult TCPSocketParent::RecvOpen(
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) {
AutoTArray<nsCString, 1> socketTypes = {NS_LITERAL_CSTRING("ssl")};
rv = sts->CreateTransport(socketTypes, aRemoteHost, aRemotePort, nullptr,
getter_AddRefs(socketTransport));
} else {
rv = sts->CreateTransport(nsTArray<nsCString>(), 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;
@ -199,27 +113,9 @@ mozilla::ipc::IPCResult TCPSocketParent::RecvResume() {
return IPC_OK();
}
mozilla::ipc::IPCResult TCPSocketParent::RecvData(
const SendableData& aData, const uint32_t& aTrackingNumber) {
mozilla::ipc::IPCResult TCPSocketParent::RecvData(const SendableData& aData) {
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 nsTArray<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;
@ -233,14 +129,13 @@ mozilla::ipc::IPCResult TCPSocketParent::RecvData(
return IPC_FAIL_NO_REASON(this);
}
Optional<uint32_t> byteLength(buffer.Length());
mSocket->SendWithTrackingNumber(autoCx, data, 0, byteLength,
aTrackingNumber, rv);
mSocket->Send(autoCx, data, 0, byteLength, rv);
break;
}
case SendableData::TnsCString: {
const nsCString& strData = aData.get_nsCString();
mSocket->SendWithTrackingNumber(strData, aTrackingNumber, rv);
mSocket->Send(nullptr, strData, rv);
break;
}
@ -274,19 +169,6 @@ void TCPSocketParent::FireArrayBufferDataEvent(nsTArray<uint8_t>& aBuffer,
nsTArray<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);
}
@ -295,8 +177,6 @@ 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);
}

12
dom/network/TCPSocketParent.h
Просмотреть файл

@ -55,18 +55,11 @@ class TCPSocketParent : public mozilla::net::PTCPSocketParent,
const bool& useSSL,
const bool& aUseArrayBuffers);
mozilla::ipc::IPCResult 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);
mozilla::ipc::IPCResult RecvStartTLS();
mozilla::ipc::IPCResult RecvSuspend();
mozilla::ipc::IPCResult RecvResume();
mozilla::ipc::IPCResult RecvClose();
mozilla::ipc::IPCResult RecvData(const SendableData& aData,
const uint32_t& aTrackingNumber);
mozilla::ipc::IPCResult RecvData(const SendableData& aData);
mozilla::ipc::IPCResult RecvRequestDelete();
void FireErrorEvent(const nsAString& aName, const nsAString& aType,
@ -84,9 +77,6 @@ class TCPSocketParent : public mozilla::net::PTCPSocketParent,
virtual void ActorDestroy(ActorDestroyReason why) override;
void SendEvent(const nsAString& aType, CallbackData aData,
TCPReadyState aReadyState);
nsresult SetFilter(const nsCString& aFilter);
nsCOMPtr<nsISocketFilter> mFilter;
};
} // namespace dom