WebSocket over SPDY: handshake support for both of SPDY/2 and SPDY/3

net/websockets/websocket_handshake_handler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/websockets/websocket_handshake_handler.h"
 
 #include "base/base64.h"
 #include "base/md5.h"
 #include "base/sha1.h"
 #include "base/string_number_conversions.h"
@@ skipping 248 matching lines @@
     request_info.extra_headers.RemoveHeader("Sec-WebSocket-Key2");
     GetKeyNumber(key, challenge);
 
     challenge->append(key3_);
   }
 
   return request_info;
 }
 
 bool WebSocketHandshakeRequestHandler::GetRequestHeaderBlock(
-    const GURL& url, SpdyHeaderBlock* headers, std::string* challenge) {
+    const GURL& url,
+    SpdyHeaderBlock* headers,
+    std::string* challenge,
+    int spdy_protocol_version) {
   // Construct opening handshake request headers as a SPDY header block.
   // For details, see WebSocket Layering over SPDY/3 Draft 8.
-  (*headers)["path"] = url.path();
-  (*headers)["version"] =
+  if (spdy_protocol_version <= 2) {
+    (*headers)["path"] = url.path();
+    (*headers)["version"] =
       base::StringPrintf("%s%d", "WebSocket/", protocol_version_);
-  (*headers)["scheme"] = url.scheme();
+    (*headers)["scheme"] = url.scheme();
+  } else {
+    (*headers)[":path"] = url.path();
+    (*headers)[":version"] =
+      base::StringPrintf("%s%d", "WebSocket/", protocol_version_);
+    (*headers)[":scheme"] = url.scheme();
+  }
 
   HttpUtil::HeadersIterator iter(headers_.begin(), headers_.end(), "\r\n");
   while (iter.GetNext()) {
     if (LowerCaseEqualsASCII(iter.name_begin(), iter.name_end(), "upgrade") ||
         LowerCaseEqualsASCII(iter.name_begin(),
                              iter.name_end(),
                              "connection") ||
         LowerCaseEqualsASCII(iter.name_begin(),
                              iter.name_end(),
                              "sec-websocket-version")) {
       // These headers must be ignored.
       continue;
     } else if (LowerCaseEqualsASCII(iter.name_begin(),
                                     iter.name_end(),
                                     "sec-websocket-key")) {
       *challenge = iter.values();
       // Sec-WebSocket-Key is not sent to a server.
       continue;
+    } else if (LowerCaseEqualsASCII(iter.name_begin(),
+                                    iter.name_end(),
+                                    "host") ||
+               LowerCaseEqualsASCII(iter.name_begin(),
+                                    iter.name_end(),
+                                    "origin") ||
+               LowerCaseEqualsASCII(iter.name_begin(),
+                                    iter.name_end(),
+                                    "sec-websocket-protocol") ||
+               LowerCaseEqualsASCII(iter.name_begin(),
+                                    iter.name_end(),
+                                    "sec-websocket-extensions")) {
+      // TODO(toyoshim): Some WebSocket extensions may not be compatible with
+      // SPDY. We should omit them from a Sec-WebSocket-Extension header.
+      std::string name;
+      if (spdy_protocol_version <= 2)
+        name = StringToLowerASCII(iter.name());
+      else
+        name = ":" + StringToLowerASCII(iter.name());
+      (*headers)[name] = iter.values();
+      continue;
     }
     // Others should be sent out to |headers|.
-    // TODO(toyoshim): Some WebSocket extensions are not compatible with SPDY.
-    // We should remove them from a Sec-WebSocket-Extension header.
     std::string name = StringToLowerASCII(iter.name());
     SpdyHeaderBlock::iterator found = headers->find(name);
     if (found == headers->end()) {
       (*headers)[name] = iter.values();
     } else {
       // For now, websocket doesn't use multiple headers, but follows to http.
       found->second.append(1, '\0');  // +=() doesn't append 0's
       found->second.append(iter.values());
     }
   }
@@ skipping 112 matching lines @@
     const char* digest_data = reinterpret_cast<char*>(digest.a);
     response_message.append(digest_data, sizeof(digest.a));
   }
 
   return ParseRawResponse(response_message.data(),
                           response_message.size()) == response_message.size();
 }
 
 bool WebSocketHandshakeResponseHandler::ParseResponseHeaderBlock(
     const SpdyHeaderBlock& headers,
-    const std::string& challenge) {
-  std::string response_message;
-  SpdyHeaderBlock::const_iterator status = headers.find("status");
+    const std::string& challenge,
+    int spdy_protocol_version) {
+  SpdyHeaderBlock::const_iterator status;
+  if (spdy_protocol_version <= 2)
+    status = headers.find("status");
+  else
+    status = headers.find(":status");
   if (status == headers.end())
     return false;
+  std::string response_message;
   response_message =
       base::StringPrintf("%s%s\r\n", "HTTP/1.1 ", status->second.c_str());
   response_message += "Upgrade: websocket\r\n";
   response_message += "Connection: Upgrade\r\n";
 
   std::string hash = base::SHA1HashString(challenge + kWebSocketGuid);
   std::string websocket_accept;
   bool encode_success = base::Base64Encode(hash, &websocket_accept);
   DCHECK(encode_success);
   response_message += "Sec-WebSocket-Accept: " + websocket_accept + "\r\n";
 
   for (SpdyHeaderBlock::const_iterator iter = headers.begin();
        iter != headers.end();
        ++iter) {
     // For each value, if the server sends a NUL-separated list of values,
     // we separate that back out into individual headers for each value
     // in the list.
-    if (LowerCaseEqualsASCII(iter->first, "status")) {
+    if ((spdy_protocol_version <= 2 &&
+         LowerCaseEqualsASCII(iter->first, "status")) ||
+        (spdy_protocol_version >= 3 &&
+         LowerCaseEqualsASCII(iter->first, ":status"))) {
       // The status value is already handled as the first line of
       // |response_message|. Just skip here.
       continue;
     }
     const std::string& value = iter->second;
     size_t start = 0;
     size_t end = 0;
     do {
       end = value.find('\0', start);
       std::string tval;
       if (end != std::string::npos)
         tval = value.substr(start, (end - start));
       else
         tval = value.substr(start);
-      response_message += iter->first + ": " + tval + "\r\n";
+      if (spdy_protocol_version >= 3 &&
+          (LowerCaseEqualsASCII(iter->first, ":sec-websocket-protocol") ||
+           LowerCaseEqualsASCII(iter->first, ":sec-websocket-extensions")))
+        response_message += iter->first.substr(1) + ": " + tval + "\r\n";
+      else
+        response_message += iter->first + ": " + tval + "\r\n";
       start = end + 1;
     } while (end != std::string::npos);
   }
   response_message += "\r\n";
 
   return ParseRawResponse(response_message.data(),
                           response_message.size()) == response_message.size();
 }
 
 void WebSocketHandshakeResponseHandler::GetHeaders(
@@ skipping 36 matching lines @@
   return status_line_ + headers_ + header_separator_ + key_;
 }
 
 size_t WebSocketHandshakeResponseHandler::GetResponseKeySize() const {
   if (protocol_version_ >= kMinVersionOfHybiNewHandshake)
     return 0;
   return kResponseKeySize;
 }
 
 }  // namespace net