/*

* Copyright (C) 2020 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 "JSIPCBinding.h"

#include "MessageArgumentDescriptions.h"

#include "NetworkProcessConnection.h"

#include "RemoteRenderingBackendCreationParameters.h"

#include "StreamClientConnection.h"

#include "StreamConnectionBuffer.h"

#include "WebCoreArgumentCoders.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/JSValueRef.h>

#include <JavaScriptCore/JavaScript.h>

#include <JavaScriptCore/OpaqueJSString.h>

#include <WebCore/DOMWrapperWorld.h>

#include <WebCore/Frame.h>

#include <WebCore/RegistrableDomain.h>

#include <WebCore/ScriptController.h>

#include <wtf/PageBlock.h>

namespace WebKit {

namespace IPCTestingAPI {

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

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

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

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

class JSIPCSemaphore : public RefCounted<JSIPCSemaphore> {

public:

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

{

return adoptRef(*new JSIPCSemaphore(WTFMove(semaphore)));

}

JSObjectRef createJSWrapper(JSContextRef);

static JSIPCSemaphore* toWrapped(JSContextRef, JSValueRef);

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

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

{

return std::exchange(m_semaphore, WTFMove(semaphore));

}

private:

JSIPCSemaphore(IPC::Semaphore&& semaphore)

: m_semaphore(WTFMove(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 JSIPCStreamClientConnection : public RefCounted<JSIPCStreamClientConnection>, public CanMakeWeakPtr<JSIPCStreamClientConnection> {

public:

static Ref<JSIPCStreamClientConnection> create(JSIPC& jsIPC, IPC::Connection& connection, size_t bufferSize)

{

return adoptRef(*new JSIPCStreamClientConnection(jsIPC, connection, bufferSize));

}

JSObjectRef createJSWrapper(JSContextRef);

static JSIPCStreamClientConnection* toWrapped(JSContextRef, JSValueRef);

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

private:

JSIPCStreamClientConnection(JSIPC& jsIPC, IPC::Connection& connection, size_t bufferSize)

: m_jsIPC(jsIPC)

, m_streamConnection { connection, bufferSize }

{ }

void setWakeUpSemaphore(JSIPCSemaphore& jsSemaphore) { m_streamConnection.setWakeUpSemaphore(jsSemaphore.exchange()); }

static JSClassRef wrapperClass();

static JSIPCStreamClientConnection* unwrap(JSObjectRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

static bool prepareToSendOutOfStreamMessage(JSContextRef, size_t argumentCount, const JSValueRef arguments[], JSIPC&, IPC::StreamClientConnection&, IPC::Encoder&, uint64_t destinationID, IPC::Timeout, JSValueRef* exception);

static const JSStaticFunction* staticFunctions();

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

static JSValueRef setWakeUpSemaphore(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);

WeakPtr<JSIPC> m_jsIPC;

IPC::StreamClientConnection m_streamConnection;

};

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 { m_streamConnection->connection().streamBuffer().encode(encoder); }

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();

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(WTFMove(sharedMemory)));

}

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

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(WTFMove(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);

Ref<SharedMemory> m_sharedMemory;

};

class JSIPC;

class JSMessageListener final : public IPC::Connection::MessageObserver {

WTF_MAKE_FAST_ALLOCATED;

public:

enum class Type { Incoming, Outgoing };

JSMessageListener(JSIPC&, Type, JSContextRef, JSObjectRef callback);

private:

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;

JSContextRef m_context;

JSObjectRef m_callback;

};

class JSIPC : public RefCounted<JSIPC>, public CanMakeWeakPtr<JSIPC> {

public:

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

{

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

}

static JSClassRef wrapperClass();

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

private:

JSIPC(WebPage& webPage, WebFrame& webFrame)

: m_webPage(webPage)

, m_webFrame(webFrame)

{ }

static JSIPC* unwrap(JSObjectRef);

static JSIPC* toWrapped(JSContextRef, JSValueRef);

static void initialize(JSContextRef, JSObjectRef);

static void finalize(JSObjectRef);

static const JSStaticFunction* staticFunctions();

static const JSStaticValue* staticValues();

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 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 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, const WTF::Function<uint64_t(JSIPC&)>&);

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

WeakPtr<WebPage> m_webPage;

WeakPtr<WebFrame> m_webFrame;

Vector<UniqueRef<JSMessageListener>> m_messageListeners;

};

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

{

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

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

}

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;

}

JSObjectRef JSIPCSemaphore::createJSWrapper(JSContextRef context)

{

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

auto scope = DECLARE_CATCH_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 JSIPCStreamClientConnection::createJSWrapper(JSContextRef context)

{

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

auto scope = DECLARE_CATCH_SCOPE(vm);

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

scope.clearException();

return wrapperObject;

}

JSClassRef JSIPCStreamClientConnection::wrapperClass()

{

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.className = "StreamClientConnection";

definition.parentClass = nullptr;

definition.staticValues = nullptr;

definition.staticFunctions = staticFunctions();

definition.initialize = initialize;

definition.finalize = finalize;

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

inline JSIPCStreamClientConnection* JSIPCStreamClientConnection::unwrap(JSObjectRef object)

{

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

}

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

{

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

return nullptr;

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

}

void JSIPCStreamClientConnection::initialize(JSContextRef, JSObjectRef object)

{

unwrap(object)->ref();

}

void JSIPCStreamClientConnection::finalize(JSObjectRef object)

{

unwrap(object)->deref();

}

const JSStaticFunction* JSIPCStreamClientConnection::staticFunctions()

{

static const JSStaticFunction functions[] = {

{ "streamBuffer", streamBuffer, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "setWakeUpSemaphore", setWakeUpSemaphore, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

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

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

{ 0, 0, 0 }

};

return functions;

}

JSValueRef JSIPCStreamClientConnection::streamBuffer(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

auto* globalObject = toJS(context);

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

RefPtr jsStreamConnection = toWrapped(context, thisObject);

if (!jsStreamConnection) {

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

return JSValueMakeUndefined(context);

}

return JSIPCStreamConnectionBuffer::create(*jsStreamConnection)->createJSWrapper(context);

}

JSValueRef JSIPCStreamClientConnection::setWakeUpSemaphore(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

auto* globalObject = toJS(context);

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

RefPtr jsStreamConnection = toWrapped(context, thisObject);

if (!jsStreamConnection) {

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

return JSValueMakeUndefined(context);

}

if (argumentCount < 1) {

*exception = createTypeError(context, "Must specify an IPC semaphore as the first argument"_s);

return JSValueMakeUndefined(context);

}

RefPtr jsSemaphore = JSIPCSemaphore::toWrapped(context, arguments[0]);

if (!jsSemaphore) {

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

return JSValueMakeUndefined(context);

}

jsStreamConnection->setWakeUpSemaphore(*jsSemaphore);

return JSValueMakeUndefined(context);

}

struct IPCStreamMessageInfo {

uint64_t destinationID;

IPC::MessageName messageName;

IPC::Timeout timeout;

};

static std::optional<IPCStreamMessageInfo> extractIPCStreamMessageInfo(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

if (argumentCount < 3) {

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

return std::nullopt;

}

auto* globalObject = toJS(context);

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

if (!destinationID)

return std::nullopt;

auto messageID = messageIDFromArgument(globalObject, arguments[1], exception);

if (!messageID)

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, static_cast<IPC::MessageName>(*messageID), { timeoutDuration } } };

}

bool JSIPCStreamClientConnection::prepareToSendOutOfStreamMessage(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], JSIPC& jsIPC, IPC::StreamClientConnection& streamConnection, IPC::Encoder& encoder, uint64_t destinationID, IPC::Timeout timeout, JSValueRef* exception)

{

// FIXME: Add support for sending in-stream IPC messages when appropriate.

if (argumentCount > 3) {

if (!encodeArgument(encoder, jsIPC, context, arguments[3], exception))

return false;

}

if (!streamConnection.trySendDestinationIDIfNeeded(destinationID, timeout))

return false;

auto span = streamConnection.tryAcquire(timeout);

if (!span)

return false;

streamConnection.sendProcessOutOfStreamMessage(WTFMove(*span));

return true;

}

JSValueRef JSIPCStreamClientConnection::sendMessage(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

auto* globalObject = toJS(context);

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

auto returnValue = JSValueMakeUndefined(context);

RefPtr jsStreamConnection = toWrapped(context, thisObject);

if (!jsStreamConnection) {

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

return returnValue;

}

auto info = extractIPCStreamMessageInfo(context, argumentCount, arguments, exception);

if (!info)

return returnValue;

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

auto& streamConnection = jsStreamConnection->connection();

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

if (prepareToSendOutOfStreamMessage(context, argumentCount, arguments, *jsStreamConnection->m_jsIPC, streamConnection, encoder.get(), destinationID, timeout, exception))

streamConnection.m_connection.sendMessage(WTFMove(encoder), { });

return returnValue;

}

JSValueRef JSIPCStreamClientConnection::sendSyncMessage(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

auto* globalObject = toJS(context);

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

RefPtr jsStreamConnection = toWrapped(context, thisObject);

if (!jsStreamConnection) {

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

return JSValueMakeUndefined(context);

}

auto info = extractIPCStreamMessageInfo(context, argumentCount, arguments, exception);

if (!info)

return JSValueMakeUndefined(context);

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

auto& streamConnection = jsStreamConnection->connection();

IPC::Connection::SyncRequestID syncRequestID;

auto encoder = streamConnection.m_connection.createSyncMessageEncoder(messageName, destinationID, syncRequestID);

if (!prepareToSendOutOfStreamMessage(context, argumentCount, arguments, *jsStreamConnection->m_jsIPC, streamConnection, encoder.get(), destinationID, timeout, exception))

return JSValueMakeUndefined(context);

if (auto replyDecoder = streamConnection.m_connection.sendSyncMessage(syncRequestID, WTFMove(encoder), timeout, { })) {

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

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

if (scope.exception()) {

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

scope.clearException();

return JSValueMakeUndefined(context);

}

return toRef(globalObject, jsResult);

}

return JSValueMakeUndefined(context);

}

JSObjectRef JSIPCStreamConnectionBuffer::createJSWrapper(JSContextRef context)

{

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

auto scope = DECLARE_CATCH_SCOPE(vm);

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

scope.clearException();

return wrapperObject;

}

JSClassRef JSIPCStreamConnectionBuffer::wrapperClass()

{

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.className = "StreamConnectionBuffer";

definition.parentClass = nullptr;

definition.staticValues = nullptr;

definition.staticFunctions = staticFunctions();

definition.initialize = initialize;

definition.finalize = finalize;

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

inline JSIPCStreamConnectionBuffer* JSIPCStreamConnectionBuffer::unwrap(JSObjectRef object)

{

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

}

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

{

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

return nullptr;

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

}

void JSIPCStreamConnectionBuffer::initialize(JSContextRef, JSObjectRef object)

{

unwrap(object)->ref();

}

void JSIPCStreamConnectionBuffer::finalize(JSObjectRef object)

{

unwrap(object)->deref();

}

const JSStaticFunction* JSIPCStreamConnectionBuffer::staticFunctions()

{

static const JSStaticFunction functions[] = {

{ 0, 0, 0 }

};

return functions;

}

JSValueRef JSIPCSemaphore::signal(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

auto* globalObject = toJS(context);

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

RefPtr jsIPCSemaphore = toWrapped(context, thisObject);

if (!jsIPCSemaphore) {

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

return JSValueMakeUndefined(context);

}

jsIPCSemaphore->m_semaphore.signal();

return JSValueMakeUndefined(context);

}

JSValueRef JSIPCSemaphore::waitFor(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

auto* globalObject = toJS(context);

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

RefPtr jsIPCSemaphore = toWrapped(context, thisObject);

if (!jsIPCSemaphore) {

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

return JSValueMakeUndefined(context);

}

if (argumentCount < 1) {

*exception = createTypeError(context, "Must specify the timeout in milliseconds as the first argument"_s);

return JSValueMakeUndefined(context);

}

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

Seconds timeout;

if (jsValue.isNumber()) {

double milliseconds = jsValue.asNumber();

if (std::isfinite(milliseconds) && milliseconds > 0)

timeout = Seconds::fromMilliseconds(milliseconds);

}

if (!timeout) {

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

return JSValueMakeUndefined(context);

}

auto result = jsIPCSemaphore->m_semaphore.waitFor(timeout);

return JSValueMakeBoolean(context, result);

}

SharedMemory::Handle JSSharedMemory::createHandle(SharedMemory::Protection protection)

{

SharedMemory::Handle handle;

m_sharedMemory->createHandle(handle, protection);

return handle;

}

JSObjectRef JSSharedMemory::createJSWrapper(JSContextRef context)

{

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

auto scope = DECLARE_CATCH_SCOPE(vm);

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

scope.clearException();

return wrapperObject;

}

JSClassRef JSSharedMemory::wrapperClass()

{

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.className = "SharedMemory";

definition.parentClass = nullptr;

definition.staticValues = nullptr;

definition.staticFunctions = staticFunctions();

definition.initialize = initialize;

definition.finalize = finalize;

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

inline JSSharedMemory* JSSharedMemory::unwrap(JSObjectRef object)

{

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

}

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

{

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

return nullptr;

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

}

void JSSharedMemory::initialize(JSContextRef, JSObjectRef object)

{

unwrap(object)->ref();

}

void JSSharedMemory::finalize(JSObjectRef object)

{

unwrap(object)->deref();

}

const JSStaticFunction* JSSharedMemory::staticFunctions()

{

static const JSStaticFunction functions[] = {

{ "readBytes", readBytes, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "writeBytes", writeBytes, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ 0, 0, 0 }

};

return functions;

}

JSValueRef JSSharedMemory::readBytes(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

RefPtr jsSharedMemory = toWrapped(context, thisObject);

if (!jsSharedMemory) {

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

return JSValueMakeUndefined(context);

}

size_t offset = 0;

size_t length = jsSharedMemory->m_sharedMemory->size();

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

if (argumentCount) {

auto offsetValue = convertToUint64(toJS(globalObject, arguments[0]));

if (!offsetValue) {

*exception = createTypeError(context, "The first argument must be a byte offset to read"_s);

return JSValueMakeUndefined(context);

}

if (*offsetValue > length)

offset = length;

else

offset = *offsetValue;

length -= offset;

}

if (argumentCount > 1) {

auto lengthValue = convertToUint64(toJS(globalObject, arguments[1]));

if (!lengthValue) {

*exception = createTypeError(context, "The second argument must be the number of bytes to read"_s);

return JSValueMakeUndefined(context);

}

if (*lengthValue < length)

length = *lengthValue;

}

auto arrayBuffer = JSC::ArrayBuffer::create(static_cast<uint8_t*>(jsSharedMemory->m_sharedMemory->data()) + offset, length);

JSC::JSArrayBuffer* jsArrayBuffer = nullptr;

if (auto* structure = globalObject->arrayBufferStructure(arrayBuffer->sharingMode()))

jsArrayBuffer = JSC::JSArrayBuffer::create(vm, structure, WTFMove(arrayBuffer));

if (!jsArrayBuffer) {

*exception = createTypeError(context, "Failed to create the array buffer for the read bytes"_s);

return JSValueMakeUndefined(context);

}

return toRef(jsArrayBuffer);

}

struct ArrayBufferData {

void* buffer { nullptr };

size_t length { 0 };

};

static ArrayBufferData arrayBufferDataFromValueRef(JSContextRef context, JSTypedArrayType type, JSValueRef valueRef, JSValueRef* exception)

{

auto objectRef = JSValueToObject(context, valueRef, exception);

if (!objectRef)

return { };

void* buffer = nullptr;

if (type == kJSTypedArrayTypeArrayBuffer)

buffer = JSObjectGetArrayBufferBytesPtr(context, objectRef, exception);

else

buffer = JSObjectGetTypedArrayBytesPtr(context, objectRef, exception);

if (!buffer)

return { };

size_t length;

if (type == kJSTypedArrayTypeArrayBuffer)

length = JSObjectGetArrayBufferByteLength(context, objectRef, exception);

else

length = JSObjectGetTypedArrayByteLength(context, objectRef, exception);

return { buffer, length };

}

JSValueRef JSSharedMemory::writeBytes(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

RefPtr jsSharedMemory = toWrapped(context, thisObject);

if (!jsSharedMemory) {

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

return JSValueMakeUndefined(context);

}

auto type = argumentCount ? JSValueGetTypedArrayType(context, arguments[0], exception) : kJSTypedArrayTypeNone;

if (type == kJSTypedArrayTypeNone) {

*exception = createTypeError(context, "The first argument must be an array buffer or a typed array"_s);

return JSValueMakeUndefined(context);

}

auto data = arrayBufferDataFromValueRef(context, type, arguments[0], exception);

if (!data.buffer) {

*exception = createTypeError(context, "Could not read the buffer"_s);

return JSValueMakeUndefined(context);

}

size_t offset = 0;

size_t length = data.length;

size_t sharedMemorySize = jsSharedMemory->m_sharedMemory->size();

auto* globalObject = toJS(context);

auto& vm = globalObject->vm();

JSC::JSLockHolder lock(vm);

if (argumentCount > 1) {

auto offsetValue = convertToUint64(toJS(globalObject, arguments[1]));

if (!offsetValue) {

*exception = createTypeError(context, "The second argument must be a byte offset to write"_s);

return JSValueMakeUndefined(context);

}

if (*offsetValue >= sharedMemorySize) {

*exception = createTypeError(context, "Offset is too big"_s);

return JSValueMakeUndefined(context);

}

offset = *offsetValue;

}

if (argumentCount > 2) {

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

if (!lengthValue) {

*exception = createTypeError(context, "The third argument must be the number of bytes to write"_s);

return JSValueMakeUndefined(context);

}

if (*lengthValue >= sharedMemorySize - offset || *lengthValue > length) {

*exception = createTypeError(context, "The number of bytes to write is too big"_s);

return JSValueMakeUndefined(context);

}

length = *lengthValue;

}

memcpy(static_cast<uint8_t*>(jsSharedMemory->m_sharedMemory->data()) + offset, data.buffer, length);

return JSValueMakeUndefined(context);

}

JSClassRef JSIPC::wrapperClass()

{

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.className = "IPC";

definition.parentClass = nullptr;

definition.staticValues = staticValues();

definition.staticFunctions = staticFunctions();

definition.initialize = initialize;

definition.finalize = finalize;

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

inline JSIPC* JSIPC::unwrap(JSObjectRef object)

{

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

}

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

{

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

return nullptr;

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

}

void JSIPC::initialize(JSContextRef, JSObjectRef object)

{

unwrap(object)->ref();

}

void JSIPC::finalize(JSObjectRef object)

{

unwrap(object)->deref();

}

const JSStaticFunction* JSIPC::staticFunctions()

{

static const JSStaticFunction functions[] = {

{ "addIncomingMessageListener", addIncomingMessageListener, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "addOutgoingMessageListener", addOutgoingMessageListener, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

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

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

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

{ "createStreamClientConnection", createStreamClientConnection, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "createSemaphore", createSemaphore, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "createSharedMemory", createSharedMemory, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ 0, 0, 0 }

};

return functions;

}

const JSStaticValue* JSIPC::staticValues()

{

static const JSStaticValue values[] = {

{ "vmPageSize", vmPageSize, 0, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "visitedLinkStoreID", visitedLinkStoreID, 0, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "frameID", frameID, 0, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "pageID", pageID, 0, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "sessionID", sessionID, 0, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "webPageProxyID", webPageProxyID, 0, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ "messages", messages, 0, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },

{ 0, 0, 0, 0 }

};

return values;

}

static RefPtr<IPC::Connection> processTargetFromArgument(JSC::JSGlobalObject* globalObject, JSValueRef valueRef, JSValueRef* exception)

{

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

auto name = toJS(globalObject, valueRef).toWTFString(globalObject);

if (scope.exception())

return nullptr;

if (name == "UI")

return WebProcess::singleton().parentProcessConnection();

#if ENABLE(GPU_PROCESS)

if (name == "GPU")

return &WebProcess::singleton().ensureGPUProcessConnection().connection();

#endif

if (name == "Networking")

return &WebProcess::singleton().ensureNetworkProcessConnection().connection();

*exception = toRef(JSC::createTypeError(globalObject, "Target process must be UI, GPU, or Networking"_s));

return nullptr;

}

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

{

auto* globalObject = toJS(context);

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

RefPtr jsIPC = toWrapped(context, thisObject);

if (!jsIPC) {

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

return;

}

if (argumentCount < 1) {

*exception = createTypeError(context, "Must specify the target process as the first argument"_s);

return;

}

auto connection = processTargetFromArgument(globalObject, arguments[0], exception);

if (!connection)

return;

std::unique_ptr<JSMessageListener> listener;

if (argumentCount >= 2 && JSValueIsObject(context, arguments[1])) {

auto listenerObjectRef = JSValueToObject(context, arguments[1], exception);

if (JSObjectIsFunction(context, listenerObjectRef))

listener = makeUnique<JSMessageListener>(*jsIPC, type, context, listenerObjectRef);

}

if (!listener) {

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

return;

}

connection->addMessageObserver(*listener);