DevTools: implement basic handshake for remote debugging.

net/server/http_listen_socket.cc

 // Copyright (c) 2010 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.
 
 #ifdef _WIN32
 #include <winsock2.h>
 #else
 #include <arpa/inet.h>
 #endif
 
@@ skipping 40 matching lines @@
     // TODO (ibrar): error handling
   } else {
     HttpListenSocket *serv = new HttpListenSocket(s, delegate);
     serv->Listen();
     return serv;
   }
   return NULL;
 }
 
 std::string GetHeaderValue(
-    HttpServerRequestInfo* request,
+    const HttpServerRequestInfo& request,
     const std::string& header_name) {
   HttpServerRequestInfo::HeadersMap::iterator it =
-      request->headers.find(header_name);
-  if (it != request->headers.end())
+      request.headers.find(header_name);
+  if (it != request.headers.end())
     return it->second;
   return "";
 }
 
 uint32 WebSocketKeyFingerprint(const std::string& str) {
   std::string result;
   const char* pChar = str.c_str();
   int length = str.length();
   int spaces = 0;
   for (int i = 0; i < length; ++i) {
     if (pChar[i] >= '0' && pChar[i] <= '9')
       result.append(&pChar[i], 1);
     else if (pChar[i] == ' ')
       spaces++;
   }
   if (spaces == 0)
     return 0;
   int64 number = 0;
   if (!StringToInt64(result, &number))
     return 0;
   return htonl(static_cast<uint32>(number / spaces));
 }
 
-void HttpListenSocket::AcceptWebSocket(HttpServerRequestInfo* request) {
+void HttpListenSocket::AcceptWebSocket(const HttpServerRequestInfo& request) {
   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);
+  memcpy(data + 8, &request.data[0], 8);
 
   MD5Digest digest;
   MD5Sum(data, 16, &digest);
 
   std::string origin = GetHeaderValue(request, "Origin");
   std::string host = GetHeaderValue(request, "Host");
-  std::string location = "ws://" + host + request->path;
+  std::string location = "ws://" + host + request.path;
   is_web_socket_ = true;
   Send(StringPrintf("HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
                     "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()));
   Send(reinterpret_cast<char*>(digest.a), 16);
 }
 
 void HttpListenSocket::SendOverWebSocket(const std::string& data) {
   DCHECK(is_web_socket_);
   char message_start = 0;
   char message_end = -1;
   Send(&message_start, 1);
   Send(data);
   Send(&message_end, 1);
 }
 
+void HttpListenSocket::Send200(const std::string& data,
+                               const std::string& content_type) {
+  Send(StringPrintf("HTTP/1.1 200 OK\r\n"
+                    "Content-Type:%s\r\n"
+                    "Content-Length:%d\r\n"
+                    "\r\n",
+                    content_type.c_str(),
+                    data.length()));
+  Send(data);
+}
+
+void HttpListenSocket::Send404() {
+  Send("HTTP/1.1 404 Not Found\r\n"
+       "Content-Length: 0\r\n"
+       "\r\n");
+}
+
+void HttpListenSocket::Send500(const std::string& message) {
+  Send(StringPrintf("HTTP/1.1 500 Internal Error\r\n"
+                    "Content-Type:text/html\r\n"
+                    "Content-Length:%d\r\n"
+                    "\r\n"
+                    "%s",
+                    message.length(),
+                    message.c_str()));
+}
+
 //
 // HTTP Request Parser
 // This HTTP request parser uses a simple state machine to quickly parse
 // through the headers.  The parser is not 100% complete, as it is designed
 // for use in this simple test driver.
 //
 // Known issues:
 //   - does not handle whitespace on first HTTP line correctly.  Expects
 //     a single space between the method/url and url/protocol.
 
@@ skipping 54 matching lines @@
     case ':':
       return INPUT_COLON;
     case 0x0:
       return INPUT_00;
     case static_cast<char>(-1):
       return INPUT_FF;
   }
   return INPUT_DEFAULT;
 }
 
-HttpServerRequestInfo* HttpListenSocket::ParseHeaders() {
+bool HttpListenSocket::ParseHeaders(HttpServerRequestInfo* info) {
   int pos = 0;
   int data_len = recv_data_.length();
   int state = is_web_socket_ ? ST_WS_READY : ST_METHOD;
-  scoped_ptr<HttpServerRequestInfo> info(new HttpServerRequestInfo());
   std::string buffer;
   std::string header_name;
   std::string header_value;
   while (pos < data_len) {
     char ch = recv_data_[pos++];
     int input = charToInput(ch);
     int next_state = parser_state[state][input];
 
     bool transition = (next_state != state);
     if (transition) {
@@ skipping 23 matching lines @@
           info->headers[header_name] = header_value;
           buffer.clear();
           break;
         case ST_SEPARATOR:
           buffer.append(&ch, 1);
           break;
         case ST_WS_FRAME:
           recv_data_ = recv_data_.substr(pos);
           info->data = buffer;
           buffer.clear();
-          return info.release();
+          return true;
           break;
       }
       state = next_state;
     } else {
       // Do any actions based on current state
       switch (state) {
         case ST_METHOD:
         case ST_URL:
         case ST_PROTO:
         case ST_VALUE:
         case ST_NAME:
         case ST_WS_FRAME:
           buffer.append(&ch, 1);
           break;
         case ST_DONE:
           recv_data_ = recv_data_.substr(pos);
           info->data = recv_data_;
           recv_data_.clear();
-          return info.release();
+          return true;
         case ST_WS_CLOSE:
           is_web_socket_ = false;
-          return NULL;
+          return false;
         case ST_ERR:
-          return NULL;
+          return false;
       }
     }
   }
   // No more characters, but we haven't finished parsing yet.
-  return NULL;
+  return false;
 }
 
 void HttpListenSocket::DidAccept(ListenSocket* server,
                                  ListenSocket* connection) {
   connection->AddRef();
 }
 
 void HttpListenSocket::DidRead(ListenSocket*,
                                const char* data,
                                int len) {
   recv_data_.append(data, len);
   while (recv_data_.length()) {
-    scoped_ptr<HttpServerRequestInfo> request(ParseHeaders());
-    if (!request.get())
+    HttpServerRequestInfo request;
+    if (!ParseHeaders(&request))
       break;
 
     if (is_web_socket_) {
-      delegate_->OnWebSocketMessage(this, request->data);
+      delegate_->OnWebSocketMessage(this, request.data);
       continue;
     }
 
-    std::string connection = GetHeaderValue(request.get(), "Connection");
+    std::string connection = GetHeaderValue(request, "Connection");
     if (connection == "Upgrade") {
       // Is this WebSocket and if yes, upgrade the connection.
-      std::string key1 = GetHeaderValue(request.get(), "Sec-WebSocket-Key1");
-      std::string key2 = GetHeaderValue(request.get(), "Sec-WebSocket-Key2");
+      std::string key1 = GetHeaderValue(request, "Sec-WebSocket-Key1");
+      std::string key2 = GetHeaderValue(request, "Sec-WebSocket-Key2");
       if (!key1.empty() && !key2.empty()) {
-        delegate_->OnWebSocketRequest(this, request.get());
+        delegate_->OnWebSocketRequest(this, request);
         continue;
       }
     }
-    delegate_->OnHttpRequest(this, request.get());
+    delegate_->OnHttpRequest(this, request);
   }
 }
 
 void HttpListenSocket::DidClose(ListenSocket* sock) {
   sock->Release();
   delegate_->OnClose(this);
 }