[GLIB] Remove support for GSocket main loop sources from GMainLoopSource
[WebKit-https.git] / Source / WebKit2 / Platform / IPC / Connection.h
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
4  * Portions Copyright (c) 2010 Motorola Mobility, Inc.  All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
19  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
25  * THE POSSIBILITY OF SUCH DAMAGE.
26  */
27
28 #ifndef Connection_h
29 #define Connection_h
30
31 #include "Arguments.h"
32 #include "MessageDecoder.h"
33 #include "MessageEncoder.h"
34 #include "MessageReceiver.h"
35 #include "ProcessType.h"
36 #include <atomic>
37 #include <wtf/Condition.h>
38 #include <wtf/Deque.h>
39 #include <wtf/Forward.h>
40 #include <wtf/HashMap.h>
41 #include <wtf/Lock.h>
42 #include <wtf/WorkQueue.h>
43 #include <wtf/text/CString.h>
44
45 #if OS(DARWIN) && !USE(UNIX_DOMAIN_SOCKETS)
46 #include <mach/mach_port.h>
47 #include <wtf/OSObjectPtr.h>
48 #include <wtf/spi/darwin/XPCSPI.h>
49 #endif
50
51 #if PLATFORM(GTK) || PLATFORM(EFL)
52 #include "PlatformProcessIdentifier.h"
53 #endif
54
55 #if PLATFORM(GTK)
56 #include "GSocketMonitor.h"
57 #endif
58
59 namespace IPC {
60
61 struct WaitForMessageState;
62
63 enum MessageSendFlags {
64     // Whether this message should be dispatched when waiting for a sync reply.
65     // This is the default for synchronous messages.
66     DispatchMessageEvenWhenWaitingForSyncReply = 1 << 0,
67 };
68
69 enum SyncMessageSendFlags {
70     // Use this to inform that this sync call will suspend this process until the user responds with input.
71     InformPlatformProcessWillSuspend = 1 << 0,
72     // Some platform accessibility clients can't suspend gracefully and need to spin the run loop so WebProcess doesn't hang.
73     // FIXME (126021): Remove when no platforms need to support this.
74     SpinRunLoopWhileWaitingForReply = 1 << 1,
75     UseFullySynchronousModeForTesting = 1 << 2,
76 };
77
78 enum WaitForMessageFlags {
79     // Use this to make waitForMessage be interrupted immediately by any incoming sync messages.
80     InterruptWaitingIfSyncMessageArrives = 1 << 0,
81 };
82
83 #define MESSAGE_CHECK_BASE(assertion, connection) do \
84     if (!(assertion)) { \
85         ASSERT(assertion); \
86         (connection)->markCurrentlyDispatchedMessageAsInvalid(); \
87         return; \
88     } \
89 while (0)
90
91 class Connection : public ThreadSafeRefCounted<Connection> {
92 public:
93     class Client : public MessageReceiver {
94     public:
95         virtual void didClose(Connection&) = 0;
96         virtual void didReceiveInvalidMessage(Connection&, StringReference messageReceiverName, StringReference messageName) = 0;
97         virtual IPC::ProcessType localProcessType() = 0;
98         virtual IPC::ProcessType remoteProcessType() = 0;
99
100     protected:
101         virtual ~Client() { }
102     };
103
104     class WorkQueueMessageReceiver : public MessageReceiver, public ThreadSafeRefCounted<WorkQueueMessageReceiver> {
105     };
106
107 #if USE(UNIX_DOMAIN_SOCKETS)
108     typedef int Identifier;
109     static bool identifierIsNull(Identifier identifier) { return identifier == -1; }
110
111     struct SocketPair {
112         int client;
113         int server;
114     };
115
116     enum ConnectionOptions {
117         SetCloexecOnClient = 1 << 0,
118         SetCloexecOnServer = 1 << 1,
119     };
120
121     static Connection::SocketPair createPlatformConnection(unsigned options = SetCloexecOnClient | SetCloexecOnServer);
122 #elif OS(DARWIN)
123     struct Identifier {
124         Identifier()
125             : port(MACH_PORT_NULL)
126         {
127         }
128
129         Identifier(mach_port_t port)
130             : port(port)
131         {
132         }
133
134         Identifier(mach_port_t port, OSObjectPtr<xpc_connection_t> xpcConnection)
135             : port(port)
136             , xpcConnection(WTF::move(xpcConnection))
137         {
138         }
139
140         mach_port_t port;
141         OSObjectPtr<xpc_connection_t> xpcConnection;
142     };
143     static bool identifierIsNull(Identifier identifier) { return identifier.port == MACH_PORT_NULL; }
144     xpc_connection_t xpcConnection() const { return m_xpcConnection.get(); }
145     bool getAuditToken(audit_token_t&);
146     pid_t remoteProcessID() const;
147 #endif
148
149     static Ref<Connection> createServerConnection(Identifier, Client&);
150     static Ref<Connection> createClientConnection(Identifier, Client&);
151     ~Connection();
152
153     Client* client() const { return m_client; }
154
155 #if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED <= 101000
156     void setShouldCloseConnectionOnMachExceptions();
157 #endif
158
159     void setOnlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage(bool);
160     void setShouldExitOnSyncMessageSendFailure(bool shouldExitOnSyncMessageSendFailure);
161
162     // The set callback will be called on the connection work queue when the connection is closed, 
163     // before didCall is called on the client thread. Must be called before the connection is opened.
164     // In the future we might want a more generic way to handle sync or async messages directly
165     // on the work queue, for example if we want to handle them on some other thread we could avoid
166     // handling the message on the client thread first.
167     typedef void (*DidCloseOnConnectionWorkQueueCallback)(Connection*);
168     void setDidCloseOnConnectionWorkQueueCallback(DidCloseOnConnectionWorkQueueCallback callback);
169
170     void addWorkQueueMessageReceiver(StringReference messageReceiverName, WorkQueue*, WorkQueueMessageReceiver*);
171     void removeWorkQueueMessageReceiver(StringReference messageReceiverName);
172
173     bool open();
174     void invalidate();
175     void markCurrentlyDispatchedMessageAsInvalid();
176
177     void postConnectionDidCloseOnConnectionWorkQueue();
178
179     template<typename T> bool send(T&& message, uint64_t destinationID, unsigned messageSendFlags = 0);
180     template<typename T> bool sendSync(T&& message, typename T::Reply&& reply, uint64_t destinationID, std::chrono::milliseconds timeout = std::chrono::milliseconds::max(), unsigned syncSendFlags = 0);
181     template<typename T> bool waitForAndDispatchImmediately(uint64_t destinationID, std::chrono::milliseconds timeout, unsigned waitForMessageFlags = 0);
182
183     std::unique_ptr<MessageEncoder> createSyncMessageEncoder(StringReference messageReceiverName, StringReference messageName, uint64_t destinationID, uint64_t& syncRequestID);
184     bool sendMessage(std::unique_ptr<MessageEncoder>, unsigned messageSendFlags = 0, bool alreadyRecordedMessage = false);
185     std::unique_ptr<MessageDecoder> sendSyncMessage(uint64_t syncRequestID, std::unique_ptr<MessageEncoder>, std::chrono::milliseconds timeout, unsigned syncSendFlags = 0);
186     std::unique_ptr<MessageDecoder> sendSyncMessageFromSecondaryThread(uint64_t syncRequestID, std::unique_ptr<MessageEncoder>, std::chrono::milliseconds timeout);
187     bool sendSyncReply(std::unique_ptr<MessageEncoder>);
188
189     void wakeUpRunLoop();
190
191     void incrementDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount() { ++m_inDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount; }
192     void decrementDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount() { --m_inDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount; }
193
194     bool inSendSync() const { return m_inSendSyncCount; }
195
196     Identifier identifier() const;
197
198 #if PLATFORM(COCOA)
199     bool kill();
200     void terminateSoon(double intervalInSeconds);
201 #endif
202
203     bool isValid() const { return m_client; }
204
205 #if HAVE(QOS_CLASSES)
206     void setShouldBoostMainThreadOnSyncMessage(bool b) { m_shouldBoostMainThreadOnSyncMessage = b; }
207 #endif
208
209     uint64_t installIncomingSyncMessageCallback(std::function<void ()>);
210     void uninstallIncomingSyncMessageCallback(uint64_t);
211     bool hasIncomingSyncMessage();
212
213     void allowFullySynchronousModeForTesting() { m_fullySynchronousModeIsAllowedForTesting = true; }
214
215 private:
216     Connection(Identifier, bool isServer, Client&);
217     void platformInitialize(Identifier);
218     void platformInvalidate();
219     
220     std::unique_ptr<MessageDecoder> waitForMessage(StringReference messageReceiverName, StringReference messageName, uint64_t destinationID, std::chrono::milliseconds timeout, unsigned waitForMessageFlags);
221     
222     std::unique_ptr<MessageDecoder> waitForSyncReply(uint64_t syncRequestID, std::chrono::milliseconds timeout, unsigned syncSendFlags);
223
224     // Called on the connection work queue.
225     void processIncomingMessage(std::unique_ptr<MessageDecoder>);
226     void processIncomingSyncReply(std::unique_ptr<MessageDecoder>);
227
228     void dispatchWorkQueueMessageReceiverMessage(WorkQueueMessageReceiver&, MessageDecoder&);
229
230     bool canSendOutgoingMessages() const;
231     bool platformCanSendOutgoingMessages() const;
232     void sendOutgoingMessages();
233     bool sendOutgoingMessage(std::unique_ptr<MessageEncoder>);
234     void connectionDidClose();
235     
236     // Called on the listener thread.
237     void dispatchOneMessage();
238     void dispatchMessage(std::unique_ptr<MessageDecoder>);
239     void dispatchMessage(MessageDecoder&);
240     void dispatchSyncMessage(MessageDecoder&);
241     void dispatchDidReceiveInvalidMessage(const CString& messageReceiverNameString, const CString& messageNameString);
242     void didFailToSendSyncMessage();
243
244     // Can be called on any thread.
245     void enqueueIncomingMessage(std::unique_ptr<MessageDecoder>);
246
247     void willSendSyncMessage(unsigned syncSendFlags);
248     void didReceiveSyncReply(unsigned syncSendFlags);
249     
250     Client* m_client;
251     bool m_isServer;
252     std::atomic<uint64_t> m_syncRequestID;
253
254     bool m_onlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage;
255     bool m_shouldExitOnSyncMessageSendFailure;
256     DidCloseOnConnectionWorkQueueCallback m_didCloseOnConnectionWorkQueueCallback;
257
258     bool m_isConnected;
259     Ref<WorkQueue> m_connectionQueue;
260
261     HashMap<StringReference, std::pair<RefPtr<WorkQueue>, RefPtr<WorkQueueMessageReceiver>>> m_workQueueMessageReceivers;
262
263     unsigned m_inSendSyncCount;
264     unsigned m_inDispatchMessageCount;
265     unsigned m_inDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount;
266     unsigned m_inDispatchMessageMarkedToUseFullySynchronousModeForTesting { 0 };
267     bool m_fullySynchronousModeIsAllowedForTesting { false };
268     bool m_didReceiveInvalidMessage;
269
270     // Incoming messages.
271     Lock m_incomingMessagesMutex;
272     Deque<std::unique_ptr<MessageDecoder>> m_incomingMessages;
273
274     // Outgoing messages.
275     Lock m_outgoingMessagesMutex;
276     Deque<std::unique_ptr<MessageEncoder>> m_outgoingMessages;
277     
278     Condition m_waitForMessageCondition;
279     Lock m_waitForMessageMutex;
280
281     WaitForMessageState* m_waitingForMessage;
282
283     // Represents a sync request for which we're waiting on a reply.
284     struct PendingSyncReply {
285         // The request ID.
286         uint64_t syncRequestID;
287
288         // The reply decoder, will be null if there was an error processing the sync
289         // message on the other side.
290         std::unique_ptr<MessageDecoder> replyDecoder;
291
292         // Will be set to true once a reply has been received.
293         bool didReceiveReply;
294     
295         PendingSyncReply()
296             : syncRequestID(0)
297             , didReceiveReply(false)
298         {
299         }
300
301         explicit PendingSyncReply(uint64_t syncRequestID)
302             : syncRequestID(syncRequestID)
303             , didReceiveReply(0)
304         {
305         }
306     };
307
308     class SyncMessageState;
309     friend class SyncMessageState;
310
311     Lock m_syncReplyStateMutex;
312     bool m_shouldWaitForSyncReplies;
313     Vector<PendingSyncReply> m_pendingSyncReplies;
314
315     class SecondaryThreadPendingSyncReply;
316     typedef HashMap<uint64_t, SecondaryThreadPendingSyncReply*> SecondaryThreadPendingSyncReplyMap;
317     SecondaryThreadPendingSyncReplyMap m_secondaryThreadPendingSyncReplyMap;
318
319     Lock m_incomingSyncMessageCallbackMutex;
320     HashMap<uint64_t, std::function<void ()>> m_incomingSyncMessageCallbacks;
321     RefPtr<WorkQueue> m_incomingSyncMessageCallbackQueue;
322     uint64_t m_nextIncomingSyncMessageCallbackID { 0 };
323
324 #if HAVE(QOS_CLASSES)
325     pthread_t m_mainThread { 0 };
326     bool m_shouldBoostMainThreadOnSyncMessage { false };
327 #endif
328
329 #if USE(UNIX_DOMAIN_SOCKETS)
330     // Called on the connection queue.
331     void readyReadHandler();
332     bool processMessage();
333
334     Vector<uint8_t> m_readBuffer;
335     size_t m_readBufferSize;
336     Vector<int> m_fileDescriptors;
337     size_t m_fileDescriptorsSize;
338     int m_socketDescriptor;
339 #if PLATFORM(GTK)
340     GSocketMonitor m_socketMonitor;
341 #endif
342 #elif OS(DARWIN)
343     // Called on the connection queue.
344     void receiveSourceEventHandler();
345     void initializeDeadNameSource();
346
347     mach_port_t m_sendPort;
348     dispatch_source_t m_deadNameSource;
349
350     mach_port_t m_receivePort;
351     dispatch_source_t m_receivePortDataAvailableSource;
352
353 #if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED <= 101000
354     void exceptionSourceEventHandler();
355
356     // If setShouldCloseConnectionOnMachExceptions has been called, this has
357     // the exception port that exceptions from the other end will be sent on.
358     mach_port_t m_exceptionPort;
359     dispatch_source_t m_exceptionPortDataAvailableSource;
360 #endif
361
362     OSObjectPtr<xpc_connection_t> m_xpcConnection;
363 #endif
364 };
365
366 template<typename T> bool Connection::send(T&& message, uint64_t destinationID, unsigned messageSendFlags)
367 {
368     COMPILE_ASSERT(!T::isSync, AsyncMessageExpected);
369
370     auto encoder = std::make_unique<MessageEncoder>(T::receiverName(), T::name(), destinationID);
371     encoder->encode(message.arguments());
372     
373     return sendMessage(WTF::move(encoder), messageSendFlags);
374 }
375
376 template<typename T> bool Connection::sendSync(T&& message, typename T::Reply&& reply, uint64_t destinationID, std::chrono::milliseconds timeout, unsigned syncSendFlags)
377 {
378     COMPILE_ASSERT(T::isSync, SyncMessageExpected);
379
380     uint64_t syncRequestID = 0;
381     std::unique_ptr<MessageEncoder> encoder = createSyncMessageEncoder(T::receiverName(), T::name(), destinationID, syncRequestID);
382
383     if (syncSendFlags & SyncMessageSendFlags::UseFullySynchronousModeForTesting) {
384         encoder->setFullySynchronousModeForTesting();
385         m_fullySynchronousModeIsAllowedForTesting = true;
386     }
387
388     // Encode the rest of the input arguments.
389     encoder->encode(message.arguments());
390
391     // Now send the message and wait for a reply.
392     std::unique_ptr<MessageDecoder> replyDecoder = sendSyncMessage(syncRequestID, WTF::move(encoder), timeout, syncSendFlags);
393     if (!replyDecoder)
394         return false;
395
396     // Decode the reply.
397     return replyDecoder->decode(reply);
398 }
399
400 template<typename T> bool Connection::waitForAndDispatchImmediately(uint64_t destinationID, std::chrono::milliseconds timeout, unsigned waitForMessageFlags)
401 {
402     std::unique_ptr<MessageDecoder> decoder = waitForMessage(T::receiverName(), T::name(), destinationID, timeout, waitForMessageFlags);
403     if (!decoder)
404         return false;
405
406     ASSERT(decoder->destinationID() == destinationID);
407     m_client->didReceiveMessage(*this, *decoder);
408     return true;
409 }
410
411 } // namespace IPC
412
413 #endif // Connection_h