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