2016-05-27 21:54:31 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
2011-06-03 18:33:56 +00:00
|
|
|
|
|
|
|
#include "base/process_util.h"
|
2016-10-11 21:25:17 +00:00
|
|
|
#include "base/task.h"
|
2011-06-03 18:33:56 +00:00
|
|
|
|
2016-04-01 06:33:52 +00:00
|
|
|
#ifdef OS_POSIX
|
|
|
|
# include <errno.h>
|
|
|
|
#endif
|
|
|
|
|
2016-12-14 16:32:21 +00:00
|
|
|
#include "mozilla/IntegerPrintfMacros.h"
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
#include "mozilla/ipc/ProtocolUtils.h"
|
2016-08-05 19:00:19 +00:00
|
|
|
|
|
|
|
#include "mozilla/ipc/MessageChannel.h"
|
2011-06-03 18:33:56 +00:00
|
|
|
#include "mozilla/ipc/Transport.h"
|
2018-07-22 11:51:30 +00:00
|
|
|
#include "mozilla/recordreplay/ChildIPC.h"
|
|
|
|
#include "mozilla/recordreplay/ParentIPC.h"
|
2015-03-23 21:34:38 +00:00
|
|
|
#include "mozilla/StaticMutex.h"
|
2017-05-10 19:52:20 +00:00
|
|
|
#include "mozilla/SystemGroup.h"
|
2016-11-02 04:05:38 +00:00
|
|
|
#include "mozilla/Unused.h"
|
2016-08-05 19:00:19 +00:00
|
|
|
#include "nsPrintfCString.h"
|
2011-06-03 18:33:56 +00:00
|
|
|
|
2015-04-01 08:40:35 +00:00
|
|
|
#if defined(MOZ_SANDBOX) && defined(XP_WIN)
|
|
|
|
# include "mozilla/sandboxTarget.h"
|
|
|
|
#endif
|
|
|
|
|
2017-10-10 10:06:35 +00:00
|
|
|
#if defined(XP_WIN)
|
2016-04-23 11:04:59 +00:00
|
|
|
# include "aclapi.h"
|
|
|
|
# include "sddl.h"
|
2016-05-06 11:01:29 +00:00
|
|
|
|
|
|
|
# include "mozilla/TypeTraits.h"
|
2016-04-19 11:08:55 +00:00
|
|
|
#endif
|
|
|
|
|
2016-06-07 20:10:18 +00:00
|
|
|
#include "nsAutoPtr.h"
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
using namespace IPC;
|
2011-06-03 18:33:56 +00:00
|
|
|
|
2015-04-01 08:40:35 +00:00
|
|
|
using base::GetCurrentProcId;
|
2015-02-11 20:01:26 +00:00
|
|
|
using base::ProcessHandle;
|
|
|
|
using base::ProcessId;
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
namespace mozilla {
|
2016-05-06 11:01:29 +00:00
|
|
|
|
2017-10-10 10:06:35 +00:00
|
|
|
#if defined(XP_WIN)
|
2016-05-06 11:01:29 +00:00
|
|
|
// Generate RAII classes for LPTSTR and PSECURITY_DESCRIPTOR.
|
|
|
|
MOZ_TYPE_SPECIFIC_SCOPED_POINTER_TEMPLATE(ScopedLPTStr,
|
|
|
|
RemovePointer<LPTSTR>::Type,
|
|
|
|
::LocalFree)
|
|
|
|
MOZ_TYPE_SPECIFIC_SCOPED_POINTER_TEMPLATE(
|
|
|
|
ScopedPSecurityDescriptor, RemovePointer<PSECURITY_DESCRIPTOR>::Type,
|
|
|
|
::LocalFree)
|
|
|
|
#endif
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
namespace ipc {
|
|
|
|
|
2016-11-15 03:26:00 +00:00
|
|
|
IPCResult IPCResult::Fail(NotNull<IProtocol*> actor, const char* where,
|
|
|
|
const char* why) {
|
|
|
|
// Calls top-level protocol to handle the error.
|
2018-04-23 18:13:36 +00:00
|
|
|
nsPrintfCString errorMsg("%s %s\n", where, why);
|
2016-11-15 03:26:00 +00:00
|
|
|
actor->GetIPCChannel()->Listener()->ProcessingError(
|
|
|
|
HasResultCodes::MsgProcessingError, errorMsg.get());
|
|
|
|
return IPCResult(false);
|
|
|
|
}
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
class ChannelOpened : public IPC::Message {
|
|
|
|
public:
|
|
|
|
ChannelOpened(TransportDescriptor aDescriptor, ProcessId aOtherProcess,
|
2014-12-19 01:35:48 +00:00
|
|
|
ProtocolId aProtocol,
|
2016-09-30 23:20:50 +00:00
|
|
|
NestedLevel aNestedLevel = NOT_NESTED)
|
2011-06-03 18:33:56 +00:00
|
|
|
: IPC::Message(MSG_ROUTING_CONTROL, // these only go to top-level actors
|
|
|
|
CHANNEL_OPENED_MESSAGE_TYPE, 0,
|
Bug 1397823 - part 3 - do a better job setting IPC::Message flags; r=kanru
The current IPC::Message constructor takes a large number of arguments,
three of which--the nesting level, the priority, and the
compression--are almost always constant by virtue of the vast majority
of Message construction being done by auto-generated IPDL code. But
then we take these constant values into the Message constructor, we
check them for various values, and then based on those values, we
perform a bunch of bitfield operations to store flags based on those
values. This is wasted work.
Furthermore, for replies to IPDL messages, we'll construct a Message
object, and then call mutating setters on the Message object that will
perform even more bitfield manipulations. Again, these operations are
performing tasks at runtime that are the same every single time, and use
information we already have at compile time.
The impact of these extra operations is not large, maybe 15-30K of extra
code, depending on platform. Nonetheless, we can easily make them go
away, and make everything cleaner to boot.
This patch adds a HeaderFlags class that encapsulates all the knowledge
about the various kinds of flags Message needs to know about. We can
construct HeaderFlags objects with strongly-typed enum arguments for the
various kinds of flags, and the compiler can take care of folding all of
those flags together into a constant when possible (and it is possible
for all the IPDL-generated code that instantiates Messages). The upshot
is that we do no unnecessary work in the Message constructor itself. We
can also remove various mutating operations on Message, as those
operations were only there to support post-constructor flag twiddling,
which is no longer necessary.
2017-09-15 12:06:11 +00:00
|
|
|
HeaderFlags(aNestedLevel)) {
|
2011-06-03 18:33:56 +00:00
|
|
|
IPC::WriteParam(this, aDescriptor);
|
|
|
|
IPC::WriteParam(this, aOtherProcess);
|
2012-09-17 08:37:20 +00:00
|
|
|
IPC::WriteParam(this, static_cast<uint32_t>(aProtocol));
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool Read(const IPC::Message& aMsg, TransportDescriptor* aDescriptor,
|
|
|
|
ProcessId* aOtherProcess, ProtocolId* aProtocol) {
|
2016-04-21 04:09:15 +00:00
|
|
|
PickleIterator iter(aMsg);
|
2011-06-03 18:33:56 +00:00
|
|
|
if (!IPC::ReadParam(&aMsg, &iter, aDescriptor) ||
|
|
|
|
!IPC::ReadParam(&aMsg, &iter, aOtherProcess) ||
|
2012-09-17 08:37:20 +00:00
|
|
|
!IPC::ReadParam(&aMsg, &iter, reinterpret_cast<uint32_t*>(aProtocol))) {
|
2011-06-03 18:33:56 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
aMsg.EndRead(iter);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
nsresult Bridge(const PrivateIPDLInterface&, MessageChannel* aParentChannel,
|
2015-04-01 08:40:35 +00:00
|
|
|
ProcessId aParentPid, MessageChannel* aChildChannel,
|
2013-08-20 19:46:41 +00:00
|
|
|
ProcessId aChildPid, ProtocolId aProtocol,
|
|
|
|
ProtocolId aChildProtocol) {
|
2015-04-01 08:40:35 +00:00
|
|
|
if (!aParentPid || !aChildPid) {
|
2015-07-10 00:07:49 +00:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TransportDescriptor parentSide, childSide;
|
2015-07-10 00:07:49 +00:00
|
|
|
nsresult rv;
|
|
|
|
if (NS_FAILED(rv = CreateTransport(aParentPid, &parentSide, &childSide))) {
|
|
|
|
return rv;
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!aParentChannel->Send(
|
|
|
|
new ChannelOpened(parentSide, aChildPid, aProtocol,
|
2016-09-30 23:20:50 +00:00
|
|
|
IPC::Message::NESTED_INSIDE_CPOW))) {
|
2011-06-03 18:33:56 +00:00
|
|
|
CloseDescriptor(parentSide);
|
|
|
|
CloseDescriptor(childSide);
|
2015-07-10 00:07:49 +00:00
|
|
|
return NS_ERROR_BRIDGE_OPEN_PARENT;
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
2015-07-10 00:07:49 +00:00
|
|
|
|
|
|
|
if (!aChildChannel->Send(
|
|
|
|
new ChannelOpened(childSide, aParentPid, aChildProtocol,
|
2016-09-30 23:20:50 +00:00
|
|
|
IPC::Message::NESTED_INSIDE_CPOW))) {
|
2015-07-10 00:07:49 +00:00
|
|
|
CloseDescriptor(parentSide);
|
|
|
|
CloseDescriptor(childSide);
|
|
|
|
return NS_ERROR_BRIDGE_OPEN_CHILD;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
bool Open(const PrivateIPDLInterface&, MessageChannel* aOpenerChannel,
|
2015-04-01 08:40:35 +00:00
|
|
|
ProcessId aOtherProcessId, Transport::Mode aOpenerMode,
|
2013-08-20 19:46:41 +00:00
|
|
|
ProtocolId aProtocol, ProtocolId aChildProtocol) {
|
2011-06-03 18:33:56 +00:00
|
|
|
bool isParent = (Transport::MODE_SERVER == aOpenerMode);
|
2015-04-01 08:40:35 +00:00
|
|
|
ProcessId thisPid = GetCurrentProcId();
|
|
|
|
ProcessId parentId = isParent ? thisPid : aOtherProcessId;
|
|
|
|
ProcessId childId = !isParent ? thisPid : aOtherProcessId;
|
2011-06-03 18:33:56 +00:00
|
|
|
if (!parentId || !childId) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
TransportDescriptor parentSide, childSide;
|
2015-07-10 00:07:49 +00:00
|
|
|
if (NS_FAILED(CreateTransport(parentId, &parentSide, &childSide))) {
|
2011-06-03 18:33:56 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Message* parentMsg = new ChannelOpened(parentSide, childId, aProtocol);
|
2013-08-20 19:46:41 +00:00
|
|
|
Message* childMsg = new ChannelOpened(childSide, parentId, aChildProtocol);
|
2011-06-03 18:33:56 +00:00
|
|
|
nsAutoPtr<Message> messageForUs(isParent ? parentMsg : childMsg);
|
|
|
|
nsAutoPtr<Message> messageForOtherSide(!isParent ? parentMsg : childMsg);
|
|
|
|
if (!aOpenerChannel->Echo(messageForUs.forget()) ||
|
|
|
|
!aOpenerChannel->Send(messageForOtherSide.forget())) {
|
|
|
|
CloseDescriptor(parentSide);
|
|
|
|
CloseDescriptor(childSide);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
bool UnpackChannelOpened(const PrivateIPDLInterface&, const Message& aMsg,
|
|
|
|
TransportDescriptor* aTransport,
|
|
|
|
ProcessId* aOtherProcess, ProtocolId* aProtocol) {
|
|
|
|
return ChannelOpened::Read(aMsg, aTransport, aOtherProcess, aProtocol);
|
|
|
|
}
|
|
|
|
|
2015-04-01 08:40:35 +00:00
|
|
|
#if defined(XP_WIN)
|
|
|
|
bool DuplicateHandle(HANDLE aSourceHandle, DWORD aTargetProcessId,
|
|
|
|
HANDLE* aTargetHandle, DWORD aDesiredAccess,
|
|
|
|
DWORD aOptions) {
|
|
|
|
// If our process is the target just duplicate the handle.
|
2015-04-01 12:59:20 +00:00
|
|
|
if (aTargetProcessId == base::GetCurrentProcId()) {
|
2015-04-01 08:40:35 +00:00
|
|
|
return !!::DuplicateHandle(::GetCurrentProcess(), aSourceHandle,
|
|
|
|
::GetCurrentProcess(), aTargetHandle,
|
|
|
|
aDesiredAccess, false, aOptions);
|
|
|
|
}
|
|
|
|
|
|
|
|
# if defined(MOZ_SANDBOX)
|
|
|
|
// Try the broker next (will fail if not sandboxed).
|
|
|
|
if (SandboxTarget::Instance()->BrokerDuplicateHandle(
|
|
|
|
aSourceHandle, aTargetProcessId, aTargetHandle, aDesiredAccess,
|
|
|
|
aOptions)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
# endif
|
|
|
|
|
|
|
|
// Finally, see if we already have access to the process.
|
2016-05-06 11:01:29 +00:00
|
|
|
ScopedProcessHandle targetProcess(
|
|
|
|
OpenProcess(PROCESS_DUP_HANDLE, FALSE, aTargetProcessId));
|
|
|
|
if (!targetProcess) {
|
|
|
|
CrashReporter::AnnotateCrashReport(
|
Bug 1348273 - Convert crash annotations into a machine-readable list of constants; r=ted.mielczarek,njn,dholbert,mak,cpearce,mcmanus,froydnj,Dexter,jrmuizel,jchen,jimm,bz,surkov
This introduces the machinery needed to generate crash annotations from a YAML
file. The relevant C++ functions are updated to take a typed enum. JavaScript
calls are unaffected but they will throw if the string argument does not
correspond to one of the known entries in the C++ enum. The existing whitelists
and blacklists of annotations are also generated from the YAML file and all
duplicate code related to them has been consolidated. Once written out to the
.extra file the annotations are converted in string form and are no different
than the existing ones.
All existing annotations have been included in the list (and some obsolete ones
have been removed) and all call sites have been updated including tests where
appropriate.
--HG--
extra : source : 4f6c43f2830701ec5552e08e3f1b06fe6d045860
2018-07-05 13:42:11 +00:00
|
|
|
CrashReporter::Annotation::IPCTransportFailureReason,
|
2016-05-06 11:01:29 +00:00
|
|
|
NS_LITERAL_CSTRING("Failed to open target process."));
|
2015-04-01 08:40:35 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !!::DuplicateHandle(::GetCurrentProcess(), aSourceHandle,
|
|
|
|
targetProcess, aTargetHandle, aDesiredAccess,
|
|
|
|
FALSE, aOptions);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-04-19 11:08:55 +00:00
|
|
|
void AnnotateSystemError() {
|
2016-04-01 06:33:52 +00:00
|
|
|
int64_t error = 0;
|
|
|
|
#if defined(XP_WIN)
|
|
|
|
error = ::GetLastError();
|
|
|
|
#elif defined(OS_POSIX)
|
|
|
|
error = errno;
|
|
|
|
#endif
|
|
|
|
if (error) {
|
2016-04-19 11:08:55 +00:00
|
|
|
CrashReporter::AnnotateCrashReport(
|
Bug 1348273 - Convert crash annotations into a machine-readable list of constants; r=ted.mielczarek,njn,dholbert,mak,cpearce,mcmanus,froydnj,Dexter,jrmuizel,jchen,jimm,bz,surkov
This introduces the machinery needed to generate crash annotations from a YAML
file. The relevant C++ functions are updated to take a typed enum. JavaScript
calls are unaffected but they will throw if the string argument does not
correspond to one of the known entries in the C++ enum. The existing whitelists
and blacklists of annotations are also generated from the YAML file and all
duplicate code related to them has been consolidated. Once written out to the
.extra file the annotations are converted in string form and are no different
than the existing ones.
All existing annotations have been included in the list (and some obsolete ones
have been removed) and all call sites have been updated including tests where
appropriate.
--HG--
extra : source : 4f6c43f2830701ec5552e08e3f1b06fe6d045860
2018-07-05 13:42:11 +00:00
|
|
|
CrashReporter::Annotation::IPCSystemError,
|
2016-12-14 16:32:21 +00:00
|
|
|
nsPrintfCString("%" PRId64, error));
|
2016-04-19 11:08:55 +00:00
|
|
|
}
|
|
|
|
}
|
2016-04-01 06:33:52 +00:00
|
|
|
|
2017-10-10 10:06:35 +00:00
|
|
|
#if defined(XP_MACOSX)
|
Bug 1348273 - Convert crash annotations into a machine-readable list of constants; r=ted.mielczarek,njn,dholbert,mak,cpearce,mcmanus,froydnj,Dexter,jrmuizel,jchen,jimm,bz,surkov
This introduces the machinery needed to generate crash annotations from a YAML
file. The relevant C++ functions are updated to take a typed enum. JavaScript
calls are unaffected but they will throw if the string argument does not
correspond to one of the known entries in the C++ enum. The existing whitelists
and blacklists of annotations are also generated from the YAML file and all
duplicate code related to them has been consolidated. Once written out to the
.extra file the annotations are converted in string form and are no different
than the existing ones.
All existing annotations have been included in the list (and some obsolete ones
have been removed) and all call sites have been updated including tests where
appropriate.
--HG--
extra : source : 4f6c43f2830701ec5552e08e3f1b06fe6d045860
2018-07-05 13:42:11 +00:00
|
|
|
void AnnotateCrashReportWithErrno(CrashReporter::Annotation tag, int error) {
|
|
|
|
CrashReporter::AnnotateCrashReport(tag, error);
|
2016-08-23 05:52:04 +00:00
|
|
|
}
|
Bug 1348273 - Convert crash annotations into a machine-readable list of constants; r=ted.mielczarek,njn,dholbert,mak,cpearce,mcmanus,froydnj,Dexter,jrmuizel,jchen,jimm,bz,surkov
This introduces the machinery needed to generate crash annotations from a YAML
file. The relevant C++ functions are updated to take a typed enum. JavaScript
calls are unaffected but they will throw if the string argument does not
correspond to one of the known entries in the C++ enum. The existing whitelists
and blacklists of annotations are also generated from the YAML file and all
duplicate code related to them has been consolidated. Once written out to the
.extra file the annotations are converted in string form and are no different
than the existing ones.
All existing annotations have been included in the list (and some obsolete ones
have been removed) and all call sites have been updated including tests where
appropriate.
--HG--
extra : source : 4f6c43f2830701ec5552e08e3f1b06fe6d045860
2018-07-05 13:42:11 +00:00
|
|
|
#endif // defined(XP_MACOSX)
|
2018-11-30 10:46:48 +00:00
|
|
|
|
2016-03-25 21:02:38 +00:00
|
|
|
void LogMessageForProtocol(const char* aTopLevelProtocol,
|
|
|
|
base::ProcessId aOtherPid,
|
|
|
|
const char* aContextDescription, uint32_t aMessageId,
|
|
|
|
MessageDirection aDirection) {
|
|
|
|
nsPrintfCString logMessage(
|
|
|
|
"[time: %" PRId64 "][%d%s%d] [%s] %s %s\n", PR_Now(),
|
|
|
|
base::GetCurrentProcId(),
|
|
|
|
aDirection == MessageDirection::eReceiving ? "<-" : "->", aOtherPid,
|
|
|
|
aTopLevelProtocol, aContextDescription,
|
2016-10-13 06:18:45 +00:00
|
|
|
StringFromIPCMessageType(aMessageId));
|
2016-03-25 21:02:38 +00:00
|
|
|
#ifdef ANDROID
|
|
|
|
__android_log_write(ANDROID_LOG_INFO, "GeckoIPC", logMessage.get());
|
|
|
|
#endif
|
|
|
|
fputs(logMessage.get(), stderr);
|
|
|
|
}
|
|
|
|
|
2013-07-24 16:38:24 +00:00
|
|
|
void ProtocolErrorBreakpoint(const char* aMsg) {
|
|
|
|
// Bugs that generate these error messages can be tough to
|
|
|
|
// reproduce. Log always in the hope that someone finds the error
|
|
|
|
// message.
|
|
|
|
printf_stderr("IPDL protocol error: %s\n", aMsg);
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:36 +00:00
|
|
|
void FatalError(const char* aMsg, bool aIsParent) {
|
2018-04-03 07:51:21 +00:00
|
|
|
#ifndef FUZZING
|
2013-08-22 14:39:32 +00:00
|
|
|
ProtocolErrorBreakpoint(aMsg);
|
2018-04-03 07:51:21 +00:00
|
|
|
#endif
|
2013-08-22 14:39:32 +00:00
|
|
|
|
2018-04-23 18:13:36 +00:00
|
|
|
nsAutoCString formattedMessage("IPDL error: \"");
|
2013-08-22 14:39:32 +00:00
|
|
|
formattedMessage.AppendASCII(aMsg);
|
|
|
|
if (aIsParent) {
|
2015-08-18 19:28:01 +00:00
|
|
|
// We're going to crash the parent process because at this time
|
|
|
|
// there's no other really nice way of getting a minidump out of
|
|
|
|
// this process if we're off the main thread.
|
|
|
|
formattedMessage.AppendLiteral("\". Intentionally crashing.");
|
2013-08-22 14:39:32 +00:00
|
|
|
NS_ERROR(formattedMessage.get());
|
Bug 1348273 - Convert crash annotations into a machine-readable list of constants; r=ted.mielczarek,njn,dholbert,mak,cpearce,mcmanus,froydnj,Dexter,jrmuizel,jchen,jimm,bz,surkov
This introduces the machinery needed to generate crash annotations from a YAML
file. The relevant C++ functions are updated to take a typed enum. JavaScript
calls are unaffected but they will throw if the string argument does not
correspond to one of the known entries in the C++ enum. The existing whitelists
and blacklists of annotations are also generated from the YAML file and all
duplicate code related to them has been consolidated. Once written out to the
.extra file the annotations are converted in string form and are no different
than the existing ones.
All existing annotations have been included in the list (and some obsolete ones
have been removed) and all call sites have been updated including tests where
appropriate.
--HG--
extra : source : 4f6c43f2830701ec5552e08e3f1b06fe6d045860
2018-07-05 13:42:11 +00:00
|
|
|
CrashReporter::AnnotateCrashReport(
|
|
|
|
CrashReporter::Annotation::IPCFatalErrorMsg, nsDependentCString(aMsg));
|
2016-04-01 06:33:52 +00:00
|
|
|
AnnotateSystemError();
|
2018-04-03 07:51:21 +00:00
|
|
|
#ifndef FUZZING
|
2015-08-18 19:28:01 +00:00
|
|
|
MOZ_CRASH("IPC FatalError in the parent process!");
|
2018-04-03 07:51:21 +00:00
|
|
|
#endif
|
2013-08-22 14:39:32 +00:00
|
|
|
} else {
|
|
|
|
formattedMessage.AppendLiteral("\". abort()ing as a result.");
|
2018-04-03 07:51:21 +00:00
|
|
|
#ifndef FUZZING
|
2019-02-03 08:09:37 +00:00
|
|
|
MOZ_CRASH_UNSAFE(formattedMessage.get());
|
2018-04-03 07:51:21 +00:00
|
|
|
#endif
|
2013-08-22 14:39:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-03 08:09:37 +00:00
|
|
|
void LogicError(const char* aMsg) { MOZ_CRASH_UNSAFE(aMsg); }
|
2016-04-06 14:53:06 +00:00
|
|
|
|
2016-05-21 08:07:56 +00:00
|
|
|
void ActorIdReadError(const char* aActorDescription) {
|
2018-04-05 19:47:34 +00:00
|
|
|
#ifndef FUZZING
|
2017-10-26 07:49:00 +00:00
|
|
|
MOZ_CRASH_UNSAFE_PRINTF("Error deserializing id for %s", aActorDescription);
|
2018-04-05 19:47:34 +00:00
|
|
|
#endif
|
2016-05-21 08:07:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void BadActorIdError(const char* aActorDescription) {
|
|
|
|
nsPrintfCString message("bad id for %s", aActorDescription);
|
|
|
|
ProtocolErrorBreakpoint(message.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
void ActorLookupError(const char* aActorDescription) {
|
|
|
|
nsPrintfCString message("could not lookup id for %s", aActorDescription);
|
|
|
|
ProtocolErrorBreakpoint(message.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
void MismatchedActorTypeError(const char* aActorDescription) {
|
|
|
|
nsPrintfCString message("actor that should be of type %s has different type",
|
|
|
|
aActorDescription);
|
|
|
|
ProtocolErrorBreakpoint(message.get());
|
|
|
|
}
|
|
|
|
|
2016-05-21 08:07:56 +00:00
|
|
|
void UnionTypeReadError(const char* aUnionName) {
|
2017-10-26 07:49:00 +00:00
|
|
|
MOZ_CRASH_UNSAFE_PRINTF("error deserializing type of union %s", aUnionName);
|
2016-05-21 08:07:56 +00:00
|
|
|
}
|
|
|
|
|
2017-03-09 21:37:55 +00:00
|
|
|
void ArrayLengthReadError(const char* aElementName) {
|
2017-10-26 07:49:00 +00:00
|
|
|
MOZ_CRASH_UNSAFE_PRINTF("error deserializing length of %s[]", aElementName);
|
2016-05-21 08:07:56 +00:00
|
|
|
}
|
|
|
|
|
2017-03-09 21:37:55 +00:00
|
|
|
void SentinelReadError(const char* aClassName) {
|
2017-10-26 07:49:00 +00:00
|
|
|
MOZ_CRASH_UNSAFE_PRINTF("incorrect sentinel when reading %s", aClassName);
|
2017-03-09 21:37:55 +00:00
|
|
|
}
|
|
|
|
|
2018-08-27 18:20:17 +00:00
|
|
|
bool StateTransition(bool aIsDelete, LivenessState* aNext) {
|
2018-04-30 21:10:27 +00:00
|
|
|
switch (*aNext) {
|
2018-08-27 18:20:17 +00:00
|
|
|
case LivenessState::Null:
|
2018-04-30 21:10:27 +00:00
|
|
|
if (aIsDelete) {
|
2018-08-27 18:20:17 +00:00
|
|
|
*aNext = LivenessState::Dead;
|
2018-04-30 21:10:27 +00:00
|
|
|
}
|
|
|
|
break;
|
2018-08-27 18:20:17 +00:00
|
|
|
case LivenessState::Dead:
|
2018-05-03 16:08:48 +00:00
|
|
|
return false;
|
2018-04-30 21:10:27 +00:00
|
|
|
default:
|
2018-05-03 16:08:48 +00:00
|
|
|
return false;
|
2018-04-30 21:10:27 +00:00
|
|
|
}
|
2018-05-03 16:08:48 +00:00
|
|
|
return true;
|
2018-04-30 21:10:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool ReEntrantDeleteStateTransition(bool aIsDelete, bool aIsDeleteReply,
|
2018-08-27 18:20:17 +00:00
|
|
|
ReEntrantDeleteLivenessState* aNext) {
|
2018-04-30 21:10:27 +00:00
|
|
|
switch (*aNext) {
|
2018-08-27 18:20:17 +00:00
|
|
|
case ReEntrantDeleteLivenessState::Null:
|
2018-04-30 21:10:27 +00:00
|
|
|
if (aIsDelete) {
|
2018-08-27 18:20:17 +00:00
|
|
|
*aNext = ReEntrantDeleteLivenessState::Dying;
|
2018-04-30 21:10:27 +00:00
|
|
|
}
|
|
|
|
break;
|
2018-08-27 18:20:17 +00:00
|
|
|
case ReEntrantDeleteLivenessState::Dead:
|
2018-05-03 16:08:48 +00:00
|
|
|
return false;
|
2018-08-27 18:20:17 +00:00
|
|
|
case ReEntrantDeleteLivenessState::Dying:
|
2018-04-30 21:10:27 +00:00
|
|
|
if (aIsDeleteReply) {
|
2018-08-27 18:20:17 +00:00
|
|
|
*aNext = ReEntrantDeleteLivenessState::Dead;
|
2018-04-30 21:10:27 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2018-05-03 16:08:48 +00:00
|
|
|
return false;
|
2018-04-30 21:10:27 +00:00
|
|
|
}
|
2018-05-03 16:08:48 +00:00
|
|
|
return true;
|
2018-04-30 21:10:27 +00:00
|
|
|
}
|
|
|
|
|
2016-08-30 00:41:22 +00:00
|
|
|
void TableToArray(const nsTHashtable<nsPtrHashKey<void>>& aTable,
|
|
|
|
nsTArray<void*>& aArray) {
|
|
|
|
uint32_t i = 0;
|
|
|
|
void** elements = aArray.AppendElements(aTable.Count());
|
|
|
|
for (auto iter = aTable.ConstIter(); !iter.Done(); iter.Next()) {
|
|
|
|
elements[i] = iter.Get()->GetKey();
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-29 04:26:21 +00:00
|
|
|
Maybe<IProtocol*> IProtocol::ReadActor(const IPC::Message* aMessage,
|
|
|
|
PickleIterator* aIter, bool aNullable,
|
|
|
|
const char* aActorDescription,
|
|
|
|
int32_t aProtocolTypeId) {
|
|
|
|
int32_t id;
|
|
|
|
if (!IPC::ReadParam(aMessage, aIter, &id)) {
|
|
|
|
ActorIdReadError(aActorDescription);
|
|
|
|
return Nothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id == 1 || (id == 0 && !aNullable)) {
|
|
|
|
BadActorIdError(aActorDescription);
|
|
|
|
return Nothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id == 0) {
|
|
|
|
return Some(static_cast<IProtocol*>(nullptr));
|
|
|
|
}
|
|
|
|
|
|
|
|
IProtocol* listener = this->Lookup(id);
|
|
|
|
if (!listener) {
|
|
|
|
ActorLookupError(aActorDescription);
|
|
|
|
return Nothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (listener->GetProtocolTypeId() != aProtocolTypeId) {
|
|
|
|
MismatchedActorTypeError(aActorDescription);
|
|
|
|
return Nothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
return Some(listener);
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
int32_t IProtocol::ManagedState::Register(IProtocol* aRouted) {
|
|
|
|
return mProtocol->Manager()->Register(aRouted);
|
2016-10-31 22:08:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
int32_t IProtocol::ManagedState::RegisterID(IProtocol* aRouted, int32_t aId) {
|
|
|
|
return mProtocol->Manager()->RegisterID(aRouted, aId);
|
2016-10-31 22:08:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
IProtocol* IProtocol::ManagedState::Lookup(int32_t aId) {
|
|
|
|
return mProtocol->Manager()->Lookup(aId);
|
2016-10-31 22:08:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
void IProtocol::ManagedState::Unregister(int32_t aId) {
|
|
|
|
if (mProtocol->mId == aId) {
|
|
|
|
mProtocol->mId = kFreedActorId;
|
2016-10-29 03:46:59 +00:00
|
|
|
}
|
2018-04-23 18:13:37 +00:00
|
|
|
mProtocol->Manager()->Unregister(aId);
|
2016-10-31 22:08:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
Shmem::SharedMemory* IProtocol::ManagedState::CreateSharedMemory(
|
|
|
|
size_t aSize, SharedMemory::SharedMemoryType aType, bool aUnsafe,
|
|
|
|
int32_t* aId) {
|
|
|
|
return mProtocol->Manager()->CreateSharedMemory(aSize, aType, aUnsafe, aId);
|
2016-10-31 22:08:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
Shmem::SharedMemory* IProtocol::ManagedState::LookupSharedMemory(int32_t aId) {
|
|
|
|
return mProtocol->Manager()->LookupSharedMemory(aId);
|
2016-10-31 22:08:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
bool IProtocol::ManagedState::IsTrackingSharedMemory(
|
|
|
|
Shmem::SharedMemory* aSegment) {
|
|
|
|
return mProtocol->Manager()->IsTrackingSharedMemory(aSegment);
|
2016-10-31 22:08:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
bool IProtocol::ManagedState::DestroySharedMemory(Shmem& aShmem) {
|
|
|
|
return mProtocol->Manager()->DestroySharedMemory(aShmem);
|
2016-10-31 22:08:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:36 +00:00
|
|
|
const MessageChannel* IProtocol::ManagedState::GetIPCChannel() const {
|
|
|
|
return mChannel;
|
|
|
|
}
|
|
|
|
|
|
|
|
MessageChannel* IProtocol::ManagedState::GetIPCChannel() { return mChannel; }
|
|
|
|
|
2016-10-31 22:08:00 +00:00
|
|
|
ProcessId IProtocol::OtherPid() const { return Manager()->OtherPid(); }
|
|
|
|
|
2016-11-01 16:10:42 +00:00
|
|
|
void IProtocol::FatalError(const char* const aErrorMsg) const {
|
2018-04-23 18:13:36 +00:00
|
|
|
HandleFatalError(aErrorMsg);
|
2016-11-01 16:10:42 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:36 +00:00
|
|
|
void IProtocol::HandleFatalError(const char* aErrorMsg) const {
|
2016-11-01 16:10:42 +00:00
|
|
|
if (IProtocol* manager = Manager()) {
|
2018-04-23 18:13:36 +00:00
|
|
|
manager->HandleFatalError(aErrorMsg);
|
2016-11-01 16:10:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:36 +00:00
|
|
|
mozilla::ipc::FatalError(aErrorMsg, mSide == ParentSide);
|
2016-11-01 16:10:42 +00:00
|
|
|
}
|
|
|
|
|
2016-10-31 23:00:00 +00:00
|
|
|
bool IProtocol::AllocShmem(size_t aSize,
|
|
|
|
Shmem::SharedMemory::SharedMemoryType aType,
|
|
|
|
Shmem* aOutMem) {
|
|
|
|
Shmem::id_t id;
|
|
|
|
Shmem::SharedMemory* rawmem(CreateSharedMemory(aSize, aType, false, &id));
|
|
|
|
if (!rawmem) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-04-17 14:05:30 +00:00
|
|
|
*aOutMem = Shmem(Shmem::PrivateIPDLCaller(), rawmem, id);
|
2016-10-31 23:00:00 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IProtocol::AllocUnsafeShmem(size_t aSize,
|
|
|
|
Shmem::SharedMemory::SharedMemoryType aType,
|
|
|
|
Shmem* aOutMem) {
|
|
|
|
Shmem::id_t id;
|
|
|
|
Shmem::SharedMemory* rawmem(CreateSharedMemory(aSize, aType, true, &id));
|
|
|
|
if (!rawmem) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-04-17 14:05:30 +00:00
|
|
|
*aOutMem = Shmem(Shmem::PrivateIPDLCaller(), rawmem, id);
|
2016-10-31 23:00:00 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IProtocol::DeallocShmem(Shmem& aMem) {
|
|
|
|
bool ok = DestroySharedMemory(aMem);
|
|
|
|
#ifdef DEBUG
|
|
|
|
if (!ok) {
|
|
|
|
if (mSide == ChildSide) {
|
|
|
|
FatalError("bad Shmem");
|
|
|
|
} else {
|
|
|
|
NS_WARNING("bad Shmem");
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif // DEBUG
|
2018-04-17 14:05:30 +00:00
|
|
|
aMem.forget(Shmem::PrivateIPDLCaller());
|
2016-10-31 23:00:00 +00:00
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
void IProtocol::SetManager(IProtocol* aManager) {
|
|
|
|
MOZ_RELEASE_ASSERT(!mManager || mManager == aManager);
|
|
|
|
mManager = aManager;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
void IProtocol::SetManagerAndRegister(IProtocol* aManager) {
|
|
|
|
// Set the manager prior to registering so registering properly inherits
|
|
|
|
// the manager's event target.
|
|
|
|
SetManager(aManager);
|
|
|
|
|
|
|
|
aManager->Register(this);
|
|
|
|
|
2018-04-23 18:13:36 +00:00
|
|
|
mState->SetIPCChannel(aManager->GetIPCChannel());
|
2018-04-23 18:13:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void IProtocol::SetManagerAndRegister(IProtocol* aManager, int32_t aId) {
|
|
|
|
// Set the manager prior to registering so registering properly inherits
|
|
|
|
// the manager's event target.
|
|
|
|
SetManager(aManager);
|
|
|
|
|
|
|
|
aManager->RegisterID(this, aId);
|
|
|
|
|
2018-04-23 18:13:36 +00:00
|
|
|
mState->SetIPCChannel(aManager->GetIPCChannel());
|
2018-04-23 18:13:37 +00:00
|
|
|
}
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
void IProtocol::SetEventTargetForActor(IProtocol* aActor,
|
|
|
|
nsIEventTarget* aEventTarget) {
|
|
|
|
// Make sure we have a manager for the internal method to access.
|
|
|
|
aActor->SetManager(this);
|
2018-04-23 18:13:37 +00:00
|
|
|
mState->SetEventTargetForActor(aActor, aEventTarget);
|
2016-10-29 03:46:59 +00:00
|
|
|
}
|
|
|
|
|
2017-03-21 03:57:56 +00:00
|
|
|
void IProtocol::ReplaceEventTargetForActor(IProtocol* aActor,
|
|
|
|
nsIEventTarget* aEventTarget) {
|
|
|
|
// Ensure the actor has been registered.
|
|
|
|
MOZ_ASSERT(aActor->Manager());
|
2018-04-23 18:13:37 +00:00
|
|
|
mState->ReplaceEventTargetForActor(aActor, aEventTarget);
|
2017-03-21 03:57:56 +00:00
|
|
|
}
|
|
|
|
|
2019-04-17 00:51:32 +00:00
|
|
|
void IProtocol::SetEventTargetForRoute(int32_t aRoute,
|
|
|
|
nsIEventTarget* aEventTarget) {
|
|
|
|
mState->SetEventTargetForRoute(aRoute, aEventTarget);
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
nsIEventTarget* IProtocol::GetActorEventTarget() {
|
|
|
|
return mState->GetActorEventTarget();
|
2016-10-29 03:46:59 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
already_AddRefed<nsIEventTarget> IProtocol::GetActorEventTarget(
|
|
|
|
IProtocol* aActor) {
|
|
|
|
return mState->GetActorEventTarget(aActor);
|
2017-03-21 03:57:56 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
nsIEventTarget* IProtocol::ManagedState::GetActorEventTarget() {
|
2017-02-13 06:04:58 +00:00
|
|
|
// We should only call this function when this actor has been registered and
|
|
|
|
// is not unregistered yet.
|
2018-04-23 18:13:37 +00:00
|
|
|
MOZ_RELEASE_ASSERT(mProtocol->mId != kNullActorId &&
|
|
|
|
mProtocol->mId != kFreedActorId);
|
|
|
|
RefPtr<nsIEventTarget> target = GetActorEventTarget(mProtocol);
|
2017-02-13 06:04:58 +00:00
|
|
|
return target;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
void IProtocol::ManagedState::SetEventTargetForActor(
|
|
|
|
IProtocol* aActor, nsIEventTarget* aEventTarget) {
|
|
|
|
// Go directly through the state so we don't try to redundantly (and
|
|
|
|
// wrongly) call SetManager() on aActor.
|
|
|
|
mProtocol->Manager()->mState->SetEventTargetForActor(aActor, aEventTarget);
|
|
|
|
}
|
|
|
|
|
|
|
|
void IProtocol::ManagedState::ReplaceEventTargetForActor(
|
|
|
|
IProtocol* aActor, nsIEventTarget* aEventTarget) {
|
|
|
|
mProtocol->Manager()->ReplaceEventTargetForActor(aActor, aEventTarget);
|
|
|
|
}
|
|
|
|
|
2019-04-17 00:51:32 +00:00
|
|
|
void IProtocol::ManagedState::SetEventTargetForRoute(
|
|
|
|
int32_t aRoute, nsIEventTarget* aEventTarget) {
|
|
|
|
mProtocol->Manager()->SetEventTargetForRoute(aRoute, aEventTarget);
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
already_AddRefed<nsIEventTarget> IProtocol::ManagedState::GetActorEventTarget(
|
|
|
|
IProtocol* aActor) {
|
|
|
|
return mProtocol->Manager()->GetActorEventTarget(aActor);
|
2017-02-13 06:04:58 +00:00
|
|
|
}
|
|
|
|
|
2018-06-14 05:48:43 +00:00
|
|
|
IToplevelProtocol::IToplevelProtocol(const char* aName, ProtocolId aProtoId,
|
|
|
|
Side aSide)
|
|
|
|
: IProtocol(aSide, MakeUnique<ToplevelState>(aName, this, aSide)),
|
|
|
|
mProtocolId(aProtoId),
|
|
|
|
mOtherPid(mozilla::ipc::kInvalidProcessId),
|
|
|
|
mIsMainThreadProtocol(false) {}
|
2016-11-02 00:02:48 +00:00
|
|
|
|
|
|
|
IToplevelProtocol::~IToplevelProtocol() {
|
2018-08-21 21:37:42 +00:00
|
|
|
mState = nullptr;
|
2016-11-02 00:02:48 +00:00
|
|
|
if (mTrans) {
|
|
|
|
RefPtr<DeleteTask<Transport>> task =
|
|
|
|
new DeleteTask<Transport>(mTrans.release());
|
|
|
|
XRE_GetIOMessageLoop()->PostTask(task.forget());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
base::ProcessId IToplevelProtocol::OtherPid() const {
|
2018-03-12 17:06:33 +00:00
|
|
|
base::ProcessId pid = OtherPidMaybeInvalid();
|
|
|
|
MOZ_RELEASE_ASSERT(pid != kInvalidProcessId);
|
|
|
|
return pid;
|
2018-03-13 16:54:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
base::ProcessId IToplevelProtocol::OtherPidMaybeInvalid() const {
|
2016-11-02 00:02:48 +00:00
|
|
|
return mOtherPid;
|
|
|
|
}
|
|
|
|
|
2018-11-28 20:42:24 +00:00
|
|
|
void IToplevelProtocol::SetOtherProcessId(base::ProcessId aOtherPid) {
|
2018-07-22 11:51:30 +00:00
|
|
|
// When recording an execution, all communication we do is forwarded from
|
|
|
|
// the middleman to the parent process, so use its pid instead of the
|
|
|
|
// middleman's pid.
|
|
|
|
if (recordreplay::IsRecordingOrReplaying() &&
|
|
|
|
aOtherPid == recordreplay::child::MiddlemanProcessId()) {
|
|
|
|
mOtherPid = recordreplay::child::ParentProcessId();
|
|
|
|
} else {
|
|
|
|
mOtherPid = aOtherPid;
|
|
|
|
}
|
2016-11-02 00:02:48 +00:00
|
|
|
}
|
|
|
|
|
2016-11-01 23:58:33 +00:00
|
|
|
bool IToplevelProtocol::Open(mozilla::ipc::Transport* aTransport,
|
|
|
|
base::ProcessId aOtherPid, MessageLoop* aThread,
|
|
|
|
mozilla::ipc::Side aSide) {
|
|
|
|
SetOtherProcessId(aOtherPid);
|
|
|
|
return GetIPCChannel()->Open(aTransport, aThread, aSide);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IToplevelProtocol::Open(MessageChannel* aChannel,
|
|
|
|
MessageLoop* aMessageLoop,
|
|
|
|
mozilla::ipc::Side aSide) {
|
|
|
|
SetOtherProcessId(base::GetCurrentProcId());
|
2017-08-03 09:21:44 +00:00
|
|
|
return GetIPCChannel()->Open(aChannel, aMessageLoop->SerialEventTarget(),
|
|
|
|
aSide);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IToplevelProtocol::Open(MessageChannel* aChannel,
|
|
|
|
nsIEventTarget* aEventTarget,
|
|
|
|
mozilla::ipc::Side aSide) {
|
|
|
|
SetOtherProcessId(base::GetCurrentProcId());
|
|
|
|
return GetIPCChannel()->Open(aChannel, aEventTarget, aSide);
|
2016-11-01 23:58:33 +00:00
|
|
|
}
|
|
|
|
|
2018-02-16 15:24:21 +00:00
|
|
|
bool IToplevelProtocol::OpenWithAsyncPid(mozilla::ipc::Transport* aTransport,
|
|
|
|
MessageLoop* aThread,
|
|
|
|
mozilla::ipc::Side aSide) {
|
|
|
|
return GetIPCChannel()->Open(aTransport, aThread, aSide);
|
|
|
|
}
|
|
|
|
|
2018-08-29 22:00:05 +00:00
|
|
|
bool IToplevelProtocol::OpenOnSameThread(MessageChannel* aChannel, Side aSide) {
|
|
|
|
SetOtherProcessId(base::GetCurrentProcId());
|
|
|
|
return GetIPCChannel()->OpenOnSameThread(aChannel, aSide);
|
|
|
|
}
|
|
|
|
|
2016-11-01 23:58:33 +00:00
|
|
|
void IToplevelProtocol::Close() { GetIPCChannel()->Close(); }
|
|
|
|
|
|
|
|
void IToplevelProtocol::SetReplyTimeoutMs(int32_t aTimeoutMs) {
|
|
|
|
GetIPCChannel()->SetReplyTimeoutMs(aTimeoutMs);
|
|
|
|
}
|
|
|
|
|
2016-11-01 23:50:07 +00:00
|
|
|
bool IToplevelProtocol::IsOnCxxStack() const {
|
|
|
|
return GetIPCChannel()->IsOnCxxStack();
|
|
|
|
}
|
|
|
|
|
2018-12-04 22:18:31 +00:00
|
|
|
int32_t IToplevelProtocol::ToplevelState::NextId() {
|
|
|
|
// Genreate the next ID to use for a shared memory or protocol. Parent and
|
|
|
|
// Child sides of the protocol use different pools, and actors created in the
|
|
|
|
// middleman need to use a distinct pool as well.
|
|
|
|
int32_t tag = 0;
|
|
|
|
if (recordreplay::IsMiddleman()) {
|
|
|
|
tag |= 1 << 0;
|
|
|
|
}
|
|
|
|
if (mProtocol->GetSide() == ParentSide) {
|
|
|
|
tag |= 1 << 1;
|
|
|
|
}
|
|
|
|
|
2019-03-22 19:06:02 +00:00
|
|
|
// Check any overflow
|
|
|
|
MOZ_RELEASE_ASSERT(mLastLocalId < (1 << 29));
|
|
|
|
|
2018-12-04 22:18:31 +00:00
|
|
|
// Compute the ID to use with the low two bits as our tag, and the remaining
|
|
|
|
// bits as a monotonic.
|
|
|
|
return (++mLastLocalId << 2) | tag;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
int32_t IToplevelProtocol::ToplevelState::Register(IProtocol* aRouted) {
|
2016-10-29 03:46:59 +00:00
|
|
|
if (aRouted->Id() != kNullActorId && aRouted->Id() != kFreedActorId) {
|
|
|
|
// If there's already an ID, just return that.
|
|
|
|
return aRouted->Id();
|
|
|
|
}
|
2018-12-04 22:18:31 +00:00
|
|
|
int32_t id = NextId();
|
2016-11-02 03:55:23 +00:00
|
|
|
mActorMap.AddWithID(aRouted, id);
|
2016-10-29 03:46:59 +00:00
|
|
|
aRouted->SetId(id);
|
|
|
|
|
|
|
|
// Inherit our event target from our manager.
|
|
|
|
if (IProtocol* manager = aRouted->Manager()) {
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
if (nsCOMPtr<nsIEventTarget> target =
|
|
|
|
mEventTargetMap.Lookup(manager->Id())) {
|
|
|
|
mEventTargetMap.AddWithID(target, id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-02 03:55:23 +00:00
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
int32_t IToplevelProtocol::ToplevelState::RegisterID(IProtocol* aRouted,
|
|
|
|
int32_t aId) {
|
2016-11-02 03:55:23 +00:00
|
|
|
mActorMap.AddWithID(aRouted, aId);
|
2016-10-29 03:46:59 +00:00
|
|
|
aRouted->SetId(aId);
|
2016-11-02 03:55:23 +00:00
|
|
|
return aId;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
IProtocol* IToplevelProtocol::ToplevelState::Lookup(int32_t aId) {
|
2016-11-02 03:55:23 +00:00
|
|
|
return mActorMap.Lookup(aId);
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
void IToplevelProtocol::ToplevelState::Unregister(int32_t aId) {
|
2016-10-29 03:46:59 +00:00
|
|
|
mActorMap.Remove(aId);
|
|
|
|
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
mEventTargetMap.RemoveIfPresent(aId);
|
2016-11-02 03:55:23 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:36 +00:00
|
|
|
IToplevelProtocol::ToplevelState::ToplevelState(const char* aName,
|
|
|
|
IToplevelProtocol* aProtocol,
|
|
|
|
Side aSide)
|
|
|
|
: ProtocolState(),
|
|
|
|
mProtocol(aProtocol),
|
2018-12-04 22:18:31 +00:00
|
|
|
mLastLocalId(0),
|
2018-04-23 18:13:37 +00:00
|
|
|
mEventTargetMutex("ProtocolEventTargetMutex"),
|
2018-04-23 18:13:36 +00:00
|
|
|
mChannel(aName, aProtocol) {}
|
2018-11-30 10:46:48 +00:00
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
Shmem::SharedMemory* IToplevelProtocol::ToplevelState::CreateSharedMemory(
|
|
|
|
size_t aSize, Shmem::SharedMemory::SharedMemoryType aType, bool aUnsafe,
|
|
|
|
Shmem::id_t* aId) {
|
|
|
|
// XXX the mProtocol uses here should go away!
|
2016-11-02 04:05:38 +00:00
|
|
|
RefPtr<Shmem::SharedMemory> segment(
|
2018-04-17 14:05:30 +00:00
|
|
|
Shmem::Alloc(Shmem::PrivateIPDLCaller(), aSize, aType, aUnsafe));
|
2016-11-02 04:05:38 +00:00
|
|
|
if (!segment) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
2018-12-04 22:18:31 +00:00
|
|
|
int32_t id = NextId();
|
2018-04-17 14:05:30 +00:00
|
|
|
Shmem shmem(Shmem::PrivateIPDLCaller(), segment.get(), id);
|
2018-03-13 16:54:35 +00:00
|
|
|
|
|
|
|
base::ProcessId pid =
|
|
|
|
#ifdef ANDROID
|
|
|
|
// We use OtherPidMaybeInvalid() because on Android this method is
|
|
|
|
// actually called on an unconnected protocol, but Android's shared memory
|
|
|
|
// implementation doesn't actually use the PID.
|
2018-04-23 18:13:37 +00:00
|
|
|
mProtocol->OtherPidMaybeInvalid();
|
2018-03-13 16:54:35 +00:00
|
|
|
#else
|
2018-04-23 18:13:37 +00:00
|
|
|
mProtocol->OtherPid();
|
2018-03-13 16:54:35 +00:00
|
|
|
#endif
|
|
|
|
|
2016-11-02 04:05:38 +00:00
|
|
|
Message* descriptor =
|
2018-04-17 14:05:30 +00:00
|
|
|
shmem.ShareTo(Shmem::PrivateIPDLCaller(), pid, MSG_ROUTING_CONTROL);
|
2016-11-02 04:05:38 +00:00
|
|
|
if (!descriptor) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
2018-04-23 18:13:37 +00:00
|
|
|
Unused << mProtocol->GetIPCChannel()->Send(descriptor);
|
2016-11-02 04:05:38 +00:00
|
|
|
|
2018-04-17 14:05:30 +00:00
|
|
|
*aId = shmem.Id(Shmem::PrivateIPDLCaller());
|
2016-11-02 04:05:38 +00:00
|
|
|
Shmem::SharedMemory* rawSegment = segment.get();
|
|
|
|
mShmemMap.AddWithID(segment.forget().take(), *aId);
|
|
|
|
return rawSegment;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
Shmem::SharedMemory* IToplevelProtocol::ToplevelState::LookupSharedMemory(
|
|
|
|
Shmem::id_t aId) {
|
2016-11-02 04:05:38 +00:00
|
|
|
return mShmemMap.Lookup(aId);
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
bool IToplevelProtocol::ToplevelState::IsTrackingSharedMemory(
|
|
|
|
Shmem::SharedMemory* segment) {
|
2016-11-02 04:05:38 +00:00
|
|
|
return mShmemMap.HasData(segment);
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
bool IToplevelProtocol::ToplevelState::DestroySharedMemory(Shmem& shmem) {
|
2018-04-17 14:05:30 +00:00
|
|
|
Shmem::id_t aId = shmem.Id(Shmem::PrivateIPDLCaller());
|
2016-11-02 04:05:38 +00:00
|
|
|
Shmem::SharedMemory* segment = LookupSharedMemory(aId);
|
|
|
|
if (!segment) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Message* descriptor =
|
2018-04-17 14:05:30 +00:00
|
|
|
shmem.UnshareFrom(Shmem::PrivateIPDLCaller(), MSG_ROUTING_CONTROL);
|
2016-11-02 04:05:38 +00:00
|
|
|
|
|
|
|
mShmemMap.Remove(aId);
|
2018-04-17 14:05:30 +00:00
|
|
|
Shmem::Dealloc(Shmem::PrivateIPDLCaller(), segment);
|
2016-11-02 04:05:38 +00:00
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
MessageChannel* channel = mProtocol->GetIPCChannel();
|
|
|
|
if (!channel->CanSend()) {
|
2016-11-02 04:05:38 +00:00
|
|
|
delete descriptor;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
return descriptor && channel->Send(descriptor);
|
2016-11-02 04:05:38 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
void IToplevelProtocol::ToplevelState::DeallocShmems() {
|
2016-11-03 23:25:48 +00:00
|
|
|
for (IDMap<SharedMemory*>::const_iterator cit = mShmemMap.begin();
|
|
|
|
cit != mShmemMap.end(); ++cit) {
|
2018-04-17 14:05:30 +00:00
|
|
|
Shmem::Dealloc(Shmem::PrivateIPDLCaller(), cit->second);
|
2016-11-02 04:05:38 +00:00
|
|
|
}
|
|
|
|
mShmemMap.Clear();
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
bool IToplevelProtocol::ToplevelState::ShmemCreated(const Message& aMsg) {
|
2016-11-02 04:05:38 +00:00
|
|
|
Shmem::id_t id;
|
2018-04-17 14:05:30 +00:00
|
|
|
RefPtr<Shmem::SharedMemory> rawmem(
|
|
|
|
Shmem::OpenExisting(Shmem::PrivateIPDLCaller(), aMsg, &id, true));
|
2016-11-02 04:05:38 +00:00
|
|
|
if (!rawmem) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
mShmemMap.AddWithID(rawmem.forget().take(), id);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
bool IToplevelProtocol::ToplevelState::ShmemDestroyed(const Message& aMsg) {
|
2016-11-02 04:05:38 +00:00
|
|
|
Shmem::id_t id;
|
|
|
|
PickleIterator iter = PickleIterator(aMsg);
|
|
|
|
if (!IPC::ReadParam(&aMsg, &iter, &id)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
aMsg.EndRead(iter);
|
|
|
|
|
|
|
|
Shmem::SharedMemory* rawmem = LookupSharedMemory(id);
|
|
|
|
if (rawmem) {
|
|
|
|
mShmemMap.Remove(id);
|
2018-04-17 14:05:30 +00:00
|
|
|
Shmem::Dealloc(Shmem::PrivateIPDLCaller(), rawmem);
|
2016-11-02 04:05:38 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
already_AddRefed<nsIEventTarget>
|
2018-04-23 18:13:37 +00:00
|
|
|
IToplevelProtocol::ToplevelState::GetMessageEventTarget(const Message& aMsg) {
|
2016-10-29 03:46:59 +00:00
|
|
|
int32_t route = aMsg.routing_id();
|
|
|
|
|
2017-04-05 03:21:16 +00:00
|
|
|
Maybe<MutexAutoLock> lock;
|
|
|
|
lock.emplace(mEventTargetMutex);
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
nsCOMPtr<nsIEventTarget> target = mEventTargetMap.Lookup(route);
|
|
|
|
|
|
|
|
if (aMsg.is_constructor()) {
|
|
|
|
ActorHandle handle;
|
|
|
|
PickleIterator iter = PickleIterator(aMsg);
|
|
|
|
if (!IPC::ReadParam(&aMsg, &iter, &handle)) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Normally a new actor inherits its event target from its manager. If the
|
|
|
|
// manager has no event target, we give the subclass a chance to make a new
|
|
|
|
// one.
|
|
|
|
if (!target) {
|
|
|
|
MutexAutoUnlock unlock(mEventTargetMutex);
|
2018-04-23 18:13:37 +00:00
|
|
|
target = mProtocol->GetConstructedEventTarget(aMsg);
|
2016-10-29 03:46:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mEventTargetMap.AddWithID(target, handle.mId);
|
2017-04-05 03:21:16 +00:00
|
|
|
} else if (!target) {
|
|
|
|
// We don't need the lock after this point.
|
|
|
|
lock.reset();
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
target = mProtocol->GetSpecificMessageEventTarget(aMsg);
|
2016-10-29 03:46:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return target.forget();
|
|
|
|
}
|
|
|
|
|
2016-11-04 18:13:52 +00:00
|
|
|
already_AddRefed<nsIEventTarget>
|
2018-04-23 18:13:37 +00:00
|
|
|
IToplevelProtocol::ToplevelState::GetActorEventTarget(IProtocol* aActor) {
|
2016-11-04 18:13:52 +00:00
|
|
|
MOZ_RELEASE_ASSERT(aActor->Id() != kNullActorId &&
|
|
|
|
aActor->Id() != kFreedActorId);
|
|
|
|
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
nsCOMPtr<nsIEventTarget> target = mEventTargetMap.Lookup(aActor->Id());
|
|
|
|
return target.forget();
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
nsIEventTarget* IToplevelProtocol::ToplevelState::GetActorEventTarget() {
|
2017-02-13 06:04:58 +00:00
|
|
|
// The EventTarget of a ToplevelProtocol shall never be set.
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
void IToplevelProtocol::ToplevelState::SetEventTargetForActor(
|
|
|
|
IProtocol* aActor, nsIEventTarget* aEventTarget) {
|
2017-02-13 06:04:58 +00:00
|
|
|
// The EventTarget of a ToplevelProtocol shall never be set.
|
2018-04-23 18:13:37 +00:00
|
|
|
MOZ_RELEASE_ASSERT(aActor != mProtocol);
|
2017-02-13 06:04:58 +00:00
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
// We should only call this function on actors that haven't been used for IPC
|
|
|
|
// code yet. Otherwise we'll be posting stuff to the wrong event target before
|
|
|
|
// we're called.
|
|
|
|
MOZ_RELEASE_ASSERT(aActor->Id() == kNullActorId ||
|
|
|
|
aActor->Id() == kFreedActorId);
|
|
|
|
|
|
|
|
// Register the actor early. When it's registered again, it will keep the same
|
|
|
|
// ID.
|
|
|
|
int32_t id = Register(aActor);
|
|
|
|
aActor->SetId(id);
|
|
|
|
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
2018-04-10 18:36:46 +00:00
|
|
|
// FIXME bug 1445121 - sometimes the id is already mapped.
|
|
|
|
// (IDMap debug-asserts that the existing state is as expected.)
|
|
|
|
bool replace = false;
|
|
|
|
#ifdef DEBUG
|
|
|
|
replace = mEventTargetMap.Lookup(id) != nullptr;
|
|
|
|
#endif
|
|
|
|
if (replace) {
|
|
|
|
mEventTargetMap.ReplaceWithID(aEventTarget, id);
|
|
|
|
} else {
|
|
|
|
mEventTargetMap.AddWithID(aEventTarget, id);
|
|
|
|
}
|
2016-10-29 03:46:59 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:37 +00:00
|
|
|
void IToplevelProtocol::ToplevelState::ReplaceEventTargetForActor(
|
2017-03-21 03:57:56 +00:00
|
|
|
IProtocol* aActor, nsIEventTarget* aEventTarget) {
|
|
|
|
// The EventTarget of a ToplevelProtocol shall never be set.
|
2018-04-23 18:13:37 +00:00
|
|
|
MOZ_RELEASE_ASSERT(aActor != mProtocol);
|
2017-03-21 03:57:56 +00:00
|
|
|
|
|
|
|
int32_t id = aActor->Id();
|
|
|
|
// The ID of the actor should have existed.
|
|
|
|
MOZ_RELEASE_ASSERT(id != kNullActorId && id != kFreedActorId);
|
|
|
|
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
mEventTargetMap.ReplaceWithID(aEventTarget, id);
|
|
|
|
}
|
|
|
|
|
2019-04-17 00:51:32 +00:00
|
|
|
void IToplevelProtocol::ToplevelState::SetEventTargetForRoute(
|
|
|
|
int32_t aRoute, nsIEventTarget* aEventTarget) {
|
|
|
|
MOZ_RELEASE_ASSERT(aRoute != mProtocol->Id());
|
|
|
|
MOZ_RELEASE_ASSERT(aRoute != kNullActorId && aRoute != kFreedActorId);
|
|
|
|
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
MOZ_ASSERT(!mEventTargetMap.Lookup(aRoute));
|
|
|
|
mEventTargetMap.AddWithID(aEventTarget, aRoute);
|
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:36 +00:00
|
|
|
const MessageChannel* IToplevelProtocol::ToplevelState::GetIPCChannel() const {
|
2018-07-22 11:51:30 +00:00
|
|
|
return ProtocolState::mChannel ? ProtocolState::mChannel : &mChannel;
|
2018-04-23 18:13:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
MessageChannel* IToplevelProtocol::ToplevelState::GetIPCChannel() {
|
2018-07-22 11:51:30 +00:00
|
|
|
return ProtocolState::mChannel ? ProtocolState::mChannel : &mChannel;
|
2018-04-23 18:13:36 +00:00
|
|
|
}
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
} // namespace ipc
|
|
|
|
} // namespace mozilla
|