Handle non-HTTP/1.1 requests more gracefully in net::HttpServer.

net/server/http_server.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/server/http_server.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 212 matching lines @@
         return ERR_CONNECTION_CLOSED;
       }
       delegate_->OnWebSocketMessage(connection->id(), message);
       if (HasClosedConnection(connection))
         return ERR_CONNECTION_CLOSED;
       continue;
     }
 
     HttpServerRequestInfo request;
     size_t pos = 0;
-    if (!ParseHeaders(read_buf->StartOfBuffer(), read_buf->GetSize(),
-                      &request, &pos)) {
+    if (!ParseHeaders(connection->id(), read_buf->StartOfBuffer(),
+                      read_buf->GetSize(), &request, &pos)) {
+      // Check if a parsing error has caused the connection to close.
+      if (HasClosedConnection(connection))
+        return ERR_CONNECTION_CLOSED;
       break;
     }
 
     // Sets peer address if exists.
     connection->socket()->GetPeerAddress(&request.peer);
 
     if (request.HasHeaderValue("connection", "upgrade")) {
       connection->SetWebSocket(
           base::WrapUnique(new WebSocket(this, connection)));
       read_buf->DidConsume(pos);
@@ skipping 126 matching lines @@
     case '\n':
       return INPUT_LF;
     case ':':
       return INPUT_COLON;
   }
   return INPUT_DEFAULT;
 }
 
 }  // namespace
 
-bool HttpServer::ParseHeaders(const char* data,
+bool HttpServer::ParseHeaders(int connection_id,
+                              const char* data,
                               size_t data_len,
                               HttpServerRequestInfo* info,
                               size_t* ppos) {
   size_t& pos = *ppos;
   int state = ST_METHOD;
   std::string buffer;
   std::string header_name;
   std::string header_value;
   while (pos < data_len) {
     char ch = data[pos++];
     int input = charToInput(ch);
     int next_state = parser_state[state][input];
 
     bool transition = (next_state != state);
     HttpServerRequestInfo::HeadersMap::iterator it;
     if (transition) {
       // Do any actions based on state transitions.
       switch (state) {
         case ST_METHOD:
           info->method = buffer;
           buffer.clear();
           break;
         case ST_URL:
           info->path = buffer;
           buffer.clear();
           break;
         case ST_PROTO:
-          // TODO(mbelshe): Deal better with parsing protocol.
-          DCHECK(buffer == "HTTP/1.1");
+          if (buffer != "HTTP/1.1") {
+            LOG(ERROR) << "Ignoring request with protocol: " << buffer;
+            next_state = ST_ERR;
+          }
           buffer.clear();
           break;
         case ST_NAME:
           header_name = base::ToLowerASCII(buffer);
           buffer.clear();
           break;
         case ST_VALUE:
           base::TrimWhitespaceASCII(buffer, base::TRIM_LEADING, &header_value);
           it = info->headers.find(header_name);
           // See the second paragraph ("A sender MUST NOT generate multiple
@@ skipping 17 matching lines @@
         case ST_URL:
         case ST_PROTO:
         case ST_VALUE:
         case ST_NAME:
           buffer.append(&ch, 1);
           break;
         case ST_DONE:
           DCHECK(input == INPUT_LF);
           return true;
         case ST_ERR:
+          Close(connection_id);
           return false;
       }
     }
   }
   // No more characters, but we haven't finished parsing yet.
   return false;
 }
 
 HttpConnection* HttpServer::FindConnection(int connection_id) {
   IdToConnectionMap::iterator it = id_to_connection_.find(connection_id);
   if (it == id_to_connection_.end())
     return NULL;
   return it->second;
 }
 
 // This is called after any delegate callbacks are called to check if Close()
 // has been called during callback processing. Using the pointer of connection,
 // |connection| is safe here because Close() deletes the connection in next run
 // loop.
 bool HttpServer::HasClosedConnection(HttpConnection* connection) {
   return FindConnection(connection->id()) != connection;
 }
 
 }  // namespace net