Move websockets to Modules/websockets
[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
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     fields.append("Origin: " + clientOrigin());
272     if (!m_clientProtocol.isEmpty())
273         fields.append("Sec-WebSocket-Protocol: " + m_clientProtocol);
274
275     KURL url = httpURLForAuthenticationAndCookies();
276     if (m_context->isDocument()) {
277         Document* document = static_cast<Document*>(m_context);
278         String cookie = cookieRequestHeaderFieldValue(document, url);
279         if (!cookie.isEmpty())
280             fields.append("Cookie: " + cookie);
281         // Set "Cookie2: <cookie>" if cookies 2 exists for url?
282     }
283
284     if (m_useHixie76Protocol) {
285         fields.append("Sec-WebSocket-Key1: " + m_hixie76SecWebSocketKey1);
286         fields.append("Sec-WebSocket-Key2: " + m_hixie76SecWebSocketKey2);
287     } else {
288         fields.append("Sec-WebSocket-Key: " + m_secWebSocketKey);
289         fields.append("Sec-WebSocket-Version: 13");
290         const String extensionValue = m_extensionDispatcher.createHeaderValue();
291         if (extensionValue.length())
292             fields.append("Sec-WebSocket-Extensions: " + extensionValue);
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     request.addHeaderField("Origin", clientOrigin());
331     if (!m_clientProtocol.isEmpty())
332         request.addHeaderField("Sec-WebSocket-Protocol:", m_clientProtocol);
333
334     KURL url = httpURLForAuthenticationAndCookies();
335     if (m_context->isDocument()) {
336         Document* document = static_cast<Document*>(m_context);
337         String cookie = cookieRequestHeaderFieldValue(document, url);
338         if (!cookie.isEmpty())
339             request.addHeaderField("Cookie", cookie);
340         // Set "Cookie2: <cookie>" if cookies 2 exists for url?
341     }
342
343     if (m_useHixie76Protocol) {
344         request.addHeaderField("Sec-WebSocket-Key1", m_hixie76SecWebSocketKey1);
345         request.addHeaderField("Sec-WebSocket-Key2", m_hixie76SecWebSocketKey2);
346         request.setKey3(m_hixie76Key3);
347     } else {
348         request.addHeaderField("Sec-WebSocket-Key", m_secWebSocketKey);
349         request.addHeaderField("Sec-WebSocket-Version", "13");
350         const String extensionValue = m_extensionDispatcher.createHeaderValue();
351         if (extensionValue.length())
352             request.addHeaderField("Sec-WebSocket-Extensions", extensionValue);
353     }
354
355     return request;
356 }
357
358 void WebSocketHandshake::reset()
359 {
360     m_mode = Incomplete;
361     m_extensionDispatcher.reset();
362 }
363
364 void WebSocketHandshake::clearScriptExecutionContext()
365 {
366     m_context = 0;
367 }
368
369 int WebSocketHandshake::readServerHandshake(const char* header, size_t len)
370 {
371     m_mode = Incomplete;
372     int statusCode;
373     String statusText;
374     int lineLength = readStatusLine(header, len, statusCode, statusText);
375     if (lineLength == -1)
376         return -1;
377     if (statusCode == -1) {
378         m_mode = Failed; // m_failureReason is set inside readStatusLine().
379         return len;
380     }
381     LOG(Network, "response code: %d", statusCode);
382     m_response.setStatusCode(statusCode);
383     m_response.setStatusText(statusText);
384     if (statusCode != 101) {
385         m_mode = Failed;
386         m_failureReason = "Unexpected response code: " + String::number(statusCode);
387         return len;
388     }
389     m_mode = Normal;
390     if (!strnstr(header, "\r\n\r\n", len)) {
391         // Just hasn't been received fully yet.
392         m_mode = Incomplete;
393         return -1;
394     }
395     const char* p = readHTTPHeaders(header + lineLength, header + len);
396     if (!p) {
397         LOG(Network, "readHTTPHeaders failed");
398         m_mode = Failed; // m_failureReason is set inside readHTTPHeaders().
399         return len;
400     }
401     if (!checkResponseHeaders()) {
402         LOG(Network, "header process failed");
403         m_mode = Failed;
404         return p - header;
405     }
406
407     if (!m_useHixie76Protocol) { // Hybi-10 handshake is complete at this point.
408         m_mode = Connected;
409         return p - header;
410     }
411
412     // In hixie-76 protocol, server's handshake contains sixteen-byte data (called "challenge response")
413     // after the header fields.
414     if (len < static_cast<size_t>(p - header + sizeof(m_hixie76ExpectedChallengeResponse))) {
415         // Just hasn't been received /expected/ yet.
416         m_mode = Incomplete;
417         return -1;
418     }
419
420     m_response.setChallengeResponse(static_cast<const unsigned char*>(static_cast<const void*>(p)));
421     if (memcmp(p, m_hixie76ExpectedChallengeResponse, sizeof(m_hixie76ExpectedChallengeResponse))) {
422         m_mode = Failed;
423         return (p - header) + sizeof(m_hixie76ExpectedChallengeResponse);
424     }
425     m_mode = Connected;
426     return (p - header) + sizeof(m_hixie76ExpectedChallengeResponse);
427 }
428
429 WebSocketHandshake::Mode WebSocketHandshake::mode() const
430 {
431     return m_mode;
432 }
433
434 String WebSocketHandshake::failureReason() const
435 {
436     return m_failureReason;
437 }
438
439 String WebSocketHandshake::serverWebSocketOrigin() const
440 {
441     return m_response.headerFields().get("sec-websocket-origin");
442 }
443
444 String WebSocketHandshake::serverWebSocketLocation() const
445 {
446     return m_response.headerFields().get("sec-websocket-location");
447 }
448
449 String WebSocketHandshake::serverWebSocketProtocol() const
450 {
451     return m_response.headerFields().get("sec-websocket-protocol");
452 }
453
454 String WebSocketHandshake::serverSetCookie() const
455 {
456     return m_response.headerFields().get("set-cookie");
457 }
458
459 String WebSocketHandshake::serverSetCookie2() const
460 {
461     return m_response.headerFields().get("set-cookie2");
462 }
463
464 String WebSocketHandshake::serverUpgrade() const
465 {
466     return m_response.headerFields().get("upgrade");
467 }
468
469 String WebSocketHandshake::serverConnection() const
470 {
471     return m_response.headerFields().get("connection");
472 }
473
474 String WebSocketHandshake::serverWebSocketAccept() const
475 {
476     return m_response.headerFields().get("sec-websocket-accept");
477 }
478
479 String WebSocketHandshake::acceptedExtensions() const
480 {
481     return m_extensionDispatcher.acceptedExtensions();
482 }
483
484 const WebSocketHandshakeResponse& WebSocketHandshake::serverHandshakeResponse() const
485 {
486     return m_response;
487 }
488
489 void WebSocketHandshake::addExtensionProcessor(PassOwnPtr<WebSocketExtensionProcessor> processor)
490 {
491     m_extensionDispatcher.addProcessor(processor);
492 }
493
494 KURL WebSocketHandshake::httpURLForAuthenticationAndCookies() const
495 {
496     KURL url = m_url.copy();
497     bool couldSetProtocol = url.setProtocol(m_secure ? "https" : "http");
498     ASSERT_UNUSED(couldSetProtocol, couldSetProtocol);
499     return url;
500 }
501
502 // Returns the header length (including "\r\n"), or -1 if we have not received enough data yet.
503 // If the line is malformed or the status code is not a 3-digit number,
504 // statusCode and statusText will be set to -1 and a null string, respectively.
505 int WebSocketHandshake::readStatusLine(const char* header, size_t headerLength, int& statusCode, String& statusText)
506 {
507     // Arbitrary size limit to prevent the server from sending an unbounded
508     // amount of data with no newlines and forcing us to buffer it all.
509     static const int maximumLength = 1024;
510
511     statusCode = -1;
512     statusText = String();
513
514     const char* space1 = 0;
515     const char* space2 = 0;
516     const char* p;
517     size_t consumedLength;
518
519     for (p = header, consumedLength = 0; consumedLength < headerLength; p++, consumedLength++) {
520         if (*p == ' ') {
521             if (!space1)
522                 space1 = p;
523             else if (!space2)
524                 space2 = p;
525         } else if (*p == '\0') {
526             // The caller isn't prepared to deal with null bytes in status
527             // line. WebSockets specification doesn't prohibit this, but HTTP
528             // does, so we'll just treat this as an error.
529             m_failureReason = "Status line contains embedded null";
530             return p + 1 - header;
531         } else if (*p == '\n')
532             break;
533     }
534     if (consumedLength == headerLength)
535         return -1; // We have not received '\n' yet.
536
537     const char* end = p + 1;
538     int lineLength = end - header;
539     if (lineLength > maximumLength) {
540         m_failureReason = "Status line is too long";
541         return maximumLength;
542     }
543
544     // The line must end with "\r\n".
545     if (lineLength < 2 || *(end - 2) != '\r') {
546         m_failureReason = "Status line does not end with CRLF";
547         return lineLength;
548     }
549
550     if (!space1 || !space2) {
551         m_failureReason = "No response code found: " + trimConsoleMessage(header, lineLength - 2);
552         return lineLength;
553     }
554
555     String statusCodeString(space1 + 1, space2 - space1 - 1);
556     if (statusCodeString.length() != 3) // Status code must consist of three digits.
557         return lineLength;
558     for (int i = 0; i < 3; ++i)
559         if (statusCodeString[i] < '0' || statusCodeString[i] > '9') {
560             m_failureReason = "Invalid status code: " + statusCodeString;
561             return lineLength;
562         }
563
564     bool ok = false;
565     statusCode = statusCodeString.toInt(&ok);
566     ASSERT(ok);
567
568     statusText = String(space2 + 1, end - space2 - 3); // Exclude "\r\n".
569     return lineLength;
570 }
571
572 const char* WebSocketHandshake::readHTTPHeaders(const char* start, const char* end)
573 {
574     m_response.clearHeaderFields();
575
576     Vector<char> name;
577     Vector<char> value;
578     for (const char* p = start; p < end; p++) {
579         name.clear();
580         value.clear();
581
582         for (; p < end; p++) {
583             switch (*p) {
584             case '\r':
585                 if (name.isEmpty()) {
586                     if (p + 1 < end && *(p + 1) == '\n')
587                         return p + 2;
588                     m_failureReason = "CR doesn't follow LF at " + trimConsoleMessage(p, end - p);
589                     return 0;
590                 }
591                 m_failureReason = "Unexpected CR in name at " + trimConsoleMessage(name.data(), name.size());
592                 return 0;
593             case '\n':
594                 m_failureReason = "Unexpected LF in name at " + trimConsoleMessage(name.data(), name.size());
595                 return 0;
596             case ':':
597                 break;
598             default:
599                 name.append(*p);
600                 continue;
601             }
602             if (*p == ':') {
603                 ++p;
604                 break;
605             }
606         }
607
608         for (; p < end && *p == 0x20; p++) { }
609
610         for (; p < end; p++) {
611             switch (*p) {
612             case '\r':
613                 break;
614             case '\n':
615                 m_failureReason = "Unexpected LF in value at " + trimConsoleMessage(value.data(), value.size());
616                 return 0;
617             default:
618                 value.append(*p);
619             }
620             if (*p == '\r') {
621                 ++p;
622                 break;
623             }
624         }
625         if (p >= end || *p != '\n') {
626             m_failureReason = "CR doesn't follow LF after value at " + trimConsoleMessage(p, end - p);
627             return 0;
628         }
629         AtomicString nameStr = AtomicString::fromUTF8(name.data(), name.size());
630         String valueStr = String::fromUTF8(value.data(), value.size());
631         if (nameStr.isNull()) {
632             m_failureReason = "Invalid UTF-8 sequence in header name";
633             return 0;
634         }
635         if (valueStr.isNull()) {
636             m_failureReason = "Invalid UTF-8 sequence in header value";
637             return 0;
638         }
639         LOG(Network, "name=%s value=%s", nameStr.string().utf8().data(), valueStr.utf8().data());
640         // Sec-WebSocket-Extensions may be split. We parse and check the
641         // header value every time the header appears.
642         if (equalIgnoringCase("sec-websocket-extensions", nameStr)) {
643             if (!m_extensionDispatcher.processHeaderValue(valueStr)) {
644                 m_failureReason = m_extensionDispatcher.failureReason();
645                 return 0;
646             }
647         } else
648             m_response.addHeaderField(nameStr, valueStr);
649     }
650     ASSERT_NOT_REACHED();
651     return 0;
652 }
653
654 bool WebSocketHandshake::checkResponseHeaders()
655 {
656     const String& serverWebSocketLocation = this->serverWebSocketLocation();
657     const String& serverWebSocketOrigin = this->serverWebSocketOrigin();
658     const String& serverWebSocketProtocol = this->serverWebSocketProtocol();
659     const String& serverUpgrade = this->serverUpgrade();
660     const String& serverConnection = this->serverConnection();
661     const String& serverWebSocketAccept = this->serverWebSocketAccept();
662
663     if (serverUpgrade.isNull()) {
664         m_failureReason = "Error during WebSocket handshake: 'Upgrade' header is missing";
665         return false;
666     }
667     if (serverConnection.isNull()) {
668         m_failureReason = "Error during WebSocket handshake: 'Connection' header is missing";
669         return false;
670     }
671     if (m_useHixie76Protocol) {
672         if (serverWebSocketOrigin.isNull()) {
673             m_failureReason = "Error during WebSocket handshake: 'Sec-WebSocket-Origin' header is missing";
674             return false;
675         }
676         if (serverWebSocketLocation.isNull()) {
677             m_failureReason = "Error during WebSocket handshake: 'Sec-WebSocket-Location' header is missing";
678             return false;
679         }
680     } else {
681         if (serverWebSocketAccept.isNull()) {
682             m_failureReason = "Error during WebSocket handshake: 'Sec-WebSocket-Accept' header is missing";
683             return false;
684         }
685     }
686
687     if (!equalIgnoringCase(serverUpgrade, "websocket")) {
688         m_failureReason = "Error during WebSocket handshake: 'Upgrade' header value is not 'WebSocket'";
689         return false;
690     }
691     if (!equalIgnoringCase(serverConnection, "upgrade")) {
692         m_failureReason = "Error during WebSocket handshake: 'Connection' header value is not 'Upgrade'";
693         return false;
694     }
695
696     if (m_useHixie76Protocol) {
697         if (clientOrigin() != serverWebSocketOrigin) {
698             m_failureReason = "Error during WebSocket handshake: origin mismatch: " + clientOrigin() + " != " + serverWebSocketOrigin;
699             return false;
700         }
701         if (clientLocation() != serverWebSocketLocation) {
702             m_failureReason = "Error during WebSocket handshake: location mismatch: " + clientLocation() + " != " + serverWebSocketLocation;
703             return false;
704         }
705         if (!m_clientProtocol.isEmpty() && m_clientProtocol != serverWebSocketProtocol) {
706             m_failureReason = "Error during WebSocket handshake: protocol mismatch: " + m_clientProtocol + " != " + serverWebSocketProtocol;
707             return false;
708         }
709     } else {
710         if (serverWebSocketAccept != m_expectedAccept) {
711             m_failureReason = "Error during WebSocket handshake: Sec-WebSocket-Accept mismatch";
712             return false;
713         }
714     }
715     return true;
716 }
717
718 } // namespace WebCore
719
720 #endif // ENABLE(WEB_SOCKETS)