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,
+    NextProto protocol_negotiated) {
   // 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 (protocol_negotiated == kProtoSPDY2) {

[Yuta Kitamura, 2012/08/03 07:31:51]

Can we assume |protocol_negotiated| is either kProtoSPDY2 or kProtoSPDY3? Or it
may take other values like kProtoUnknown, kProtoHTTP11 or kProtoSPDY1?

[Takashi Toyoshima, 2012/08/06 13:01:53]

Good point.
It doesn't seem to be kProtoHTTP11 or kProtoSPDY1 because these negotiation
never create right spdy session for WebSocket. But, kProtoUnknown can be.

SpdySession want to use g_default_protocol for kProtoUnknown to initiate a new
session. I guess this default value is kProtoSPDY2, or kProtoSPDY3 if it is
enabled. So using this value looks right way. I'll fix this change to hold this
initiating protocol version, and query it from WebSocketJob to SpdySession.

ps. SpdySession::GetProtocolVersion looks right function to know the actually
used protocol version.

+    (*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 be not not compatible

[Yuta Kitamura, 2012/08/03 07:31:51]

"may be not not" -> "may not be"

[Takashi Toyoshima, 2012/08/06 13:01:53]

Thanks.

+      // with SPDY. We should omit them from a Sec-WebSocket-Extension header.
+      std::string name;
+      if (protocol_negotiated == kProtoSPDY2)
+        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,
+    NextProto protocol_negotiated) {
+  SpdyHeaderBlock::const_iterator status;
+  if (protocol_negotiated == kProtoSPDY2)
+    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 ((protocol_negotiated == kProtoSPDY2 &&
+        LowerCaseEqualsASCII(iter->first, "status")) ||

[Yuta Kitamura, 2012/08/03 07:31:51]

nit: This line needs to align the opening paren, i.e.:

  if ((foo &&
       bar) ||
      baz) {
  }

[Takashi Toyoshima, 2012/08/06 13:01:53]

Done.

+        (protocol_negotiated != kProtoSPDY2 &&
+        LowerCaseEqualsASCII(iter->first, ":status"))) {

[Yuta Kitamura, 2012/08/03 07:31:51]

Ditto.

[Takashi Toyoshima, 2012/08/06 13:01:53]

Done.

       // 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 (protocol_negotiated != kProtoSPDY2 &&
+          (LowerCaseEqualsASCII(iter->first, ":sec-websocket-protocol") ||
+          LowerCaseEqualsASCII(iter->first, ":sec-websocket-extensions")))

[Yuta Kitamura, 2012/08/03 07:31:51]

Ditto.

[Takashi Toyoshima, 2012/08/06 13:01:53]

Done.

+        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