30c08869cf41c7e94e854a7bf2c60fe904348b83
[WebKit-https.git] / Source / WebCore / Modules / websockets / WebSocketHandshake.cpp
1 /*
2  * Copyright (C) 2011 Google Inc.  All rights reserved.
3  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33
34 #if ENABLE(WEB_SOCKETS)
35
36 #include "WebSocketHandshake.h"
37 #include "WebSocket.h"
38
39 #include "Base64.h"
40 #include "Cookie.h"
41 #include "CookieJar.h"
42 #include "Document.h"
43 #include "HTTPHeaderMap.h"
44 #include "HTTPParsers.h"
45 #include "KURL.h"
46 #include "Logging.h"
47 #include "ScriptCallStack.h"
48 #include "ScriptExecutionContext.h"
49 #include "SecurityOrigin.h"
50 #include <wtf/CryptographicallyRandomNumber.h>
51 #include <wtf/MD5.h>
52 #include <wtf/SHA1.h>
53 #include <wtf/StdLibExtras.h>
54 #include <wtf/StringExtras.h>
55 #include <wtf/Vector.h>
56 #include <wtf/text/CString.h>
57 #include <wtf/text/StringBuilder.h>
58 #include <wtf/text/WTFString.h>
59 #include <wtf/unicode/CharacterNames.h>
60
61 namespace WebCore {
62
63 static const char randomCharacterInSecWebSocketKey[] = "!\"#$%&'()*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
64
65 static String resourceName(const KURL& url)
66 {
67     String name = url.path();
68     if (name.isEmpty())
69         name = "/";
70     if (!url.query().isNull())
71         name += "?" + url.query();
72     ASSERT(!name.isEmpty());
73     ASSERT(!name.contains(' '));
74     return name;
75 }
76
77 static String hostName(const KURL& url, bool secure)
78 {
79     ASSERT(url.protocolIs("wss") == secure);
80     StringBuilder builder;
81     builder.append(url.host().lower());
82     if (url.port() && ((!secure && url.port() != 80) || (secure && url.port() != 443))) {
83         builder.append(':');
84         builder.append(String::number(url.port()));
85     }
86     return builder.toString();
87 }
88
89 static const size_t maxInputSampleSize = 128;
90 static String trimInputSample(const char* p, size_t len)
91 {
92     String s = String(p, std::min<size_t>(len, maxInputSampleSize));
93     if (len > maxInputSampleSize)
94         s.append(horizontalEllipsis);
95     return s;
96 }
97
98 static uint32_t randomNumberLessThan(uint32_t n)
99 {
100     if (!n)
101         return 0;
102     if (n == std::numeric_limits<uint32_t>::max())
103         return cryptographicallyRandomNumber();
104     uint32_t max = std::numeric_limits<uint32_t>::max() - (std::numeric_limits<uint32_t>::max() % n);
105     ASSERT(!(max % n));
106     uint32_t v;
107     do {
108         v = cryptographicallyRandomNumber();
109     } while (v >= max);
110     return v % n;
111 }
112
113 static void generateHixie76SecWebSocketKey(uint32_t& number, String& key)
114 {
115     uint32_t space = randomNumberLessThan(12) + 1;
116     uint32_t max = 4294967295U / space;
117     number = randomNumberLessThan(max);
118     uint32_t product = number * space;
119
120     String s = String::number(product);
121     int n = randomNumberLessThan(12) + 1;
122     DEFINE_STATIC_LOCAL(String, randomChars, (randomCharacterInSecWebSocketKey));
123     for (int i = 0; i < n; i++) {
124         int pos = randomNumberLessThan(s.length() + 1);
125         int chpos = randomNumberLessThan(randomChars.length());
126         s.insert(randomChars.substring(chpos, 1), pos);
127     }
128     DEFINE_STATIC_LOCAL(String, spaceChar, (" "));
129     for (uint32_t i = 0; i < space; i++) {
130         int pos = randomNumberLessThan(s.length() - 1) + 1;
131         s.insert(spaceChar, pos);
132     }
133     ASSERT(s[0] != ' ');
134     ASSERT(s[s.length() - 1] != ' ');
135     key = s;
136 }
137
138 static void generateHixie76Key3(unsigned char key3[8])
139 {
140     cryptographicallyRandomValues(key3, 8);
141 }
142
143 static void setChallengeNumber(unsigned char* buf, uint32_t number)
144 {
145     unsigned char* p = buf + 3;
146     for (int i = 0; i < 4; i++) {
147         *p = number & 0xFF;
148         --p;
149         number >>= 8;
150     }
151 }
152
153 static void generateHixie76ExpectedChallengeResponse(uint32_t number1, uint32_t number2, unsigned char key3[8], unsigned char expectedChallenge[16])
154 {
155     unsigned char challenge[16];
156     setChallengeNumber(&challenge[0], number1);
157     setChallengeNumber(&challenge[4], number2);
158     memcpy(&challenge[8], key3, 8);
159     MD5 md5;
160     md5.addBytes(challenge, sizeof(challenge));
161     Vector<uint8_t, 16> digest;
162     md5.checksum(digest);
163     memcpy(expectedChallenge, digest.data(), 16);
164 }
165
166 static String generateSecWebSocketKey()
167 {
168     static const size_t nonceSize = 16;
169     unsigned char key[nonceSize];
170     cryptographicallyRandomValues(key, nonceSize);
171     return base64Encode(reinterpret_cast<char*>(key), nonceSize);
172 }
173
174 String WebSocketHandshake::getExpectedWebSocketAccept(const String& secWebSocketKey)
175 {
176     static const char* const webSocketKeyGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
177     static const size_t sha1HashSize = 20; // FIXME: This should be defined in SHA1.h.
178     SHA1 sha1;
179     CString keyData = secWebSocketKey.ascii();
180     sha1.addBytes(reinterpret_cast<const uint8_t*>(keyData.data()), keyData.length());
181     sha1.addBytes(reinterpret_cast<const uint8_t*>(webSocketKeyGUID), strlen(webSocketKeyGUID));
182     Vector<uint8_t, sha1HashSize> hash;
183     sha1.computeHash(hash);
184     return base64Encode(reinterpret_cast<const char*>(hash.data()), sha1HashSize);
185 }
186
187 WebSocketHandshake::WebSocketHandshake(const KURL& url, const String& protocol, ScriptExecutionContext* context, bool useHixie76Protocol)
188     : m_url(url)
189     , m_clientProtocol(protocol)
190     , m_secure(m_url.protocolIs("wss"))
191     , m_context(context)
192     , m_useHixie76Protocol(useHixie76Protocol)
193     , m_mode(Incomplete)
194 {
195     if (m_useHixie76Protocol) {
196         uint32_t number1;
197         uint32_t number2;
198         generateHixie76SecWebSocketKey(number1, m_hixie76SecWebSocketKey1);
199         generateHixie76SecWebSocketKey(number2, m_hixie76SecWebSocketKey2);
200         generateHixie76Key3(m_hixie76Key3);
201         generateHixie76ExpectedChallengeResponse(number1, number2, m_hixie76Key3, m_hixie76ExpectedChallengeResponse);
202     } else {
203         m_secWebSocketKey = generateSecWebSocketKey();
204         m_expectedAccept = getExpectedWebSocketAccept(m_secWebSocketKey);
205     }
206 }
207
208 WebSocketHandshake::~WebSocketHandshake()
209 {
210 }
211
212 const KURL& WebSocketHandshake::url() const
213 {
214     return m_url;
215 }
216
217 void WebSocketHandshake::setURL(const KURL& url)
218 {
219     m_url = url.copy();
220 }
221
222 const String WebSocketHandshake::host() const
223 {
224     return m_url.host().lower();
225 }
226
227 const String& WebSocketHandshake::clientProtocol() const
228 {
229     return m_clientProtocol;
230 }
231
232 void WebSocketHandshake::setClientProtocol(const String& protocol)
233 {
234     m_clientProtocol = protocol;
235 }
236
237 bool WebSocketHandshake::secure() const
238 {
239     return m_secure;
240 }
241
242 String WebSocketHandshake::clientOrigin() const
243 {
244     return m_context->securityOrigin()->toString();
245 }
246
247 String WebSocketHandshake::clientLocation() const
248 {
249     StringBuilder builder;
250     builder.append(m_secure ? "wss" : "ws");
251     builder.append("://");
252     builder.append(hostName(m_url, m_secure));
253     builder.append(resourceName(m_url));
254     return builder.toString();
255 }
256
257 CString WebSocketHandshake::clientHandshakeMessage() const
258 {
259     // Keep the following consistent with clientHandshakeRequest().
260     StringBuilder builder;
261
262     builder.append("GET ");
263     builder.append(resourceName(m_url));
264     builder.append(" HTTP/1.1\r\n");
265
266     Vector<String> fields;
267     if (m_useHixie76Protocol)
268         fields.append("Upgrade: WebSocket");
269     else
270         fields.append("Upgrade: websocket");
271     fields.append("Connection: Upgrade");
272     fields.append("Host: " + hostName(m_url, m_secure));
273     fields.append("Origin: " + clientOrigin());
274     if (!m_clientProtocol.isEmpty())
275         fields.append("Sec-WebSocket-Protocol: " + m_clientProtocol);
276
277     KURL url = httpURLForAuthenticationAndCookies();
278     if (m_context->isDocument()) {
279         Document* document = static_cast<Document*>(m_context);
280         String cookie = cookieRequestHeaderFieldValue(document, url);
281         if (!cookie.isEmpty())
282             fields.append("Cookie: " + cookie);
283         // Set "Cookie2: <cookie>" if cookies 2 exists for url?
284     }
285
286     if (m_useHixie76Protocol) {
287         fields.append("Sec-WebSocket-Key1: " + m_hixie76SecWebSocketKey1);
288         fields.append("Sec-WebSocket-Key2: " + m_hixie76SecWebSocketKey2);
289     } else {
290         fields.append("Sec-WebSocket-Key: " + m_secWebSocketKey);
291         fields.append("Sec-WebSocket-Version: 13");
292         const String extensionValue = m_extensionDispatcher.createHeaderValue();
293         if (extensionValue.length())
294             fields.append("Sec-WebSocket-Extensions: " + extensionValue);
295     }
296
297     // Fields in the handshake are sent by the client in a random order; the
298     // order is not meaningful.  Thus, it's ok to send the order we constructed
299     // the fields.
300
301     for (size_t i = 0; i < fields.size(); i++) {
302         builder.append(fields[i]);
303         builder.append("\r\n");
304     }
305
306     builder.append("\r\n");
307
308     CString handshakeHeader = builder.toString().utf8();
309     // Hybi-10 handshake is complete at this point.
310     if (!m_useHixie76Protocol)
311         return handshakeHeader;
312     // Hixie-76 protocol requires sending eight-byte data (so-called "key3") after the request header fields.
313     char* characterBuffer = 0;
314     CString msg = CString::newUninitialized(handshakeHeader.length() + sizeof(m_hixie76Key3), characterBuffer);
315     memcpy(characterBuffer, handshakeHeader.data(), handshakeHeader.length());
316     memcpy(characterBuffer + handshakeHeader.length(), m_hixie76Key3, sizeof(m_hixie76Key3));
317     return msg;
318 }
319
320 PassRefPtr<WebSocketHandshakeRequest> WebSocketHandshake::clientHandshakeRequest() const
321 {
322     // Keep the following consistent with clientHandshakeMessage().
323     // FIXME: do we need to store m_secWebSocketKey1, m_secWebSocketKey2 and
324     // m_key3 in WebSocketHandshakeRequest?
325     RefPtr<WebSocketHandshakeRequest> request = WebSocketHandshakeRequest::create("GET", m_url);
326     if (m_useHixie76Protocol)
327         request->addHeaderField("Upgrade", "WebSocket");
328     else
329         request->addHeaderField("Upgrade", "websocket");
330     request->addHeaderField("Connection", "Upgrade");
331     request->addHeaderField("Host", hostName(m_url, m_secure));
332     request->addHeaderField("Origin", clientOrigin());
333     if (!m_clientProtocol.isEmpty())
334         request->addHeaderField("Sec-WebSocket-Protocol", m_clientProtocol);
335
336     KURL url = httpURLForAuthenticationAndCookies();
337     if (m_context->isDocument()) {
338         Document* document = static_cast<Document*>(m_context);
339         String cookie = cookieRequestHeaderFieldValue(document, url);
340         if (!cookie.isEmpty())
341             request->addHeaderField("Cookie", cookie);
342         // Set "Cookie2: <cookie>" if cookies 2 exists for url?
343     }
344
345     if (m_useHixie76Protocol) {
346         request->addHeaderField("Sec-WebSocket-Key1", m_hixie76SecWebSocketKey1);
347         request->addHeaderField("Sec-WebSocket-Key2", m_hixie76SecWebSocketKey2);
348         request->setKey3(m_hixie76Key3);
349     } else {
350         request->addHeaderField("Sec-WebSocket-Key", m_secWebSocketKey);
351         request->addHeaderField("Sec-WebSocket-Version", "13");
352         const String extensionValue = m_extensionDispatcher.createHeaderValue();
353         if (extensionValue.length())
354             request->addHeaderField("Sec-WebSocket-Extensions", extensionValue);
355     }
356
357     return request.release();
358 }
359
360 void WebSocketHandshake::reset()
361 {
362     m_mode = Incomplete;
363     m_extensionDispatcher.reset();
364 }
365
366 void WebSocketHandshake::clearScriptExecutionContext()
367 {
368     m_context = 0;
369 }
370
371 int WebSocketHandshake::readServerHandshake(const char* header, size_t len)
372 {
373     m_mode = Incomplete;
374     int statusCode;
375     String statusText;
376     int lineLength = readStatusLine(header, len, statusCode, statusText);
377     if (lineLength == -1)
378         return -1;
379     if (statusCode == -1) {
380         m_mode = Failed; // m_failureReason is set inside readStatusLine().
381         return len;
382     }
383     LOG(Network, "response code: %d", statusCode);
384     m_response.setStatusCode(statusCode);
385     m_response.setStatusText(statusText);
386     if (statusCode != 101) {
387         m_mode = Failed;
388         m_failureReason = "Unexpected response code: " + String::number(statusCode);
389         return len;
390     }
391     m_mode = Normal;
392     if (!strnstr(header, "\r\n\r\n", len)) {
393         // Just hasn't been received fully yet.
394         m_mode = Incomplete;
395         return -1;
396     }
397     const char* p = readHTTPHeaders(header + lineLength, header + len);
398     if (!p) {
399         LOG(Network, "readHTTPHeaders failed");
400         m_mode = Failed; // m_failureReason is set inside readHTTPHeaders().
401         return len;
402     }
403     if (!checkResponseHeaders()) {
404         LOG(Network, "header process failed");
405         m_mode = Failed;
406         return p - header;
407     }
408
409     if (!m_useHixie76Protocol) { // Hybi-10 handshake is complete at this point.
410         m_mode = Connected;
411         return p - header;
412     }
413
414     // In hixie-76 protocol, server's handshake contains sixteen-byte data (called "challenge response")
415     // after the header fields.
416     if (len < static_cast<size_t>(p - header + sizeof(m_hixie76ExpectedChallengeResponse))) {
417         // Just hasn't been received /expected/ yet.
418         m_mode = Incomplete;
419         return -1;
420     }
421
422     m_response.setChallengeResponse(static_cast<const unsigned char*>(static_cast<const void*>(p)));
423     if (memcmp(p, m_hixie76ExpectedChallengeResponse, sizeof(m_hixie76ExpectedChallengeResponse))) {
424         m_mode = Failed;
425         return (p - header) + sizeof(m_hixie76ExpectedChallengeResponse);
426     }
427     m_mode = Connected;
428     return (p - header) + sizeof(m_hixie76ExpectedChallengeResponse);
429 }
430
431 WebSocketHandshake::Mode WebSocketHandshake::mode() const
432 {
433     return m_mode;
434 }
435
436 String WebSocketHandshake::failureReason() const
437 {
438     return m_failureReason;
439 }
440
441 String WebSocketHandshake::serverWebSocketOrigin() const
442 {
443     return m_response.headerFields().get("sec-websocket-origin");
444 }
445
446 String WebSocketHandshake::serverWebSocketLocation() const
447 {
448     return m_response.headerFields().get("sec-websocket-location");
449 }
450
451 String WebSocketHandshake::serverWebSocketProtocol() const
452 {
453     return m_response.headerFields().get("sec-websocket-protocol");
454 }
455
456 String WebSocketHandshake::serverSetCookie() const
457 {
458     return m_response.headerFields().get("set-cookie");
459 }
460
461 String WebSocketHandshake::serverSetCookie2() const
462 {
463     return m_response.headerFields().get("set-cookie2");
464 }
465
466 String WebSocketHandshake::serverUpgrade() const
467 {
468     return m_response.headerFields().get("upgrade");
469 }
470
471 String WebSocketHandshake::serverConnection() const
472 {
473     return m_response.headerFields().get("connection");
474 }
475
476 String WebSocketHandshake::serverWebSocketAccept() const
477 {
478     return m_response.headerFields().get("sec-websocket-accept");
479 }
480
481 String WebSocketHandshake::acceptedExtensions() const
482 {
483     return m_extensionDispatcher.acceptedExtensions();
484 }
485
486 const WebSocketHandshakeResponse& WebSocketHandshake::serverHandshakeResponse() const
487 {
488     return m_response;
489 }
490
491 void WebSocketHandshake::addExtensionProcessor(PassOwnPtr<WebSocketExtensionProcessor> processor)
492 {
493     m_extensionDispatcher.addProcessor(processor);
494 }
495
496 KURL WebSocketHandshake::httpURLForAuthenticationAndCookies() const
497 {
498     KURL url = m_url.copy();
499     bool couldSetProtocol = url.setProtocol(m_secure ? "https" : "http");
500     ASSERT_UNUSED(couldSetProtocol, couldSetProtocol);
501     return url;
502 }
503
504 // Returns the header length (including "\r\n"), or -1 if we have not received enough data yet.
505 // If the line is malformed or the status code is not a 3-digit number,
506 // statusCode and statusText will be set to -1 and a null string, respectively.
507 int WebSocketHandshake::readStatusLine(const char* header, size_t headerLength, int& statusCode, String& statusText)
508 {
509     // Arbitrary size limit to prevent the server from sending an unbounded
510     // amount of data with no newlines and forcing us to buffer it all.
511     static const int maximumLength = 1024;
512
513     statusCode = -1;
514     statusText = String();
515
516     const char* space1 = 0;
517     const char* space2 = 0;
518     const char* p;
519     size_t consumedLength;
520
521     for (p = header, consumedLength = 0; consumedLength < headerLength; p++, consumedLength++) {
522         if (*p == ' ') {
523             if (!space1)
524                 space1 = p;
525             else if (!space2)
526                 space2 = p;
527         } else if (*p == '\0') {
528             // The caller isn't prepared to deal with null bytes in status
529             // line. WebSockets specification doesn't prohibit this, but HTTP
530             // does, so we'll just treat this as an error.
531             m_failureReason = "Status line contains embedded null";
532             return p + 1 - header;
533         } else if (*p == '\n')
534             break;
535     }
536     if (consumedLength == headerLength)
537         return -1; // We have not received '\n' yet.
538
539     const char* end = p + 1;
540     int lineLength = end - header;
541     if (lineLength > maximumLength) {
542         m_failureReason = "Status line is too long";
543         return maximumLength;
544     }
545
546     // The line must end with "\r\n".
547     if (lineLength < 2 || *(end - 2) != '\r') {
548         m_failureReason = "Status line does not end with CRLF";
549         return lineLength;
550     }
551
552     if (!space1 || !space2) {
553         m_failureReason = "No response code found: " + trimInputSample(header, lineLength - 2);
554         return lineLength;
555     }
556
557     String statusCodeString(space1 + 1, space2 - space1 - 1);
558     if (statusCodeString.length() != 3) // Status code must consist of three digits.
559         return lineLength;
560     for (int i = 0; i < 3; ++i)
561         if (statusCodeString[i] < '0' || statusCodeString[i] > '9') {
562             m_failureReason = "Invalid status code: " + statusCodeString;
563             return lineLength;
564         }
565
566     bool ok = false;
567     statusCode = statusCodeString.toInt(&ok);
568     ASSERT(ok);
569
570     statusText = String(space2 + 1, end - space2 - 3); // Exclude "\r\n".
571     return lineLength;
572 }
573
574 const char* WebSocketHandshake::readHTTPHeaders(const char* start, const char* end)
575 {
576     m_response.clearHeaderFields();
577
578     AtomicString name;
579     String value;
580     bool sawSecWebSocketAcceptHeaderField = false;
581     bool sawSecWebSocketProtocolHeaderField = false;
582     const char* p = start;
583     for (; p < end; p++) {
584         size_t consumedLength = parseHTTPHeader(p, end - p, m_failureReason, name, value);
585         if (!consumedLength)
586             return 0;
587         p += consumedLength;
588
589         // Stop once we consumed an empty line.
590         if (name.isEmpty())
591             break;
592
593         // Sec-WebSocket-Extensions may be split. We parse and check the
594         // header value every time the header appears.
595         if (equalIgnoringCase("sec-websocket-extensions", name)) {
596             if (!m_extensionDispatcher.processHeaderValue(value)) {
597                 m_failureReason = m_extensionDispatcher.failureReason();
598                 return 0;
599             }
600         } else if (equalIgnoringCase("Sec-WebSocket-Accept", name)) {
601             if (sawSecWebSocketAcceptHeaderField) {
602                 m_failureReason = "The Sec-WebSocket-Accept header MUST NOT appear more than once in an HTTP response";
603                 return 0;
604             }
605             m_response.addHeaderField(name, value);
606             sawSecWebSocketAcceptHeaderField = true;
607         } else if (equalIgnoringCase("Sec-WebSocket-Protocol", name)) {
608             if (sawSecWebSocketProtocolHeaderField) {
609                 m_failureReason = "The Sec-WebSocket-Protocol header MUST NOT appear more than once in an HTTP response";
610                 return 0;
611             }
612             m_response.addHeaderField(name, value);
613             sawSecWebSocketProtocolHeaderField = true;
614         } else
615             m_response.addHeaderField(name, value);
616     }
617     return p;
618 }
619
620 bool WebSocketHandshake::checkResponseHeaders()
621 {
622     const String& serverWebSocketLocation = this->serverWebSocketLocation();
623     const String& serverWebSocketOrigin = this->serverWebSocketOrigin();
624     const String& serverWebSocketProtocol = this->serverWebSocketProtocol();
625     const String& serverUpgrade = this->serverUpgrade();
626     const String& serverConnection = this->serverConnection();
627     const String& serverWebSocketAccept = this->serverWebSocketAccept();
628
629     if (serverUpgrade.isNull()) {
630         m_failureReason = "Error during WebSocket handshake: 'Upgrade' header is missing";
631         return false;
632     }
633     if (serverConnection.isNull()) {
634         m_failureReason = "Error during WebSocket handshake: 'Connection' header is missing";
635         return false;
636     }
637     if (m_useHixie76Protocol) {
638         if (serverWebSocketOrigin.isNull()) {
639             m_failureReason = "Error during WebSocket handshake: 'Sec-WebSocket-Origin' header is missing";
640             return false;
641         }
642         if (serverWebSocketLocation.isNull()) {
643             m_failureReason = "Error during WebSocket handshake: 'Sec-WebSocket-Location' header is missing";
644             return false;
645         }
646     } else {
647         if (serverWebSocketAccept.isNull()) {
648             m_failureReason = "Error during WebSocket handshake: 'Sec-WebSocket-Accept' header is missing";
649             return false;
650         }
651     }
652
653     if (!equalIgnoringCase(serverUpgrade, "websocket")) {
654         m_failureReason = "Error during WebSocket handshake: 'Upgrade' header value is not 'WebSocket'";
655         return false;
656     }
657     if (!equalIgnoringCase(serverConnection, "upgrade")) {
658         m_failureReason = "Error during WebSocket handshake: 'Connection' header value is not 'Upgrade'";
659         return false;
660     }
661
662     if (m_useHixie76Protocol) {
663         if (clientOrigin() != serverWebSocketOrigin) {
664             m_failureReason = "Error during WebSocket handshake: origin mismatch: " + clientOrigin() + " != " + serverWebSocketOrigin;
665             return false;
666         }
667         if (clientLocation() != serverWebSocketLocation) {
668             m_failureReason = "Error during WebSocket handshake: location mismatch: " + clientLocation() + " != " + serverWebSocketLocation;
669             return false;
670         }
671         if (!m_clientProtocol.isEmpty() && m_clientProtocol != serverWebSocketProtocol) {
672             m_failureReason = "Error during WebSocket handshake: protocol mismatch: " + m_clientProtocol + " != " + serverWebSocketProtocol;
673             return false;
674         }
675     } else {
676         if (serverWebSocketAccept != m_expectedAccept) {
677             m_failureReason = "Error during WebSocket handshake: Sec-WebSocket-Accept mismatch";
678             return false;
679         }
680         if (!serverWebSocketProtocol.isNull()) {
681             if (m_clientProtocol.isEmpty()) {
682                 m_failureReason = "Error during WebSocket handshake: Sec-WebSocket-Protocol mismatch";
683                 return false;
684             }
685             Vector<String> result;
686             m_clientProtocol.split(String(WebSocket::subProtocolSeperator()), result);
687             if (!result.contains(serverWebSocketProtocol)) {
688                 m_failureReason = "Error during WebSocket handshake: Sec-WebSocket-Protocol mismatch";
689                 return false;
690             }
691         }
692     }
693     return true;
694 }
695
696 } // namespace WebCore
697
698 #endif // ENABLE(WEB_SOCKETS)