mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-22 01:35:35 +00:00
ace6d1063f
The inclusions were removed with the following very crude script and the
resulting breakage was fixed up by hand. The manual fixups did either
revert the changes done by the script, replace a generic header with a more
specific one or replace a header with a forward declaration.
find . -name "*.idl" | grep -v web-platform | grep -v third_party | while read path; do
interfaces=$(grep "^\(class\|interface\).*:.*" "$path" | cut -d' ' -f2)
if [ -n "$interfaces" ]; then
if [[ "$interfaces" == *$'\n'* ]]; then
regexp="\("
for i in $interfaces; do regexp="$regexp$i\|"; done
regexp="${regexp%%\\\|}\)"
else
regexp="$interfaces"
fi
interface=$(basename "$path")
rg -l "#include.*${interface%%.idl}.h" . | while read path2; do
hits=$(grep -v "#include.*${interface%%.idl}.h" "$path2" | grep -c "$regexp" )
if [ $hits -eq 0 ]; then
echo "Removing ${interface} from ${path2}"
grep -v "#include.*${interface%%.idl}.h" "$path2" > "$path2".tmp
mv -f "$path2".tmp "$path2"
fi
done
fi
done
Differential Revision: https://phabricator.services.mozilla.com/D55442
--HG--
extra : moz-landing-system : lando
567 lines
16 KiB
C++
567 lines
16 KiB
C++
/* -*- 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 "nsComponentManagerUtils.h"
|
|
#include "nsIUDPSocket.h"
|
|
#include "nsINetAddr.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 "mtransport/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() {}
|
|
|
|
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 mtransport
|
|
Unused << mBackgroundManager;
|
|
|
|
mPrincipal = aPrincipal;
|
|
if (net::UsingNeckoIPCSecurity() && mPrincipal &&
|
|
!ContentParent::IgnoreIPCPrincipal()) {
|
|
nsCOMPtr<nsIPermissionManager> permMgr = services::GetPermissionManager();
|
|
if (!permMgr) {
|
|
NS_WARNING("No PermissionManager available!");
|
|
return false;
|
|
}
|
|
|
|
uint32_t permission = nsIPermissionManager::DENY_ACTION;
|
|
permMgr->TestExactPermissionFromPrincipal(
|
|
mPrincipal, NS_LITERAL_CSTRING("udp-socket"), &permission);
|
|
if (permission != nsIPermissionManager::ALLOW_ACTION) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
// We don't have browser actors in xpcshell, and hence can't run automated
|
|
// tests without this loophole.
|
|
if (net::UsingNeckoIPCSecurity() && !mFilter &&
|
|
(!mPrincipal || ContentParent::IgnoreIPCPrincipal())) {
|
|
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));
|
|
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;
|
|
PRNetAddrToNetAddr(&prAddr, &addr);
|
|
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 = GetCurrentThreadEventTarget();
|
|
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(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(nsCOMPtr<nsIUDPSocket>& aSocket,
|
|
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;
|
|
PRNetAddrToNetAddr(&prAddr, &addr);
|
|
|
|
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());
|
|
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);
|
|
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;
|
|
infallibleArray.SwapElements(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(NS_LITERAL_CSTRING("Internal error"),
|
|
NS_LITERAL_CSTRING(__FILE__), aLineNo);
|
|
}
|
|
|
|
void UDPSocketParent::SendInternalError(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
|