6a0649f83d12825b6a01155153cf629f34db41bb
[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         // FIXME: Current version of pywebsocket only accepts version value of 7,
293         // while hybi-10 requires this value to be 8. Should be fixed when
294         // a new version of pywebsocket is released.
295         fields.append("Sec-WebSocket-Version: 7");
296     }
297
298     // Fields in the handshake are sent by the client in a random order; the
299     // order is not meaningful.  Thus, it's ok to send the order we constructed
300     // the fields.
301
302     for (size_t i = 0; i < fields.size(); i++) {
303         builder.append(fields[i]);
304         builder.append("\r\n");
305     }
306
307     builder.append("\r\n");
308
309     CString handshakeHeader = builder.toString().utf8();
310     // Hybi-10 handshake is complete at this point.
311     if (!m_useHixie76Protocol)
312         return handshakeHeader;
313     // Hixie-76 protocol requires sending eight-byte data (so-called "key3") after the request header fields.
314     char* characterBuffer = 0;
315     CString msg = CString::newUninitialized(handshakeHeader.length() + sizeof(m_hixie76Key3), characterBuffer);
316     memcpy(characterBuffer, handshakeHeader.data(), handshakeHeader.length());
317     memcpy(characterBuffer + handshakeHeader.length(), m_hixie76Key3, sizeof(m_hixie76Key3));
318     return msg;
319 }
320
321 WebSocketHandshakeRequest WebSocketHandshake::clientHandshakeRequest() const
322 {
323     // Keep the following consistent with clientHandshakeMessage().
324     // FIXME: do we need to store m_secWebSocketKey1, m_secWebSocketKey2 and
325     // m_key3 in WebSocketHandshakeRequest?
326     WebSocketHandshakeRequest request("GET", m_url);
327     if (m_useHixie76Protocol)
328         request.addHeaderField("Upgrade", "WebSocket");
329     else
330         request.addHeaderField("Upgrade", "websocket");
331     request.addHeaderField("Connection", "Upgrade");
332     request.addHeaderField("Host", hostName(m_url, m_secure));
333     if (m_useHixie76Protocol)
334         request.addHeaderField("Origin", clientOrigin());
335     else
336         request.addHeaderField("Sec-WebSocket-Origin", clientOrigin());
337     if (!m_clientProtocol.isEmpty())
338         request.addHeaderField("Sec-WebSocket-Protocol:", m_clientProtocol);
339
340     KURL url = httpURLForAuthenticationAndCookies();
341     if (m_context->isDocument()) {
342         Document* document = static_cast<Document*>(m_context);
343         String cookie = cookieRequestHeaderFieldValue(document, url);
344         if (!cookie.isEmpty())
345             request.addHeaderField("Cookie", cookie);
346         // Set "Cookie2: <cookie>" if cookies 2 exists for url?
347     }
348
349     if (m_useHixie76Protocol) {
350         request.addHeaderField("Sec-WebSocket-Key1", m_hixie76SecWebSocketKey1);
351         request.addHeaderField("Sec-WebSocket-Key2", m_hixie76SecWebSocketKey2);
352         request.setKey3(m_hixie76Key3);
353     } else {
354         request.addHeaderField("Sec-WebSocket-Key", m_secWebSocketKey);
355         request.addHeaderField("Sec-WebSocket-Version", "7"); // FIXME: See FIXME in clientHandshakeMessage().
356     }
357
358     return request;
359 }
360
361 void WebSocketHandshake::reset()
362 {
363     m_mode = Incomplete;
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::serverWebSocketExtensions() const
482 {
483     return m_response.headerFields().get("sec-websocket-extensions");
484 }
485
486 const WebSocketHandshakeResponse& WebSocketHandshake::serverHandshakeResponse() const
487 {
488     return m_response;
489 }
490
491 KURL WebSocketHandshake::httpURLForAuthenticationAndCookies() const
492 {
493     KURL url = m_url.copy();
494     bool couldSetProtocol = url.setProtocol(m_secure ? "https" : "http");
495     ASSERT_UNUSED(couldSetProtocol, couldSetProtocol);
496     return url;
497 }
498
499 // Returns the header length (including "\r\n"), or -1 if we have not received enough data yet.
500 // If the line is malformed or the status code is not a 3-digit number,
501 // statusCode and statusText will be set to -1 and a null string, respectively.
502 int WebSocketHandshake::readStatusLine(const char* header, size_t headerLength, int& statusCode, String& statusText)
503 {
504     // Arbitrary size limit to prevent the server from sending an unbounded
505     // amount of data with no newlines and forcing us to buffer it all.
506     static const int maximumLength = 1024;
507
508     statusCode = -1;
509     statusText = String();
510
511     const char* space1 = 0;
512     const char* space2 = 0;
513     const char* p;
514     size_t consumedLength;
515
516     for (p = header, consumedLength = 0; consumedLength < headerLength; p++, consumedLength++) {
517         if (*p == ' ') {
518             if (!space1)
519                 space1 = p;
520             else if (!space2)
521                 space2 = p;
522         } else if (*p == '\0') {
523             // The caller isn't prepared to deal with null bytes in status
524             // line. WebSockets specification doesn't prohibit this, but HTTP
525             // does, so we'll just treat this as an error.
526             m_failureReason = "Status line contains embedded null";
527             return p + 1 - header;
528         } else if (*p == '\n')
529             break;
530     }
531     if (consumedLength == headerLength)
532         return -1; // We have not received '\n' yet.
533
534     const char* end = p + 1;
535     int lineLength = end - header;
536     if (lineLength > maximumLength) {
537         m_failureReason = "Status line is too long";
538         return maximumLength;
539     }
540
541     // The line must end with "\r\n".
542     if (lineLength < 2 || *(end - 2) != '\r') {
543         m_failureReason = "Status line does not end with CRLF";
544         return lineLength;
545     }
546
547     if (!space1 || !space2) {
548         m_failureReason = "No response code found: " + trimConsoleMessage(header, lineLength - 2);
549         return lineLength;
550     }
551
552     String statusCodeString(space1 + 1, space2 - space1 - 1);
553     if (statusCodeString.length() != 3) // Status code must consist of three digits.
554         return lineLength;
555     for (int i = 0; i < 3; ++i)
556         if (statusCodeString[i] < '0' || statusCodeString[i] > '9') {
557             m_failureReason = "Invalid status code: " + statusCodeString;
558             return lineLength;
559         }
560
561     bool ok = false;
562     statusCode = statusCodeString.toInt(&ok);
563     ASSERT(ok);
564
565     statusText = String(space2 + 1, end - space2 - 3); // Exclude "\r\n".
566     return lineLength;
567 }
568
569 const char* WebSocketHandshake::readHTTPHeaders(const char* start, const char* end)
570 {
571     m_response.clearHeaderFields();
572
573     Vector<char> name;
574     Vector<char> value;
575     for (const char* p = start; p < end; p++) {
576         name.clear();
577         value.clear();
578
579         for (; p < end; p++) {
580             switch (*p) {
581             case '\r':
582                 if (name.isEmpty()) {
583                     if (p + 1 < end && *(p + 1) == '\n')
584                         return p + 2;
585                     m_failureReason = "CR doesn't follow LF at " + trimConsoleMessage(p, end - p);
586                     return 0;
587                 }
588                 m_failureReason = "Unexpected CR in name at " + trimConsoleMessage(name.data(), name.size());
589                 return 0;
590             case '\n':
591                 m_failureReason = "Unexpected LF in name at " + trimConsoleMessage(name.data(), name.size());
592                 return 0;
593             case ':':
594                 break;
595             default:
596                 name.append(*p);
597                 continue;
598             }
599             if (*p == ':') {
600                 ++p;
601                 break;
602             }
603         }
604
605         for (; p < end && *p == 0x20; p++) { }
606
607         for (; p < end; p++) {
608             switch (*p) {
609             case '\r':
610                 break;
611             case '\n':
612                 m_failureReason = "Unexpected LF in value at " + trimConsoleMessage(value.data(), value.size());
613                 return 0;
614             default:
615                 value.append(*p);
616             }
617             if (*p == '\r') {
618                 ++p;
619                 break;
620             }
621         }
622         if (p >= end || *p != '\n') {
623             m_failureReason = "CR doesn't follow LF after value at " + trimConsoleMessage(p, end - p);
624             return 0;
625         }
626         AtomicString nameStr = AtomicString::fromUTF8(name.data(), name.size());
627         String valueStr = String::fromUTF8(value.data(), value.size());
628         if (nameStr.isNull()) {
629             m_failureReason = "Invalid UTF-8 sequence in header name";
630             return 0;
631         }
632         if (valueStr.isNull()) {
633             m_failureReason = "Invalid UTF-8 sequence in header value";
634             return 0;
635         }
636         LOG(Network, "name=%s value=%s", nameStr.string().utf8().data(), valueStr.utf8().data());
637         m_response.addHeaderField(nameStr, valueStr);
638     }
639     ASSERT_NOT_REACHED();
640     return 0;
641 }
642
643 bool WebSocketHandshake::checkResponseHeaders()
644 {
645     const String& serverWebSocketLocation = this->serverWebSocketLocation();
646     const String& serverWebSocketOrigin = this->serverWebSocketOrigin();
647     const String& serverWebSocketProtocol = this->serverWebSocketProtocol();
648     const String& serverUpgrade = this->serverUpgrade();
649     const String& serverConnection = this->serverConnection();
650     const String& serverWebSocketAccept = this->serverWebSocketAccept();
651     const String& serverWebSocketExtensions = this->serverWebSocketExtensions();
652
653     if (serverUpgrade.isNull()) {
654         m_failureReason = "Error during WebSocket handshake: 'Upgrade' header is missing";
655         return false;
656     }
657     if (serverConnection.isNull()) {
658         m_failureReason = "Error during WebSocket handshake: 'Connection' header is missing";
659         return false;
660     }
661     if (m_useHixie76Protocol) {
662         if (serverWebSocketOrigin.isNull()) {
663             m_failureReason = "Error during WebSocket handshake: 'Sec-WebSocket-Origin' header is missing";
664             return false;
665         }
666         if (serverWebSocketLocation.isNull()) {
667             m_failureReason = "Error during WebSocket handshake: 'Sec-WebSocket-Location' header is missing";
668             return false;
669         }
670     } else {
671         if (serverWebSocketAccept.isNull()) {
672             m_failureReason = "Error during WebSocket handshake: 'Sec-WebSocket-Accept' header is missing";
673             return false;
674         }
675     }
676
677     if (!equalIgnoringCase(serverUpgrade, "websocket")) {
678         m_failureReason = "Error during WebSocket handshake: 'Upgrade' header value is not 'WebSocket'";
679         return false;
680     }
681     if (!equalIgnoringCase(serverConnection, "upgrade")) {
682         m_failureReason = "Error during WebSocket handshake: 'Connection' header value is not 'Upgrade'";
683         return false;
684     }
685
686     if (m_useHixie76Protocol) {
687         if (clientOrigin() != serverWebSocketOrigin) {
688             m_failureReason = "Error during WebSocket handshake: origin mismatch: " + clientOrigin() + " != " + serverWebSocketOrigin;
689             return false;
690         }
691         if (clientLocation() != serverWebSocketLocation) {
692             m_failureReason = "Error during WebSocket handshake: location mismatch: " + clientLocation() + " != " + serverWebSocketLocation;
693             return false;
694         }
695         if (!m_clientProtocol.isEmpty() && m_clientProtocol != serverWebSocketProtocol) {
696             m_failureReason = "Error during WebSocket handshake: protocol mismatch: " + m_clientProtocol + " != " + serverWebSocketProtocol;
697             return false;
698         }
699     } else {
700         if (serverWebSocketAccept != m_expectedAccept) {
701             m_failureReason = "Error during WebSocket handshake: Sec-WebSocket-Accept mismatch";
702             return false;
703         }
704         if (!serverWebSocketExtensions.isNull()) {
705             // WebSocket protocol extensions are not supported yet.
706             // We do not send Sec-WebSocket-Extensions header in our request, thus
707             // servers should not return this header, either.
708             m_failureReason = "Error during WebSocket handshake: Sec-WebSocket-Extensions header is invalid";
709             return false;
710         }
711     }
712     return true;
713 }
714
715 } // namespace WebCore
716
717 #endif // ENABLE(WEB_SOCKETS)