ASSERTION FAILURE: ASSERT_NOT_REACHED() in Connection::writeEventHandler() after...
[WebKit-https.git] / Source / WebKit2 / Platform / CoreIPC / win / ConnectionWin.cpp
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "Connection.h"
28
29 #include "ArgumentEncoder.h"
30 #include "WorkItem.h"
31 #include <wtf/RandomNumber.h>
32 #include <wtf/text/WTFString.h>
33
34 using namespace std;
35 // We explicitly don't use the WebCore namespace here because CoreIPC should only use WTF types and
36 // WTF::String is really in WTF.
37 using WTF::String;
38  
39 namespace CoreIPC {
40
41 // FIXME: Rename this or use a different constant on windows.
42 static const size_t inlineMessageMaxSize = 4096;
43
44 bool Connection::createServerAndClientIdentifiers(HANDLE& serverIdentifier, HANDLE& clientIdentifier)
45 {
46     String pipeName;
47
48     while (true) {
49         unsigned uniqueID = randomNumber() * std::numeric_limits<unsigned>::max();
50         pipeName = String::format("\\\\.\\pipe\\com.apple.WebKit.%x", uniqueID);
51
52         serverIdentifier = ::CreateNamedPipe(pipeName.charactersWithNullTermination(),
53                                              PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE | FILE_FLAG_OVERLAPPED,
54                                              PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, 1, inlineMessageMaxSize, inlineMessageMaxSize,
55                                              0, 0);
56         if (!serverIdentifier && ::GetLastError() == ERROR_PIPE_BUSY) {
57             // There was already a pipe with this name, try again.
58             continue;
59         }
60
61         break;
62     }
63
64     if (!serverIdentifier)
65         return false;
66
67     clientIdentifier = ::CreateFileW(pipeName.charactersWithNullTermination(), GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
68     if (!clientIdentifier) {
69         ::CloseHandle(serverIdentifier);
70         return false;
71     }
72
73     DWORD mode = PIPE_READMODE_MESSAGE;
74     if (!::SetNamedPipeHandleState(clientIdentifier, &mode, 0, 0)) {
75         ::CloseHandle(serverIdentifier);
76         ::CloseHandle(clientIdentifier);
77         return false;
78     }
79
80     return true;
81 }
82
83 void Connection::platformInitialize(Identifier identifier)
84 {
85     memset(&m_readState, 0, sizeof(m_readState));
86     m_readState.hEvent = ::CreateEventW(0, FALSE, FALSE, 0);
87
88     memset(&m_writeState, 0, sizeof(m_writeState));
89     m_writeState.hEvent = ::CreateEventW(0, FALSE, FALSE, 0);
90
91     m_connectionPipe = identifier;
92 }
93
94 void Connection::platformInvalidate()
95 {
96     if (m_connectionPipe == INVALID_HANDLE_VALUE)
97         return;
98
99     m_isConnected = false;
100
101     m_connectionQueue.unregisterAndCloseHandle(m_readState.hEvent);
102     m_readState.hEvent = 0;
103
104     m_connectionQueue.unregisterAndCloseHandle(m_writeState.hEvent);
105     m_writeState.hEvent = 0;
106
107     ::CloseHandle(m_connectionPipe);
108     m_connectionPipe = INVALID_HANDLE_VALUE;
109 }
110
111 void Connection::readEventHandler()
112 {
113     if (m_connectionPipe == INVALID_HANDLE_VALUE)
114         return;
115
116     while (true) {
117         // Check if we got some data.
118         DWORD numberOfBytesRead = 0;
119         if (!::GetOverlappedResult(m_connectionPipe, &m_readState, &numberOfBytesRead, FALSE)) {
120             DWORD error = ::GetLastError();
121
122             switch (error) {
123             case ERROR_BROKEN_PIPE:
124                 connectionDidClose();
125                 return;
126             case ERROR_MORE_DATA: {
127                 // Read the rest of the message out of the pipe.
128
129                 DWORD bytesToRead = 0;
130                 if (!::PeekNamedPipe(m_connectionPipe, 0, 0, 0, 0, &bytesToRead)) {
131                     DWORD error = ::GetLastError();
132                     if (error == ERROR_BROKEN_PIPE) {
133                         connectionDidClose();
134                         return;
135                     }
136                     ASSERT_NOT_REACHED();
137                     return;
138                 }
139
140                 // ::GetOverlappedResult told us there's more data. ::PeekNamedPipe shouldn't
141                 // contradict it!
142                 ASSERT(bytesToRead);
143                 if (!bytesToRead)
144                     break;
145
146                 m_readBuffer.grow(m_readBuffer.size() + bytesToRead);
147                 if (!::ReadFile(m_connectionPipe, m_readBuffer.data() + numberOfBytesRead, bytesToRead, 0, &m_readState)) {
148                     DWORD error = ::GetLastError();
149                     ASSERT_NOT_REACHED();
150                     return;
151                 }
152                 continue;
153             }
154
155             // FIXME: We should figure out why we're getting this error.
156             case ERROR_IO_INCOMPLETE:
157                 return;
158             default:
159                 ASSERT_NOT_REACHED();
160             }
161         }
162
163         if (!m_readBuffer.isEmpty()) {
164             // We have a message, let's dispatch it.
165
166             // The messageID is encoded at the end of the buffer.
167             // Note that we assume here that the message is the same size as m_readBuffer. We can
168             // assume this because we always size m_readBuffer to exactly match the size of the message,
169             // either when receiving ERROR_MORE_DATA from ::GetOverlappedResult above or when
170             // ::PeekNamedPipe tells us the size below. We never set m_readBuffer to a size larger
171             // than the message.
172             ASSERT(m_readBuffer.size() >= sizeof(MessageID));
173             size_t realBufferSize = m_readBuffer.size() - sizeof(MessageID);
174
175             unsigned messageID = *reinterpret_cast<unsigned*>(m_readBuffer.data() + realBufferSize);
176
177             processIncomingMessage(MessageID::fromInt(messageID), adoptPtr(new ArgumentDecoder(m_readBuffer.data(), realBufferSize)));
178         }
179
180         // Find out the size of the next message in the pipe (if there is one) so that we can read
181         // it all in one operation. (This is just an optimization to avoid an extra pass through the
182         // loop (if we chose a buffer size that was too small) or allocating extra memory (if we
183         // chose a buffer size that was too large).)
184         DWORD bytesToRead = 0;
185         if (!::PeekNamedPipe(m_connectionPipe, 0, 0, 0, 0, &bytesToRead)) {
186             DWORD error = ::GetLastError();
187             if (error == ERROR_BROKEN_PIPE) {
188                 connectionDidClose();
189                 return;
190             }
191             ASSERT_NOT_REACHED();
192         }
193         if (!bytesToRead) {
194             // There's no message waiting in the pipe. Schedule a read of the first byte of the
195             // next message. We'll find out the message's actual size when it arrives. (If we
196             // change this to read more than a single byte for performance reasons, we'll have to
197             // deal with m_readBuffer potentially being larger than the message we read after
198             // calling ::GetOverlappedResult above.)
199             bytesToRead = 1;
200         }
201
202         m_readBuffer.resize(bytesToRead);
203
204         // Either read the next available message (which should occur synchronously), or start an
205         // asynchronous read of the next message that becomes available.
206         BOOL result = ::ReadFile(m_connectionPipe, m_readBuffer.data(), m_readBuffer.size(), 0, &m_readState);
207         if (result) {
208             // There was already a message waiting in the pipe, and we read it synchronously.
209             // Process it.
210             continue;
211         }
212
213         DWORD error = ::GetLastError();
214
215         if (error == ERROR_IO_PENDING) {
216             // There are no messages in the pipe currently. readEventHandler will be called again once there is a message.
217             return;
218         }
219
220         if (error == ERROR_MORE_DATA) {
221             // Either a message is available when we didn't think one was, or the message is larger
222             // than ::PeekNamedPipe told us. The former seems far more likely. Probably the message
223             // became available between our calls to ::PeekNamedPipe and ::ReadFile above. Go back
224             // to the top of the loop to use ::GetOverlappedResult to retrieve the available data.
225             continue;
226         }
227
228         // FIXME: We need to handle other errors here.
229         ASSERT_NOT_REACHED();
230     }
231 }
232
233 void Connection::writeEventHandler()
234 {
235     if (m_connectionPipe == INVALID_HANDLE_VALUE)
236         return;
237
238     DWORD numberOfBytesWritten = 0;
239     if (!::GetOverlappedResult(m_connectionPipe, &m_writeState, &numberOfBytesWritten, FALSE)) {
240         DWORD error = ::GetLastError();
241         if (error == ERROR_IO_INCOMPLETE) {
242             // FIXME: We should figure out why we're getting this error.
243             return;
244         }
245         if (error == ERROR_BROKEN_PIPE) {
246             connectionDidClose();
247             return;
248         }
249         ASSERT_NOT_REACHED();
250     }
251
252     // The pending write has finished, so we are now done with its arguments. Clearing this member
253     // will allow us to send messages again.
254     m_pendingWriteArguments = 0;
255
256     // Now that the pending write has finished, we can try to send a new message.
257     sendOutgoingMessages();
258 }
259
260 bool Connection::open()
261 {
262     // We connected the two ends of the pipe in createServerAndClientIdentifiers.
263     m_isConnected = true;
264
265     // Start listening for read and write state events.
266     m_connectionQueue.registerHandle(m_readState.hEvent, WorkItem::create(this, &Connection::readEventHandler));
267     m_connectionQueue.registerHandle(m_writeState.hEvent, WorkItem::create(this, &Connection::writeEventHandler));
268
269     // Schedule a read.
270     m_connectionQueue.scheduleWork(WorkItem::create(this, &Connection::readEventHandler));
271
272     return true;
273 }
274
275 bool Connection::platformCanSendOutgoingMessages() const
276 {
277     // We only allow sending one asynchronous message at a time. If we wanted to send more than one
278     // at once, we'd have to use multiple OVERLAPPED structures and hold onto multiple pending
279     // ArgumentEncoders (one of each for each simultaneous asynchronous message).
280     return !m_pendingWriteArguments;
281 }
282
283 bool Connection::sendOutgoingMessage(MessageID messageID, PassOwnPtr<ArgumentEncoder> arguments)
284 {
285     ASSERT(!m_pendingWriteArguments);
286
287     // Just bail if the handle has been closed.
288     if (m_connectionPipe == INVALID_HANDLE_VALUE)
289         return false;
290
291     // We put the message ID last.
292     arguments->encodeUInt32(messageID.toInt());
293
294     // Write the outgoing message.
295
296     if (::WriteFile(m_connectionPipe, arguments->buffer(), arguments->bufferSize(), 0, &m_writeState)) {
297         // We successfully sent this message.
298         return true;
299     }
300
301     DWORD error = ::GetLastError();
302
303     if (error == ERROR_NO_DATA) {
304         // The pipe is being closed.
305         connectionDidClose();
306         return false;
307     }
308
309     if (error != ERROR_IO_PENDING) {
310         ASSERT_NOT_REACHED();
311         return false;
312     }
313
314     // The message will be sent soon. Hold onto the arguments so that they won't be destroyed
315     // before the write completes.
316     m_pendingWriteArguments = arguments;
317
318     // We can only send one asynchronous message at a time (see comment in platformCanSendOutgoingMessages).
319     return false;
320 }
321
322 } // namespace CoreIPC