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/rand_util.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"
 
 #if defined(OS_WIN)
 #include <winsock2.h>
 #else
 #include <arpa/inet.h>
 #endif
 
+#include <limits>
+
 namespace net {
 
 int HttpServer::Connection::lastId_ = 0;
 
 HttpServer::HttpServer(const std::string& host,
                        int port,
                        HttpServer::Delegate* del)
     : delegate_(del) {
   server_ = ListenSocket::Listen(host, port, this);
 }
@@ skipping 28 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_hybi10_web_socket_(false) {
   id_ = lastId_++;
 }
 
 HttpServer::Connection::~Connection() {
   DetachSocket();
   server_->delegate_->OnClose(id_);
 }
 
 void HttpServer::Connection::DetachSocket() {
   socket_ = NULL;
@@ skipping 167 matching lines @@
                          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;
     HttpServerRequestInfo request;
-    if (!ParseHeaders(connection, &request, &pos))
+    if (!connection->use_hybi10_web_socket_ &&
+        !ParseHeaders(connection, &request, &pos))
       break;
 
     if (connection->is_web_socket_) {
-      delegate_->OnWebSocketMessage(connection->id_, request.data);
-      connection->Shift(pos);
+      if (connection->use_hybi10_web_socket_) {
+        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);
+      } else {
+        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()) {

[pfeldman, 2011/07/28 09:32:47]

compare to "8"?

+        if (WebSocketHandshakeHyBi10(connection, 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 >
               static_cast<int>(connection->recv_data_.length())) {
         // We haven't received websocket handshake body yet. Wait.
         break;
       }
@@ skipping 29 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;
 }
 
+bool HttpServer::WebSocketHandshakeHyBi10(
+    Connection* connection,
+    const HttpServerRequestInfo& request) {
+  if (GetHeaderValue(request, "Connection") == "Upgrade" &&
+      GetHeaderValue(request, "Upgrade") == "websocket") {
+    // Is this WebSocket and if yes, upgrade the connection.
+    std::string key = GetHeaderValue(request, "Sec-WebSocket-Key");
+
+    if (!key.empty()) {
+      connection->use_hybi10_web_socket_ = true;
+      delegate_->OnWebSocketRequest(connection->id_, request);
+      return true;
+    }
+  }
+  return false;
+}
+
+void HttpServer::AcceptWebSocket(
+    int connection_id,
+    const HttpServerRequestInfo& request) {
+  Connection* connection = FindConnection(connection_id);
+  if (connection == NULL)
+    return;
+  if (connection->use_hybi10_web_socket_)
+    AcceptWebSocketHyBi10(connection, request);
+  else
+    AcceptWebSocketHixie76(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(sec_web_socket_key);

[pfeldman, 2011/07/28 09:32:47]

Use StringPrintf ?

+  data += 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"
+       "Upgrade: WebSocket\r\n"
+       "Connection: Upgrade\r\n"
+       "Sec-WebSocket-Accept: %s\r\n"
+       "\r\n",
+      GenerateWebSocketHyBi10AcceptKey(key).c_str());
+  connection->socket_->Send(response);
+}
+
+struct WebSocketFrame {

[pfeldman, 2011/07/28 09:32:47]

Declare this struct in anonymous namespace above.

+  // Hybi-10 opcodes.
+  typedef unsigned int OpCode;
+  static const OpCode kOpCodeContinuation;
+  static const OpCode kOpCodeText;
+  static const OpCode kOpCodeBinary;
+  static const OpCode kOpCodeClose;
+  static const OpCode kOpCodePing;
+  static const OpCode kOpCodePong;
+
+  static const unsigned char kFinalBit;
+  static const unsigned char kReserved1Bit;
+  static const unsigned char kReserved2Bit;
+  static const unsigned char kReserved3Bit;
+  static const unsigned char kOpCodeMask;
+  static const unsigned char kMaskBit;
+  static const unsigned char kPayloadLengthMask;
+
+  static const size_t kMaxSingleBytePayloadLength;
+  static const size_t kTwoBytePayloadLengthField;
+  static const size_t kEightBytePayloadLengthField;
+  static const size_t kMaskingKeyWidthInBytes;
+
+  enum ParseResult {
+    FrameOK,
+    FrameIncomplete,
+    FrameError
+  };
+
+  OpCode op_code_;
+  bool final_;
+  bool reserved1_;
+  bool reserved2_;
+  bool reserved3_;
+  bool masked_;
+  const char* payload_;
+  size_t payload_length_;
+  const char* frame_end_;
+
+  bool isNonControlOpCode() const {
+    return op_code_ == kOpCodeContinuation ||
+           op_code_ == kOpCodeText ||
+           op_code_ == kOpCodeBinary;
+  }
+  bool isControlOpCode() const {
+    return op_code_ == kOpCodeClose ||
+           op_code_ == kOpCodePing ||
+           op_code_ == kOpCodePong;
+  }
+  bool isReservedOpCode() const {
+    return !isNonControlOpCode() && !isControlOpCode();
+  }
+
+  ParseResult DecodeFrame(const char* data, size_t data_length);
+  std::vector<char> EncodeFrame(OpCode op_code,
+                                const char* data,
+                                size_t data_length);
+};
+
+// Constants for hybi-10 frame format.
+const WebSocketFrame::OpCode WebSocketFrame::kOpCodeContinuation = 0x0;
+const WebSocketFrame::OpCode WebSocketFrame::kOpCodeText = 0x1;
+const WebSocketFrame::OpCode WebSocketFrame::kOpCodeBinary = 0x2;
+const WebSocketFrame::OpCode WebSocketFrame::kOpCodeClose = 0x8;
+const WebSocketFrame::OpCode WebSocketFrame::kOpCodePing = 0x9;
+const WebSocketFrame::OpCode WebSocketFrame::kOpCodePong = 0xA;
+
+const unsigned char WebSocketFrame::kFinalBit = 0x80;
+const unsigned char WebSocketFrame::kReserved1Bit = 0x40;
+const unsigned char WebSocketFrame::kReserved2Bit = 0x20;
+const unsigned char WebSocketFrame::kReserved3Bit = 0x10;
+const unsigned char WebSocketFrame::kOpCodeMask = 0xF;
+const unsigned char WebSocketFrame::kMaskBit = 0x80;
+const unsigned char WebSocketFrame::kPayloadLengthMask = 0x7F;
+
+const size_t WebSocketFrame::kMaxSingleBytePayloadLength = 125;
+const size_t WebSocketFrame::kTwoBytePayloadLengthField = 126;
+const size_t WebSocketFrame::kEightBytePayloadLengthField = 127;
+const size_t WebSocketFrame::kMaskingKeyWidthInBytes = 4;
+
+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_hybi10_web_socket_)
+    SendOverWebSocketHyBi10(connection, data);
+  else
+    SendOverWebSocketHixie76(connection, data);
+}
+
+WebSocketFrame::ParseResult WebSocketFrame::DecodeFrame(
+    const char* data, size_t data_length) {
+  const char* p = data;
+  const char* buffer_end = data + data_length;
+
+  if (data_length < 2)
+    return FrameIncomplete;
+
+  unsigned char first_byte = *p++;
+  unsigned char second_byte = *p++;
+
+  final_ = first_byte & kFinalBit;
+  reserved1_ = first_byte & kReserved1Bit;
+  reserved2_ = first_byte & kReserved2Bit;
+  reserved3_ = first_byte & kReserved3Bit;
+  op_code_ = first_byte & kOpCodeMask;
+  masked_ = second_byte & kMaskBit;
+
+  uint64_t payload_length64 = second_byte & kPayloadLengthMask;
+  if (payload_length64 > kMaxSingleBytePayloadLength) {
+    int extended_payload_length_size;
+    if (payload_length64 == kTwoBytePayloadLengthField)
+      extended_payload_length_size = 2;
+    else {
+      CHECK(payload_length64 == kEightBytePayloadLengthField);
+      extended_payload_length_size = 8;
+    }
+    if (buffer_end - p < extended_payload_length_size)
+      return FrameIncomplete;
+    payload_length64 = 0;
+    for (int i = 0; i < extended_payload_length_size; ++i) {
+      payload_length64 <<= 8;
+      payload_length64 |= static_cast<unsigned char>(*p++);
+    }
+  }
+
+  static const uint64_t max_payload_ength = 0x7FFFFFFFFFFFFFFFull;
+  size_t masking_key_length = masked_ ? kMaskingKeyWidthInBytes : 0;
+  static size_t max_length = std::numeric_limits<size_t>::max();
+  if (payload_length64 > max_payload_ength ||
+      payload_length64 + masking_key_length > max_length) {
+    // WebSocket frame length too large.
+    return FrameError;
+  }
+  payload_length_ = static_cast<size_t>(payload_length64);
+
+  size_t total_length = masking_key_length + payload_length_;
+  if (static_cast<size_t>(buffer_end - p) < total_length)
+    return FrameIncomplete;
+
+  if (masked_) {
+    const char* masking_key = p;
+    char* payload = const_cast<char*>(p + kMaskingKeyWidthInBytes);
+    for (size_t i = 0; i < payload_length_; ++i) // Unmask the payload.
+      payload[i] ^= masking_key[i % kMaskingKeyWidthInBytes];
+  }
+
+  payload_ = p + masking_key_length;
+  frame_end_ = p + masking_key_length + payload_length_;
+  return FrameOK;
+}
+
+std::vector<char> WebSocketFrame::EncodeFrame(
+    OpCode op_code, const char* data, size_t data_length) {
+  std::vector<char> frame;
+
+  // Checks whether "op_code" fits in the range of opCodes.
+  CHECK(!(op_code & ~kOpCodeMask));

[pfeldman, 2011/07/28 09:32:47]

DCHECK 

+  frame.push_back(kFinalBit | op_code);
+  if (data_length <= kMaxSingleBytePayloadLength)
+    frame.push_back(kMaskBit | data_length);
+  else if (data_length <= 0xFFFF) {
+    frame.push_back(kMaskBit | kTwoBytePayloadLengthField);
+    frame.push_back((data_length & 0xFF00) >> 8);
+    frame.push_back(data_length & 0xFF);
+  } else {
+    frame.push_back(kMaskBit | kEightBytePayloadLengthField);
+    char extended_payload_length[8];
+    size_t remaining = data_length;
+    // Fill the length into extended_payload_length in the network byte order.
+    for (int i = 0; i < 8; ++i) {
+      extended_payload_length[7 - i] = remaining & 0xFF;
+      remaining >>= 8;
+    }
+    frame.insert(frame.end(),
+                 extended_payload_length,
+                 extended_payload_length + 8);
+    CHECK(!remaining);
+  }
+
+  // Mask the frame.
+  size_t masking_key_start = frame.size();
+  // Add placeholder for masking key. Will be overwritten.
+  frame.resize(frame.size() + kMaskingKeyWidthInBytes);
+  size_t payload_start = frame.size();
+  frame.insert(frame.end(), data, data + data_length);
+
+  base::RandBytes(frame.data() + masking_key_start,
+                  kMaskingKeyWidthInBytes);
+  for (size_t i = 0; i < data_length; ++i)

[pfeldman, 2011/07/28 09:32:47]

Use  {} since more than one line.

+    frame[payload_start + i] ^=
+        frame[masking_key_start + i % kMaskingKeyWidthInBytes];
+
+  return frame;
+}
+
+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,
+                                               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