DevTools: no way to remote debug using ToT build.

net/server/http_server.cc

 // Copyright (c) 2011 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/server/http_server.h"
 
+#include "base/base64.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/md5.h"
+#include "base/sha1.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "build/build_config.h"
 #include "net/server/http_server_request_info.h"
+#include "net/server/web_socket_frame.h"
 
 #if defined(OS_WIN)
 #include <winsock2.h>
 #else
 #include <arpa/inet.h>
 #endif
 
 namespace net {
 
 int HttpServer::Connection::lastId_ = 0;
@@ skipping 35 matching lines @@
       spaces++;
   }
   if (spaces == 0)
     return 0;
   int64 number = 0;
   if (!base::StringToInt64(result, &number))
     return 0;
   return htonl(static_cast<uint32>(number / spaces));
 }
 
-void HttpServer::AcceptWebSocket(
-    int connection_id,
+void HttpServer::AcceptWebSocketHixie76(
+    HttpServer::Connection* connection,
     const HttpServerRequestInfo& request) {
-  Connection* connection = FindConnection(connection_id);
-  if (connection == NULL)
-    return;
-
   std::string key1 = GetHeaderValue(request, "Sec-WebSocket-Key1");
   std::string key2 = GetHeaderValue(request, "Sec-WebSocket-Key2");
 
   uint32 fp1 = WebSocketKeyFingerprint(key1);
   uint32 fp2 = WebSocketKeyFingerprint(key2);
 
   char data[16];
   memcpy(data, &fp1, 4);
   memcpy(data + 4, &fp2, 4);
   memcpy(data + 8, &request.data[0], 8);
@@ skipping 10 matching lines @@
       "Upgrade: WebSocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Origin: %s\r\n"
       "Sec-WebSocket-Location: %s\r\n"
       "\r\n",
       origin.c_str(),
       location.c_str()));
   connection->socket_->Send(reinterpret_cast<char*>(digest.a), 16);
 }
 
-void HttpServer::SendOverWebSocket(int connection_id,
-                                   const std::string& data) {
-  Connection* connection = FindConnection(connection_id);
-  if (connection == NULL)
-    return;
-
-  DCHECK(connection->is_web_socket_);
+void HttpServer::SendOverWebSocketHixie76(HttpServer::Connection* connection,
+                                          const std::string& data) {
   char message_start = 0;
   char message_end = -1;
   connection->socket_->Send(&message_start, 1);
   connection->socket_->Send(data);
   connection->socket_->Send(&message_end, 1);
 }
 
 void HttpServer::Send(int connection_id, const std::string& data) {
   Connection* connection = FindConnection(connection_id);
   if (connection == NULL)
@@ skipping 58 matching lines @@
   Connection* connection = FindConnection(connection_id);
   if (connection == NULL)
     return;
 
   connection->DetachSocket();
 }
 
 HttpServer::Connection::Connection(HttpServer* server, ListenSocket* sock)
     : server_(server),
       socket_(sock),
-      is_web_socket_(false) {
+      is_web_socket_(false),
+      use_hixie76_web_socket_(false) {
   id_ = lastId_++;
 }
 
 HttpServer::Connection::~Connection() {
   DetachSocket();
   server_->delegate_->OnClose(id_);
 }
 
 void HttpServer::Connection::DetachSocket() {
   socket_ = NULL;
@@ skipping 166 matching lines @@
                          const char* data,
                          int len) {
   Connection* connection = FindConnection(socket);
   DCHECK(connection != NULL);
   if (connection == NULL)
     return;
 
   connection->recv_data_.append(data, len);
   while (connection->recv_data_.length()) {
     int pos = 0;
+    if (connection->is_web_socket_) {
+      if (connection->use_hixie76_web_socket_) {
+        HttpServerRequestInfo request;
+        if (!ParseHeaders(connection, &request, &pos))

[pfeldman, 2011/07/28 14:54:18]

Please add FIXME suggesting that hixie76 frames are parsed outside the
ParseHeaders routine.

+          break;
+        delegate_->OnWebSocketMessage(connection->id_, request.data);
+        connection->Shift(pos);
+      } else {
+        std::string message;
+        if (!DidReadWebSocketHyBi10(
+                 connection,
+                 (char*)(connection->recv_data_.c_str() + pos),
+                 connection->recv_data_.length() - pos,
+                 &message))
+          break;
+        delegate_->OnWebSocketMessage(connection->id_, message);
+      }
+      continue;
+    }
+
     HttpServerRequestInfo request;
     if (!ParseHeaders(connection, &request, &pos))
       break;
 
-    if (connection->is_web_socket_) {
-      delegate_->OnWebSocketMessage(connection->id_, request.data);
-      connection->Shift(pos);
-      continue;
-    }
-
     std::string connection_header = GetHeaderValue(request, "Connection");
     if (connection_header == "Upgrade") {
+      std::string version = GetHeaderValue(request, "Sec-WebSocket-Version");
+      if (version.length() && version == "8") {
+        std::string key = GetHeaderValue(request, "Sec-WebSocket-Key");
+        if (key.empty()) {
+          Send500(connection->id_,
+            "Invalid request format. "
+            "Sec-WebSocket-Key is empty or isn't specified.");
+          connection->Shift(pos);
+          break;
+        }
+
+        delegate_->OnWebSocketRequest(connection->id_, request);
+        connection->Shift(pos);
+        continue;
+      }
+
       // Is this WebSocket and if yes, upgrade the connection.
       std::string key1 = GetHeaderValue(request, "Sec-WebSocket-Key1");
       std::string key2 = GetHeaderValue(request, "Sec-WebSocket-Key2");
 
-      const int websocket_handshake_body_len = 8;
-      if (pos + websocket_handshake_body_len >
+      const int web_socket_handshake_body_len = 8;
+      if (pos + web_socket_handshake_body_len >
               static_cast<int>(connection->recv_data_.length())) {
         // We haven't received websocket handshake body yet. Wait.
         break;
       }
 
       if (!key1.empty() && !key2.empty()) {
         request.data = connection->recv_data_.substr(
             pos,
-            pos + websocket_handshake_body_len);
-        pos += websocket_handshake_body_len;
+            pos + web_socket_handshake_body_len);
+        pos += web_socket_handshake_body_len;
+        connection->use_hixie76_web_socket_ = true;
         delegate_->OnWebSocketRequest(connection->id_, request);
         connection->Shift(pos);
         continue;
       }
     }
     // Request body is not supported. It is always empty.
     delegate_->OnHttpRequest(connection->id_, request);
     connection->Shift(pos);
   }
 }
@@ skipping 13 matching lines @@
   return it->second;
 }
 
 HttpServer::Connection* HttpServer::FindConnection(ListenSocket* socket) {
   SocketToConnectionMap::iterator it = socket_to_connection_.find(socket);
   if (it == socket_to_connection_.end())
     return NULL;
   return it->second;
 }
 
+void HttpServer::AcceptWebSocket(
+    int connection_id,
+    const HttpServerRequestInfo& request) {
+  Connection* connection = FindConnection(connection_id);
+  if (connection == NULL)
+    return;
+  if (connection->use_hixie76_web_socket_)
+    AcceptWebSocketHixie76(connection, request);
+  else
+    AcceptWebSocketHyBi10(connection, request);
+}
+
+static std::string GenerateWebSocketHyBi10AcceptKey(
+   const std::string& sec_web_socket_key)
+{
+  static const char* const web_socket_key_GUID =
+      "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+  std::string data = base::StringPrintf("%s%s",
+                                        sec_web_socket_key.c_str(),
+                                        web_socket_key_GUID);
+  std::string encoded_hash;
+  base::Base64Encode(base::SHA1HashString(data), &encoded_hash);
+  return encoded_hash;
+}
+
+void HttpServer::AcceptWebSocketHyBi10(
+    HttpServer::Connection* connection,
+    const HttpServerRequestInfo& request) {
+  std::string key = GetHeaderValue(request, "Sec-WebSocket-Key");
+  connection->is_web_socket_ = true;
+
+  std::string response = base::StringPrintf(
+       "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"

[pfeldman, 2011/07/28 14:54:18]

wrong indent

+       "Upgrade: WebSocket\r\n"
+       "Connection: Upgrade\r\n"
+       "Sec-WebSocket-Accept: %s\r\n"
+       "\r\n",
+      GenerateWebSocketHyBi10AcceptKey(key).c_str());
+  connection->socket_->Send(response);
+}
+
+void HttpServer::SendOverWebSocket(int connection_id,
+                                   const std::string& data) {
+  Connection* connection = FindConnection(connection_id);
+  if (connection == NULL)
+    return;
+  DCHECK(connection->is_web_socket_);
+  if (connection->use_hixie76_web_socket_)

[pfeldman, 2011/07/28 14:54:18]

Having two web socket implementations with the same interface would simplify
understanding significantly.

+    SendOverWebSocketHixie76(connection, data);
+  else
+    SendOverWebSocketHyBi10(connection, data);
+}
+
+void HttpServer::SendOverWebSocketHyBi10(HttpServer::Connection* connection,
+                                         const std::string& data) {
+  WebSocketFrame frame;
+  std::vector<char> buffer = frame.EncodeFrame(WebSocketFrame::kOpCodeText,
+                                               data.c_str(), data.length());
+  connection->socket_->Send(&buffer[0], buffer.size());
+}
+
+bool HttpServer::DidReadWebSocketHyBi10(HttpServer::Connection* connection,
+                                               char* data,

[pfeldman, 2011/07/28 14:54:18]

poor indentation.

+                                               size_t length,
+                                               std::string* message) {
+  WebSocketFrame frame;
+  WebSocketFrame::ParseResult parse_result = frame.DecodeFrame(data, length);
+  if (parse_result == WebSocketFrame::FrameError)
+    return false;
+
+  if (parse_result == WebSocketFrame::FrameIncomplete)
+    return false;
+
+  CHECK(parse_result == WebSocketFrame::FrameOK);
+  *message = std::string(frame.payload_, frame.payload_length_);
+  connection->Shift(frame.frame_end_ - data);
+
+  return true;
+}
+
 }  // namespace net