/*

* Copyright (C) 2020-2025 Apple Inc. All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

* THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "config.h"

#include "IPCTestingAPI.h"

#if ENABLE(IPC_TESTING_API)

#include "Encoder.h"

#include "FrameInfoData.h"

#include "GPUProcessConnection.h"

#include "IPCSemaphore.h"

#include "IPCStreamTesterMessages.h"

#include "IPCTesterReceiver.h"

#include "IPCTesterReceiverMessages.h"

#include "JSIPCBinding.h"

#include "MessageArgumentDescriptions.h"

#include "MessageObserver.h"

#include "NetworkProcessConnection.h"

#include "SerializedTypeInfo.h"

#include "StreamClientConnection.h"

#include "StreamConnectionBuffer.h"

#include "WebFrame.h"

#include "WebPage.h"

#include "WebProcess.h"

#include <JavaScriptCore/APICast.h>

#include <JavaScriptCore/BuiltinNames.h>

#include <JavaScriptCore/JSBigInt.h>

#include <JavaScriptCore/JSClassRef.h>

#include <JavaScriptCore/JSLock.h>

#include <JavaScriptCore/JSObject.h>

#include <JavaScriptCore/JSRetainPtr.h>

#include <JavaScriptCore/JSValueRef.h>

#include <JavaScriptCore/JavaScript.h>

#include <JavaScriptCore/OpaqueJSString.h>

#include <WebCore/DOMWrapperWorld.h>

#include <WebCore/JSDOMGlobalObject.h>

#include <WebCore/LocalFrame.h>

#include <WebCore/RegistrableDomain.h>

#include <WebCore/ScriptController.h>

#include <WebCore/SharedMemory.h>

#include <wtf/PageBlock.h>

#include <wtf/RefCountedAndCanMakeWeakPtr.h>

#include <wtf/Scope.h>

#include <wtf/StdLibExtras.h>

#include <wtf/TZoneMallocInlines.h>

#include <wtf/text/MakeString.h>

#if ENABLE(IPC_TESTING_SWIFT)

#include "WebKit-Swift.h"

#endif

namespace WebKit::IPCTestingAPI {

class JSIPC;

using WebCore::SharedMemory;

static constexpr auto processTargetNameUI = "UI"_s;

#if ENABLE(GPU_PROCESS)

static constexpr auto processTargetNameGPU = "GPU"_s;

#endif

static constexpr auto processTargetNameNetworking = "Networking"_s;

static std::optional<uint64_t> destinationIDFromArgument(JSC::JSGlobalObject*, JSValueRef, JSValueRef*);

static std::optional<IPC::MessageName> messageNameFromArgument(JSC::JSGlobalObject*, JSValueRef, JSValueRef*);

static JSC::JSObject* jsResultFromReplyDecoder(JSC::JSGlobalObject*, IPC::MessageName, IPC::Decoder&);

static bool encodeArgument(IPC::Encoder&, JSContextRef, JSValueRef, JSValueRef* exception);

class JSIPCSemaphore : public RefCounted<JSIPCSemaphore> {

public:

static Ref<JSIPCSemaphore> create(IPC::Semaphore&& semaphore = { })

{

return adoptRef(*new JSIPCSemaphore(WTF::move(semaphore)));

}

JSObjectRef createJSWrapper(JSContextRef);

static JSIPCSemaphore* toWrapped(JSContextRef, JSValueRef);

void encode(IPC::Encoder& encoder) const { encoder << m_semaphore; }

IPC::Semaphore exchange(IPC::Semaphore&& semaphore = { })

{

return std::exchange(m_semaphore, WTF::move(semaphore));

}

private:

JSIPCSemaphore(IPC::Semaphore&& semaphore)

: m_semaphore(WTF::move(semaphore))

{ }

static JSClassRef wrapperClass();

static JSIPCSemaphore* unwrap(JSObjectRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

static const JSStaticFunction* staticFunctions();

static JSValueRef signal(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef waitFor(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

IPC::Semaphore m_semaphore;

};

class JSIPCConnectionHandle : public RefCounted<JSIPCConnectionHandle> {

public:

static Ref<JSIPCConnectionHandle> create(IPC::Connection::Handle&& handle)

{

return adoptRef(*new JSIPCConnectionHandle(WTF::move(handle)));

}

JSObjectRef createJSWrapper(JSContextRef);

static JSIPCConnectionHandle* toWrapped(JSContextRef, JSValueRef);

void encode(IPC::Encoder& encoder) { encoder << WTF::move(m_handle); }

private:

JSIPCConnectionHandle(IPC::Connection::Handle&& handle)

: m_handle(WTF::move(handle))

{ }

static JSClassRef wrapperClass();

static JSIPCConnectionHandle* unwrap(JSObjectRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

static const JSStaticFunction* staticFunctions();

IPC::Connection::Handle m_handle;

};

class JSIPCConnection : public RefCounted<JSIPCConnection>, private IPC::Connection::Client {

WTF_DEPRECATED_MAKE_FAST_ALLOCATED(JSIPCConnection);

WTF_OVERRIDE_DELETE_FOR_CHECKED_PTR(JSIPCConnection);

public:

static Ref<JSIPCConnection> create(IPC::Connection::Identifier&& testedConnectionIdentifier)

{

return adoptRef(*new JSIPCConnection(IPC::Connection::createServerConnection(WTF::move(testedConnectionIdentifier))));

}

static Ref<JSIPCConnection> create(Ref<IPC::Connection> connection)

{

return adoptRef(*new JSIPCConnection(WTF::move(connection)));

}

void ref() const final { RefCounted::ref(); }

void deref() const final { RefCounted::deref(); }

JSObjectRef createJSWrapper(JSContextRef);

static JSIPCConnection* toWrapped(JSContextRef, JSValueRef);

IPC::Connection& connection() const { return m_testedConnection; }

private:

JSIPCConnection(Ref<IPC::Connection> connection)

: m_testedConnection { WTF::move(connection) }

{

}

// IPC::Connection::Client overrides.

void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;

void didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&) final;

void didClose(IPC::Connection&) final;

void didReceiveInvalidMessage(IPC::Connection&, IPC::MessageName, const Vector<uint32_t>&) final;

static JSClassRef wrapperClass();

static JSIPCConnection* unwrap(JSObjectRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

static const JSStaticFunction* staticFunctions();

static JSValueRef open(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef invalidate(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef sendMessage(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef sendWithAsyncReply(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef sendSyncMessage(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef waitForMessage(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef waitForAsyncReplyAndDispatchImmediately(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

const Ref<IPC::Connection> m_testedConnection;

};

class JSIPCStreamClientConnection : public RefCountedAndCanMakeWeakPtr<JSIPCStreamClientConnection> {

public:

static Ref<JSIPCStreamClientConnection> create(JSIPC& jsIPC, RefPtr<IPC::StreamClientConnection> connection)

{

return adoptRef(*new JSIPCStreamClientConnection(jsIPC, WTF::move(connection)));

}

JSObjectRef createJSWrapper(JSContextRef);

static JSIPCStreamClientConnection* toWrapped(JSContextRef, JSValueRef);

IPC::StreamClientConnection& connection() { return *m_streamConnection; }

private:

friend class JSIPCStreamConnectionBuffer;

JSIPCStreamClientConnection(JSIPC& jsIPC, RefPtr<IPC::StreamClientConnection> connection)

: m_jsIPC(jsIPC)

, m_streamConnection { WTF::move(connection) }

, m_dummyMessageReceiver { makeUniqueRefWithoutRefCountedCheck<MessageReceiver>(*this) }

{

}

void setSemaphores(JSIPCSemaphore& jsWakeUpSemaphore, JSIPCSemaphore& jsClientWaitSemaphore) { m_streamConnection->setSemaphores(jsWakeUpSemaphore.exchange(), jsClientWaitSemaphore.exchange()); }

static JSClassRef wrapperClass();

static JSIPCStreamClientConnection* unwrap(JSObjectRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

bool prepareToSendOutOfStreamMessage(uint64_t destinationID, IPC::Timeout);

static const JSStaticFunction* staticFunctions();

static JSValueRef open(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef invalidate(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef streamBuffer(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef setSemaphores(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef sendMessage(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef sendWithAsyncReply(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef sendSyncMessage(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef sendIPCStreamTesterSyncCrashOnZero(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef waitForMessage(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef waitForAsyncReplyAndDispatchImmediately(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

WeakPtr<JSIPC> m_jsIPC;

RefPtr<IPC::StreamClientConnection> m_streamConnection;

// Current tests expect that actions and their induced messages are waited on during same

// run loop invocation (in JS). This means that messages of interest do not ever enter here.

// Due to JSIPCStreamClientConnection supporting WeakPtr and IPC::MessageReceiver forcing WeakPtr, we store this as a member.

class MessageReceiver : public IPC::Connection::Client {

WTF_DEPRECATED_MAKE_FAST_ALLOCATED(MessageReceiver);

WTF_OVERRIDE_DELETE_FOR_CHECKED_PTR(MessageReceiver);

public:

MessageReceiver(JSIPCStreamClientConnection& connection)

: m_connection(connection)

{ }

void ref() const { m_connection->ref(); }

void deref() const { m_connection->deref(); }

// IPC::MessageReceiver overrides.

void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final { ASSERT_NOT_REACHED(); }

void didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&) final { ASSERT_NOT_REACHED(); }

void didClose(IPC::Connection&) final { }

void didReceiveInvalidMessage(IPC::Connection&, IPC::MessageName, const Vector<uint32_t>& indicesOfObjectsFailingDecoding) final { ASSERT_NOT_REACHED(); }

private:

WeakRef<JSIPCStreamClientConnection> m_connection;

};

UniqueRef<MessageReceiver> m_dummyMessageReceiver;

};

class JSIPCStreamServerConnectionHandle : public RefCounted<JSIPCStreamServerConnectionHandle> {

public:

static Ref<JSIPCStreamServerConnectionHandle> create(IPC::StreamServerConnection::Handle&& handle)

{

return adoptRef(*new JSIPCStreamServerConnectionHandle(WTF::move(handle)));

}

JSObjectRef createJSWrapper(JSContextRef);

static JSIPCStreamServerConnectionHandle* toWrapped(JSContextRef, JSValueRef);

void encode(IPC::Encoder& encoder) { encoder << WTF::move(m_handle); }

private:

JSIPCStreamServerConnectionHandle(IPC::StreamServerConnection::Handle&& handle)

: m_handle { WTF::move(handle) }

{

}

static JSClassRef wrapperClass();

static JSIPCStreamServerConnectionHandle* unwrap(JSObjectRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

static const JSStaticFunction* staticFunctions();

IPC::StreamServerConnection::Handle m_handle;

};

class JSIPCStreamConnectionBuffer : public RefCounted<JSIPCStreamConnectionBuffer> {

public:

static Ref<JSIPCStreamConnectionBuffer> create(JSIPCStreamClientConnection& streamConnection)

{

return adoptRef(*new JSIPCStreamConnectionBuffer(streamConnection));

}

JSObjectRef createJSWrapper(JSContextRef);

static JSIPCStreamConnectionBuffer* toWrapped(JSContextRef, JSValueRef);

void encode(IPC::Encoder& encoder) const { encoder << m_streamConnection->connection().bufferForTesting().createHandle(); }

private:

JSIPCStreamConnectionBuffer(JSIPCStreamClientConnection& streamConnection)

: m_streamConnection(streamConnection)

{

}

static JSClassRef wrapperClass();

static JSIPCStreamConnectionBuffer* unwrap(JSObjectRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

static const JSStaticFunction* staticFunctions();

static JSValueRef readHeaderBytes(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef readDataBytes(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef readBytes(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception, std::span<uint8_t>);

static JSValueRef writeHeaderBytes(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef writeDataBytes(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef writeBytes(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception, std::span<uint8_t>);

WeakPtr<JSIPCStreamClientConnection> m_streamConnection;

};

class JSSharedMemory : public RefCounted<JSSharedMemory> {

public:

static Ref<JSSharedMemory> create(size_t size)

{

return adoptRef(*new JSSharedMemory(size));

}

static Ref<JSSharedMemory> create(Ref<SharedMemory>&& sharedMemory)

{

return adoptRef(*new JSSharedMemory(WTF::move(sharedMemory)));

}

size_t size() const { return m_sharedMemory->size(); }

std::optional<SharedMemory::Handle> createHandle(SharedMemory::Protection);

JSObjectRef createJSWrapper(JSContextRef);

static JSSharedMemory* toWrapped(JSContextRef, JSValueRef);

private:

JSSharedMemory(size_t size)

: m_sharedMemory(*SharedMemory::allocate(size))

{ }

JSSharedMemory(Ref<SharedMemory>&& sharedMemory)

: m_sharedMemory(WTF::move(sharedMemory))

{

}

static JSClassRef wrapperClass();

static JSSharedMemory* unwrap(JSObjectRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

static const JSStaticFunction* staticFunctions();

static JSValueRef readBytes(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef writeBytes(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

const Ref<SharedMemory> m_sharedMemory;

};

class JSMessageListener final : public IPC::MessageObserver, public RefCounted<JSMessageListener> {

WTF_MAKE_TZONE_ALLOCATED(JSMessageListener);

public:

enum class Type { Incoming, Outgoing };

static Ref<JSMessageListener> create(JSIPC& jsIPC, Type type, JSC::JSGlobalObject* globalObject, JSObjectRef callback)

{

return adoptRef(*new JSMessageListener(jsIPC, type, globalObject, callback));

}

void ref() const final { RefCounted::ref(); }

void deref() const final { RefCounted::deref(); }

private:

JSMessageListener(JSIPC&, Type, JSC::JSGlobalObject*, JSObjectRef callback);

void willSendMessage(const IPC::Encoder&, OptionSet<IPC::SendOption>) override;

void didReceiveMessage(const IPC::Decoder&) override;

JSC::JSObject* jsDescriptionFromDecoder(JSC::JSGlobalObject*, IPC::Decoder&);

WeakPtr<JSIPC> m_jsIPC;

Type m_type;

JSC::Weak<WebCore::JSDOMGlobalObject> m_globalObject;

JSObjectRef m_callback;

};

class JSIPC : public RefCountedAndCanMakeWeakPtr<JSIPC> {

public:

static Ref<JSIPC> create(WebPage& webPage, WebFrame& webFrame)

{

return adoptRef(*new JSIPC(webPage, webFrame));

}

static JSIPC* toWrapped(JSContextRef, JSValueRef);

static JSClassRef wrapperClass();

WebFrame* webFrame() { return m_webFrame.get(); }

private:

JSIPC(WebPage& webPage, WebFrame& webFrame)

: m_webPage(webPage)

, m_webFrame(webFrame)

#if ENABLE(IPC_TESTING_SWIFT)

, m_testerProxy(IPCTesterReceiver::init())

#else

, m_testerProxy(IPCTesterReceiver::create())

#endif

{ }

static JSIPC* unwrap(JSObjectRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

static const JSStaticFunction* staticFunctions();

static const JSStaticValue* staticValues();

static JSValueRef connectionForProcessTarget(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static void addMessageListener(JSMessageListener::Type, JSContextRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef addIncomingMessageListener(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef addOutgoingMessageListener(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef sendMessage(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef sendSyncMessage(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef waitForMessage(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef createConnectionPair(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef createStreamClientConnection(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef createSemaphore(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef createSharedMemory(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef addTesterReceiver(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef removeTesterReceiver(JSContextRef, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);

static JSValueRef vmPageSize(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef visitedLinkStoreID(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef webPageProxyID(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef sessionID(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef pageID(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef frameID(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef retrieveID(JSContextRef, JSObjectRef thisObject, JSValueRef* exception, NOESCAPE const WTF::Function<uint64_t(JSIPC&)>&);

static JSValueRef messages(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef serializedTypeInfo(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef serializedEnumInfo(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef objectIdentifiers(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

static JSValueRef processTargets(JSContextRef, JSObjectRef, JSStringRef, JSValueRef* exception);

RefPtr<JSIPCConnection> processTargetFromArgument(JSC::JSGlobalObject*, JSValueRef, JSValueRef* exception);

WeakPtr<WebPage> m_webPage;

WeakPtr<WebFrame> m_webFrame;

Vector<Ref<JSMessageListener>> m_messageListeners;

#if ENABLE(IPC_TESTING_SWIFT)

IPCTesterReceiver m_testerProxy;

#else

const Ref<IPCTesterReceiver> m_testerProxy;

#endif

RefPtr<JSIPCConnection> m_uiConnection;

RefPtr<JSIPCConnection> m_networkConnection;

RefPtr<JSIPCConnection> m_gpuConnection;

};

static JSValueRef createError(JSContextRef context, const String& message)

{

JSC::JSLockHolder lock(toJS(context)->vm());

return toRef(JSC::createError(toJS(context), message));

}

static JSValueRef createTypeError(JSContextRef context, const String& message)

{

JSC::JSLockHolder lock(toJS(context)->vm());

return toRef(JSC::createTypeError(toJS(context), message));

}

static JSValueRef createErrorFromIPCError(JSContextRef context, IPC::Error error)

{

return createError(context, makeString("IPC error:"_s, IPC::errorAsString(error)));

}

static std::optional<uint64_t> convertToUint64(JSC::JSValue jsValue)

{

if (jsValue.isNumber()) {

double value = jsValue.asNumber();

if (value < 0 || trunc(value) != value)

return std::nullopt;

return value;

}

if (jsValue.isBigInt())

return JSC::JSBigInt::toBigUInt64(jsValue);

return std::nullopt;

}

static std::optional<double> convertToDouble(JSC::JSValue jsValue)

{

if (jsValue.isNumber())

return jsValue.asNumber();

if (jsValue.isBigInt())

return JSC::JSBigInt::toBigUInt64(jsValue);

return std::nullopt;

}

namespace {

struct SyncIPCMessageInfo {

uint64_t destinationID;

IPC::MessageName messageName;

IPC::Timeout timeout;

};

}

static std::optional<SyncIPCMessageInfo> extractSyncIPCMessageInfo(JSContextRef context, std::span<const JSValueRef> arguments, JSValueRef* exception)

{

ASSERT(arguments.size() >= 2);

auto* globalObject = toJS(context);

auto destinationID = destinationIDFromArgument(globalObject, arguments[0], exception);

if (!destinationID)

return std::nullopt;

auto messageName = messageNameFromArgument(globalObject, arguments[1], exception);

if (!messageName)

return std::nullopt;

Seconds timeoutDuration;

{

auto jsValue = toJS(globalObject, arguments[2]);

if (!jsValue.isNumber()) {

*exception = createTypeError(context, "Timeout must be a number"_s);

return std::nullopt;

}

timeoutDuration = Seconds { jsValue.asNumber() };

}

return { { *destinationID, *messageName, { timeoutDuration } } };

}

static JSValueRef jsSend(IPC::Connection& connection, uint64_t destinationID, IPC::MessageName messageName, JSContextRef context, const JSValueRef messageArguments, JSValueRef* exception)

{

auto encoder = makeUniqueRef<IPC::Encoder>(messageName, destinationID);

if (messageArguments && !encodeArgument(encoder.get(), context, messageArguments, exception))

return JSValueMakeUndefined(context);

connection.sendMessage(WTF::move(encoder), IPC::SendOption::IPCTestingMessage);

return JSValueMakeUndefined(context);

}

static JSValueRef jsSendWithAsyncReply(IPC::Connection& connection, uint64_t destinationID, IPC::MessageName messageName, JSContextRef context, const JSObjectRef callback, const JSValueRef messageArguments, JSValueRef* exception)

{

auto encoder = makeUniqueRef<IPC::Encoder>(messageName, destinationID);

if (messageArguments && !encodeArgument(encoder.get(), context, messageArguments, exception))

return JSValueMakeUndefined(context);

JSGlobalContextRetain(JSContextGetGlobalContext(context));

JSValueProtect(context, callback);

IPC::Connection::AsyncReplyHandler handler = {

[messageName, context, callback](IPC::Connection*, IPC::Decoder* replyDecoder) {

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

auto scope = DECLARE_TOP_EXCEPTION_SCOPE(vm);

auto cleanup = makeScopeExit([context, callback] {

JSValueUnprotect(context, callback);

JSGlobalContextRelease(JSContextGetGlobalContext(context));

});

JSC::JSObject* jsResult = nullptr;

if (replyDecoder && replyDecoder->isValid())

jsResult = jsResultFromReplyDecoder(globalObject, messageName, *replyDecoder);

std::array<JSValueRef, 1> arguments { nullptr };

if (auto* exception = scope.exception()) {

arguments[0] = toRef(globalObject, exception);

scope.clearException();

} else

arguments[0] = toRef(globalObject, jsResult);

JSObjectCallAsFunction(context, callback, callback, 1, arguments.data(), nullptr);

},

IPC::Connection::AsyncReplyID::generate()

};

auto asyncReplyID = *handler.replyID;

auto result = connection.sendMessageWithAsyncReply(WTF::move(encoder), WTF::move(handler), IPC::SendOption::IPCTestingMessage);

if (result != IPC::Error::NoError) {

*exception = createErrorFromIPCError(context, result);

return JSValueMakeUndefined(context);

}

return JSValueMakeNumber(context, asyncReplyID.toUInt64());

}

static JSValueRef jsSendSync(IPC::Connection& connection, uint64_t destinationID, IPC::MessageName messageName, IPC::Timeout timeout, JSContextRef context, const JSValueRef messageArguments, JSValueRef* exception)

{

auto [encoder, syncRequestID] = connection.createSyncMessageEncoder(messageName, destinationID);

if (messageArguments && !encodeArgument(encoder.get(), context, messageArguments, exception))

return JSValueMakeUndefined(context);

auto replyDecoderOrError = connection.sendSyncMessage(syncRequestID, WTF::move(encoder), timeout, { });

if (replyDecoderOrError.has_value()) {

auto* globalObject = toJS(context);

JSC::JSLockHolder lock(globalObject->vm());

auto scope = DECLARE_TOP_EXCEPTION_SCOPE(globalObject->vm());

auto* jsResult = jsResultFromReplyDecoder(globalObject, messageName, replyDecoderOrError.value().get());

if (scope.exception()) {

*exception = toRef(globalObject, scope.exception());

scope.clearException();

return JSValueMakeUndefined(context);

}

return toRef(globalObject, jsResult);

}

return JSValueMakeUndefined(context);

}

static JSValueRef jsWaitForMessage(IPC::Connection& connection, uint64_t destinationID, IPC::MessageName messageName, IPC::Timeout timeout, JSContextRef context, JSValueRef* exception)

{

auto* globalObject = toJS(context);

JSC::JSLockHolder lock(globalObject->vm());

auto decoderOrError = connection.waitForMessageForTesting(messageName, destinationID, timeout, { });

if (decoderOrError.has_value()) {

auto scope = DECLARE_TOP_EXCEPTION_SCOPE(globalObject->vm());

auto jsResult = jsValueForArguments(globalObject, messageName, decoderOrError.value().get());

if (scope.exception()) {

*exception = toRef(globalObject, scope.exception());

scope.clearException();

return JSValueMakeUndefined(context);

}

return jsResult ? toRef(globalObject, *jsResult) : JSValueMakeUndefined(context);

}

return JSValueMakeUndefined(context);

}

static JSValueRef jsWaitForAsyncReplyAndDispatchImmediately(IPC::Connection& connection, uint64_t destinationID, IPC::MessageName messageName, IPC::Timeout timeout, JSContextRef context, JSValueRef* exception)

{

auto handler = connection.takeAsyncReplyHandler(IPC::Connection::AsyncReplyID { destinationID });

if (!handler) {

*exception = createError(context, "IPC error: no handler"_s);

return JSValueMakeUndefined(context);

}

auto decoderOrError = connection.waitForMessageForTesting(messageName, destinationID, timeout, { });

if (!decoderOrError.has_value()) {

*exception = createErrorFromIPCError(context, decoderOrError.error());

handler(nullptr, nullptr);

return JSValueMakeUndefined(context);

}

handler(&connection, &decoderOrError.value().get());

return JSValueMakeUndefined(context);

}

JSObjectRef JSIPCSemaphore::createJSWrapper(JSContextRef context)

{

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

auto scope = DECLARE_TOP_EXCEPTION_SCOPE(vm);

JSObjectRef wrapperObject = JSObjectMake(toGlobalRef(globalObject), wrapperClass(), this);

scope.clearException();

return wrapperObject;

}

JSClassRef JSIPCSemaphore::wrapperClass()

{

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.className = "Semaphore";

definition.parentClass = nullptr;

definition.staticValues = nullptr;

definition.staticFunctions = staticFunctions();

definition.initialize = initialize;

definition.finalize = finalize;

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

inline JSIPCSemaphore* JSIPCSemaphore::unwrap(JSObjectRef object)

{

return static_cast<JSIPCSemaphore*>(JSObjectGetPrivate(object));

}

JSIPCSemaphore* JSIPCSemaphore::toWrapped(JSContextRef context, JSValueRef value)

{

if (!context || !value || !JSValueIsObjectOfClass(context, value, wrapperClass()))

return nullptr;

return unwrap(JSValueToObject(context, value, nullptr));

}

void JSIPCSemaphore::initialize(JSContextRef, JSObjectRef object)

{

unwrap(object)->ref();

}

void JSIPCSemaphore::finalize(JSObjectRef object)

{

unwrap(object)->deref();

}

const JSStaticFunction* JSIPCSemaphore::staticFunctions()

{

static const JSStaticFunction functions[] = {

{ "signal", signal, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "waitFor", waitFor, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ 0, 0, 0 }

};

return functions;

}

JSObjectRef JSIPCConnectionHandle::createJSWrapper(JSContextRef context)

{

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

auto scope = DECLARE_TOP_EXCEPTION_SCOPE(vm);

JSObjectRef wrapperObject = JSObjectMake(toGlobalRef(globalObject), wrapperClass(), this);

scope.clearException();

return wrapperObject;

}

JSClassRef JSIPCConnectionHandle::wrapperClass()

{

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.className = "ConnectionHandle";

definition.parentClass = nullptr;

definition.staticValues = nullptr;

definition.staticFunctions = staticFunctions();

definition.initialize = initialize;

definition.finalize = finalize;

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

inline JSIPCConnectionHandle* JSIPCConnectionHandle::unwrap(JSObjectRef object)

{

return static_cast<JSIPCConnectionHandle*>(JSObjectGetPrivate(object));

}

JSIPCConnectionHandle* JSIPCConnectionHandle::toWrapped(JSContextRef context, JSValueRef value)

{

if (!context || !value || !JSValueIsObjectOfClass(context, value, wrapperClass()))

return nullptr;

return unwrap(JSValueToObject(context, value, nullptr));

}

void JSIPCConnectionHandle::initialize(JSContextRef, JSObjectRef object)

{

unwrap(object)->ref();

}

void JSIPCConnectionHandle::finalize(JSObjectRef object)

{

unwrap(object)->deref();

}

const JSStaticFunction* JSIPCConnectionHandle::staticFunctions()

{

static const JSStaticFunction functions[] = {

{ 0, 0, 0 }

};

return functions;

}

JSObjectRef JSIPCConnection::createJSWrapper(JSContextRef context)

{

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

auto scope = DECLARE_TOP_EXCEPTION_SCOPE(vm);

JSObjectRef wrapperObject = JSObjectMake(toGlobalRef(globalObject), wrapperClass(), this);

scope.clearException();

return wrapperObject;

}

JSClassRef JSIPCConnection::wrapperClass()

{

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.className = "Connection";

definition.parentClass = nullptr;

definition.staticValues = nullptr;

definition.staticFunctions = staticFunctions();

definition.initialize = initialize;

definition.finalize = finalize;

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

inline JSIPCConnection* JSIPCConnection::unwrap(JSObjectRef object)

{

return static_cast<JSIPCConnection*>(JSObjectGetPrivate(object));

}

JSIPCConnection* JSIPCConnection::toWrapped(JSContextRef context, JSValueRef value)

{

if (!context || !value || !JSValueIsObjectOfClass(context, value, wrapperClass()))

return nullptr;

return unwrap(JSValueToObject(context, value, nullptr));

}

void JSIPCConnection::initialize(JSContextRef, JSObjectRef object)

{

unwrap(object)->ref();

}

void JSIPCConnection::finalize(JSObjectRef object)

{

unwrap(object)->deref();

}

void JSIPCConnection::didReceiveMessage(IPC::Connection&, IPC::Decoder&)

{

ASSERT_NOT_REACHED();

}

void JSIPCConnection::didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&)

{

ASSERT_NOT_REACHED();

}

void JSIPCConnection::didClose(IPC::Connection&)

{

}

void JSIPCConnection::didReceiveInvalidMessage(IPC::Connection&, IPC::MessageName, const Vector<uint32_t>&)

{

ASSERT_NOT_REACHED();

}

const JSStaticFunction* JSIPCConnection::staticFunctions()

{

static const JSStaticFunction functions[] = {

{ "open", open, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "invalidate", invalidate, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "sendMessage", sendMessage, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "sendWithAsyncReply", sendWithAsyncReply, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "sendSyncMessage", sendSyncMessage, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "waitForMessage", waitForMessage, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "waitForAsyncReplyAndDispatchImmediately", waitForAsyncReplyAndDispatchImmediately, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ 0, 0, 0 }

};

return functions;

}

JSValueRef JSIPCConnection::open(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t, const JSValueRef[], JSValueRef* exception)

{

RefPtr jsIPC = toWrapped(context, thisObject);

if (!jsIPC) {

*exception = createTypeError(context, "Wrong type"_s);

return JSValueMakeUndefined(context);

}

jsIPC->m_testedConnection->open(*jsIPC);

return JSValueMakeUndefined(context);

}

JSValueRef JSIPCConnection::invalidate(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t, const JSValueRef[], JSValueRef* exception)

{

RefPtr jsIPC = toWrapped(context, thisObject);

if (!jsIPC) {

*exception = createTypeError(context, "Wrong type"_s);

return JSValueMakeUndefined(context);

}

jsIPC->m_testedConnection->invalidate();

return JSValueMakeUndefined(context);

}

JSValueRef JSIPCConnection::sendMessage(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t rawArgumentCount, const JSValueRef rawArguments[], JSValueRef* exception)

{

auto arguments = unsafeMakeSpan(rawArguments, rawArgumentCount);

RefPtr jsIPC = toWrapped(context, thisObject);

if (!jsIPC) {

*exception = createTypeError(context, "Wrong type"_s);

return JSValueMakeUndefined(context);

}

if (arguments.size() < 2) {

*exception = createTypeError(context, "Must specify the destination ID and message ID as the first two arguments"_s);

return JSValueMakeUndefined(context);

}

auto* globalObject = toJS(context);

JSC::JSLockHolder lock(globalObject->vm());

auto destinationID = destinationIDFromArgument(globalObject, arguments[0], exception);

if (!destinationID)

return JSValueMakeUndefined(context);

auto messageName = messageNameFromArgument(globalObject, arguments[1], exception);

if (!messageName)

return JSValueMakeUndefined(context);

JSValueRef messageArguments = arguments.size() > 2 ? arguments[2] : nullptr;

return jsSend(jsIPC->m_testedConnection.get(), *destinationID, *messageName, context, messageArguments, exception);

}

JSValueRef JSIPCConnection::sendWithAsyncReply(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t rawArgumentCount, const JSValueRef rawArguments[], JSValueRef* exception)

{

auto arguments = unsafeMakeSpan(rawArguments, rawArgumentCount);

RefPtr jsIPC = toWrapped(context, thisObject);

if (!jsIPC) {

*exception = createTypeError(context, "Wrong type"_s);

return JSValueMakeUndefined(context);

}

if (arguments.size() < 4) {

*exception = createTypeError(context, "Must specify the destination ID, message ID, messageArguments, callback as the first four arguments"_s);

return JSValueMakeUndefined(context);

}

auto* globalObject = toJS(context);

JSC::JSLockHolder lock(globalObject->vm());

auto destinationID = destinationIDFromArgument(globalObject, arguments[0], exception);

if (!destinationID)

return JSValueMakeUndefined(context);

auto messageName = messageNameFromArgument(globalObject, arguments[1], exception);

if (!messageName)

return JSValueMakeUndefined(context);

if (!messageReplyArgumentDescriptions(*messageName)) {

*exception = createError(context, "Message does not have a reply"_s);

return JSValueMakeUndefined(context);

}

JSObjectRef callback = nullptr;

if (JSValueIsObject(context, arguments[3])) {

callback = JSValueToObject(context, arguments[3], exception);

if (!JSObjectIsFunction(context, callback))

callback = nullptr;

}

if (!callback) {

*exception = createTypeError(context, "Must specify callback as the fourth argument"_s);

return JSValueMakeUndefined(context);

}

return jsSendWithAsyncReply(jsIPC->m_testedConnection.get(), *destinationID, *messageName, context, callback, arguments[2], exception);

}

JSValueRef JSIPCConnection::sendSyncMessage(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t rawArgumentCount, const JSValueRef rawArguments[], JSValueRef* exception)

{

auto arguments = unsafeMakeSpan(rawArguments, rawArgumentCount);

RefPtr jsIPC = toWrapped(context, thisObject);

if (!jsIPC) {

*exception = createTypeError(context, "Wrong type"_s);

return JSValueMakeUndefined(context);

}

if (arguments.size() < 2) {

*exception = createTypeError(context, "Must specify the destination ID and message ID as the first two arguments"_s);

return JSValueMakeUndefined(context);

}

auto info = extractSyncIPCMessageInfo(context, arguments, exception);

if (!info)

return JSValueMakeUndefined(context);

auto [destinationID, messageName, timeout] = *info;

JSValueRef messageArguments = arguments.size() > 3 ? arguments[3] : nullptr;

return jsSendSync(jsIPC->m_testedConnection.get(), destinationID, messageName, timeout, context, messageArguments, exception);

}

JSValueRef JSIPCConnection::waitForMessage(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t rawArgumentCount, const JSValueRef rawArguments[], JSValueRef* exception)

{

auto arguments = unsafeMakeSpan(rawArguments, rawArgumentCount);

RefPtr jsIPC = toWrapped(context, thisObject);

if (!jsIPC) {

*exception = createTypeError(context, "Wrong type"_s);

return JSValueMakeUndefined(context);

}

if (arguments.size() < 2) {

*exception = createTypeError(context, "Must specify the destination ID and message ID as the first two arguments"_s);

return JSValueMakeUndefined(context);

}

auto info = extractSyncIPCMessageInfo(context, arguments, exception);

if (!info)

return JSValueMakeUndefined(context);

auto [destinationID, messageName, timeout] = *info;

return jsWaitForMessage(jsIPC->m_testedConnection.get(), destinationID, messageName, timeout, context, exception);

}

JSValueRef JSIPCConnection::waitForAsyncReplyAndDispatchImmediately(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t rawArgumentCount, const JSValueRef rawArguments[], JSValueRef* exception)

{

auto arguments = unsafeMakeSpan(rawArguments, rawArgumentCount);

RefPtr jsIPC = toWrapped(context, thisObject);

if (!jsIPC) {

*exception = createTypeError(context, "Wrong type"_s);

return JSValueMakeUndefined(context);

}

if (arguments.size() < 3) {

*exception = createTypeError(context, "Must specify the message name, async reply ID and timeout as the first three arguments"_s);

return JSValueMakeUndefined(context);

}

auto info = extractSyncIPCMessageInfo(context, arguments, exception);

if (!info)

return JSValueMakeUndefined(context);

auto [destinationID, messageName, timeout] = *info;

return jsWaitForAsyncReplyAndDispatchImmediately(jsIPC->m_testedConnection.get(), destinationID, messageName, timeout, context, exception);

}