nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity
fune/dom/network/UDPSocketParent.cpp
Nika Layzell 852d02ec16 Bug 1809753 - Part 3: Replace all callers of GetCurrentEventTarget with GetCurrentSerialEventTarget, r=mccr8,necko-reviewers,valentin 
This only changes the behaviour when called with a TaskQueue or other type
using SerialEventTargetGuard on the stack. They are being switched over as the
existing GetCurrentEventTarget method is being removed, as it is somewhat
confusing, and poorly documented.

Callers which need to get the current thread even when on a threadpool or
behind a TaskQueue were switched to GetCurrentEventTarget in the previous part.

Differential Revision: https://phabricator.services.mozilla.com/D166607
2023-01-16 23:14:11 +00:00

551 lines
16 KiB
C++
Raw Blame History

/* -*- 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 "UDPSocketParent.h"
#include "UDPSocket.h"
#include "nsComponentManagerUtils.h"
#include "nsIUDPSocket.h"
#include "nsINetAddr.h"
#include "nsNetCID.h"
#include "mozilla/Unused.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/ipc/InputStreamUtils.h"
#include "mozilla/net/DNS.h"
#include "mozilla/net/NeckoCommon.h"
#include "mozilla/net/PNeckoParent.h"
#include "nsIPermissionManager.h"
#include "mozilla/ipc/PBackgroundParent.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) {
MOZ_ASSERT_IF(mBackgroundManager, !aPrincipal);
// will be used once we move all UDPSocket to PBackground, or
// if we add in Principal checking for dom/media/webrtc/transport
Unused << mBackgroundManager;
mPrincipal = aPrincipal;
if (!aFilter.IsEmpty()) {
nsAutoCString contractId(NS_NETWORK_UDP_SOCKET_FILTER_HANDLER_PREFIX);
contractId.Append(aFilter);
nsCOMPtr<nsISocketFilterHandler> filterHandler =
do_GetService(contractId.get());
if (filterHandler) {
nsresult rv = filterHandler->NewFilter(getter_AddRefs(mFilter));
if (NS_FAILED(rv)) {
printf_stderr(
"Cannot create filter that content specified. "
"filter name: %s, error code: %u.",
aFilter.BeginReading(), static_cast<uint32_t>(rv));
return false;
}
} else {
printf_stderr(
"Content doesn't have a valid filter. "
"filter name: %s.",
aFilter.BeginReading());
return false;
}
}
return true;
}
// PUDPSocketParent methods
mozilla::ipc::IPCResult UDPSocketParent::RecvBind(
const UDPAddressInfo& aAddressInfo, const bool& aAddressReuse,
const bool& aLoopback, const uint32_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();
}
nsCOMPtr<nsINetAddr> localAddr;
mSocket->GetLocalAddr(getter_AddRefs(localAddr));
nsCString addr;
if (NS_FAILED(localAddr->GetAddress(addr))) {
FireInternalError(__LINE__);
return IPC_OK();
}
uint16_t port;
if (NS_FAILED(localAddr->GetPort(&port))) {
FireInternalError(__LINE__);
return IPC_OK();
}
UDPSOCKET_LOG(
("%s: SendCallbackOpened: %s:%u", __FUNCTION__, addr.get(), port));
mAddress = {addr, port};
mozilla::Unused << SendCallbackOpened(UDPAddressInfo(addr, port));
return IPC_OK();
}
nsresult UDPSocketParent::BindInternal(const nsCString& aHost,
const uint16_t& aPort,
const bool& aAddressReuse,
const bool& aLoopback,
const uint32_t& recvBufferSize,
const uint32_t& sendBufferSize) {
nsresult rv;
UDPSOCKET_LOG(
("%s: [this=%p] %s:%u addressReuse: %d loopback: %d recvBufferSize: "
"%" PRIu32 ", sendBufferSize: %" PRIu32,
__FUNCTION__, this, nsCString(aHost).get(), aPort, aAddressReuse,
aLoopback, recvBufferSize, sendBufferSize));
nsCOMPtr<nsIUDPSocket> sock =
do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (aHost.IsEmpty()) {
rv = sock->Init(aPort, false, mPrincipal, aAddressReuse,
/* optional_argc = */ 1);
} else {
PRNetAddr prAddr;
PR_InitializeNetAddr(PR_IpAddrAny, aPort, &prAddr);
PRStatus status = PR_StringToNetAddr(aHost.BeginReading(), &prAddr);
if (status != PR_SUCCESS) {
return NS_ERROR_FAILURE;
}
mozilla::net::NetAddr addr(&prAddr);
rv = sock->InitWithAddress(&addr, mPrincipal, aAddressReuse,
/* optional_argc = */ 1);
}
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
nsCOMPtr<nsINetAddr> laddr;
rv = sock->GetLocalAddr(getter_AddRefs(laddr));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
uint16_t family;
rv = laddr->GetFamily(&family);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (family == nsINetAddr::FAMILY_INET) {
rv = sock->SetMulticastLoopback(aLoopback);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
}
// TODO: once bug 1252759 is fixed query buffer first and only increase
if (recvBufferSize != 0) {
rv = sock->SetRecvBufferSize(recvBufferSize);
if (NS_WARN_IF(NS_FAILED(rv))) {
UDPSOCKET_LOG(
("%s: [this=%p] %s:%u failed to set recv buffer size to: %" PRIu32,
__FUNCTION__, this, nsCString(aHost).get(), aPort, recvBufferSize));
}
}
if (sendBufferSize != 0) {
rv = sock->SetSendBufferSize(sendBufferSize);
if (NS_WARN_IF(NS_FAILED(rv))) {
UDPSOCKET_LOG(
("%s: [this=%p] %s:%u failed to set send buffer size to: %" PRIu32,
__FUNCTION__, this, nsCString(aHost).get(), aPort, sendBufferSize));
}
}
// register listener
rv = sock->AsyncListen(this);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
mSocket = sock;
return NS_OK;
}
static nsCOMPtr<nsIEventTarget> GetSTSThread() {
nsresult rv;
nsCOMPtr<nsIEventTarget> sts_thread;
sts_thread = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
MOZ_ASSERT(NS_SUCCEEDED(rv));
return sts_thread;
}
static void CheckSTSThread() {
DebugOnly<nsCOMPtr<nsIEventTarget>> sts_thread = GetSTSThread();
ASSERT_ON_THREAD(sts_thread.value);
}
// Proxy the Connect() request to the STS thread, since it may block and
// should be done there.
mozilla::ipc::IPCResult UDPSocketParent::RecvConnect(
const UDPAddressInfo& aAddressInfo) {
nsCOMPtr<nsIEventTarget> target = GetCurrentSerialEventTarget();
Unused << NS_WARN_IF(NS_FAILED(GetSTSThread()->Dispatch(
WrapRunnable(RefPtr<UDPSocketParent>(this), &UDPSocketParent::DoConnect,
mSocket, target, aAddressInfo),
NS_DISPATCH_NORMAL)));
return IPC_OK();
}
void UDPSocketParent::DoSendConnectResponse(
const UDPAddressInfo& aAddressInfo) {
// can't use directly with WrapRunnable due to warnings
mozilla::Unused << SendCallbackConnected(aAddressInfo);
}
void UDPSocketParent::SendConnectResponse(
const nsCOMPtr<nsIEventTarget>& aThread,
const UDPAddressInfo& aAddressInfo) {
Unused << NS_WARN_IF(NS_FAILED(aThread->Dispatch(
WrapRunnable(RefPtr<UDPSocketParent>(this),
&UDPSocketParent::DoSendConnectResponse, aAddressInfo),
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__, aAddressInfo.addr().get(),
aAddressInfo.port()));
if (NS_FAILED(ConnectInternal(aAddressInfo.addr(), aAddressInfo.port()))) {
SendInternalError(aReturnThread, __LINE__);
return;
}
CheckSTSThread();
nsCOMPtr<nsINetAddr> localAddr;
aSocket->GetLocalAddr(getter_AddRefs(localAddr));
nsCString addr;
if (NS_FAILED(localAddr->GetAddress(addr))) {
SendInternalError(aReturnThread, __LINE__);
return;
}
uint16_t port;
if (NS_FAILED(localAddr->GetPort(&port))) {
SendInternalError(aReturnThread, __LINE__);
return;
}
UDPSOCKET_LOG(
("%s: SendConnectResponse: %s:%u", __FUNCTION__, addr.get(), port));
SendConnectResponse(aReturnThread, UDPAddressInfo(addr, port));
}
nsresult UDPSocketParent::ConnectInternal(const nsCString& aHost,
const uint16_t& aPort) {
nsresult rv;
UDPSOCKET_LOG(("%s: %s:%u", __FUNCTION__, nsCString(aHost).get(), aPort));
if (!mSocket) {
return NS_ERROR_NOT_AVAILABLE;
}
PRNetAddr prAddr;
memset(&prAddr, 0, sizeof(prAddr));
PR_InitializeNetAddr(PR_IpAddrAny, aPort, &prAddr);
PRStatus status = PR_StringToNetAddr(aHost.BeginReading(), &prAddr);
if (status != PR_SUCCESS) {
return NS_ERROR_FAILURE;
}
mozilla::net::NetAddr addr(&prAddr);
rv = mSocket->Connect(&addr);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
mozilla::ipc::IPCResult UDPSocketParent::RecvOutgoingData(
const UDPData& aData, const UDPSocketAddr& aAddr) {
if (!mSocket) {
NS_WARNING("sending socket is closed");
FireInternalError(__LINE__);
return IPC_OK();
}
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, &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 nsCString& aMulticastAddress, const nsCString& 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 nsCString& aMulticastAddress, const nsCString& 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;
mozilla::Unused << NS_WARN_IF(NS_FAILED(rv));
return IPC_OK();
}
mozilla::ipc::IPCResult UDPSocketParent::RecvRequestDelete() {
mozilla::Unused << 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
mozilla::Unused << 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) {
mozilla::Unused << SendCallbackClosed();
}
return NS_OK;
}
void UDPSocketParent::FireInternalError(uint32_t aLineNo) {
if (!mIPCOpen) {
return;
}
mozilla::Unused << SendCallbackError("Internal error"_ns,
nsLiteralCString(__FILE__), aLineNo);
}
void UDPSocketParent::SendInternalError(const nsCOMPtr<nsIEventTarget>& aThread,
uint32_t aLineNo) {
UDPSOCKET_LOG(("SendInternalError: %u", aLineNo));
Unused << NS_WARN_IF(NS_FAILED(aThread->Dispatch(
WrapRunnable(RefPtr<UDPSocketParent>(this),
&UDPSocketParent::FireInternalError, aLineNo),
NS_DISPATCH_NORMAL)));
}
} // namespace dom
} // namespace mozilla
View git blame Copy permalink