HttpServer: Handling of multiple header fields with the same name and multiple values of "Connectio…

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 "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 124 matching lines @@
     }
 
     HttpServerRequestInfo request;
     size_t pos = 0;
     if (!ParseHeaders(connection, &request, &pos))
       break;
 
     // Sets peer address if exists.
     socket->GetPeerAddress(&request.peer);
 
-    std::string connection_header = request.GetHeaderValue("connection");
-    if (connection_header == "Upgrade") {
+    bool connection_upgrade = false;
+    {

[pfeldman, 2014/05/08 13:38:18]

There is no need for this.

+      std::string connection_header = request.GetHeaderValue("connection");

[pfeldman, 2014/05/08 13:38:18]

if (request.HasHeaderValue("connection", "upgrade"))

+      StringToLowerASCII(&connection_header);
+      std::vector<std::string> conn_items;
+      Tokenize(connection_header, ",", &conn_items);
+      for (std::vector<std::string>::iterator it = conn_items.begin();
+          it != conn_items.end(); ++it) {
+        base::TrimString(*it, " \t", &*it);
+        if (*it == "upgrade") {
+          connection_upgrade = true;
+          break;
+        }
+      }
+    }
+    if (connection_upgrade) {
       connection->web_socket_.reset(WebSocket::CreateWebSocket(connection,
                                                                request,
                                                                &pos));
 
       if (!connection->web_socket_.get())  // Not enough data was received.
         break;
       delegate_->OnWebSocketRequest(connection->id(), request);
       connection->Shift(pos);
       continue;
     }
@@ skipping 41 matching lines @@
 // 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.
 
 // Input character types.
 enum header_parse_inputs {
-  INPUT_SPACE,
+  INPUT_LWS,
   INPUT_CR,
   INPUT_LF,
   INPUT_COLON,
   INPUT_DEFAULT,
   MAX_INPUTS,
 };
 
 // Parser states.
 enum header_parse_states {
   ST_METHOD,     // Receiving the method
@@ skipping 18 matching lines @@
 /* SEPARATOR */ { ST_SEPARATOR, ST_ERR,     ST_ERR,   ST_VALUE,     ST_ERR },
 /* VALUE     */ { ST_VALUE,     ST_HEADER,  ST_NAME,  ST_VALUE,     ST_VALUE },
 /* DONE      */ { ST_DONE,      ST_DONE,    ST_DONE,  ST_DONE,      ST_DONE },
 /* ERR       */ { ST_ERR,       ST_ERR,     ST_ERR,   ST_ERR,       ST_ERR }
 };
 
 // Convert an input character to the parser's input token.
 int charToInput(char ch) {
   switch(ch) {
     case ' ':
-      return INPUT_SPACE;
+    case '\t':
+      return INPUT_LWS;
     case '\r':
       return INPUT_CR;
     case '\n':
       return INPUT_LF;
     case ':':
       return INPUT_COLON;
   }
   return INPUT_DEFAULT;
 }
 
 bool HttpServer::ParseHeaders(HttpConnection* connection,
                               HttpServerRequestInfo* info,
                               size_t* ppos) {
   size_t& pos = *ppos;
   size_t data_len = connection->recv_data_.length();
   int state = ST_METHOD;
   std::string buffer;
   std::string header_name;
   std::string header_value;
   while (pos < data_len) {
     char ch = connection->recv_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");
           buffer.clear();
           break;
         case ST_NAME:
           header_name = StringToLowerASCII(buffer);
           buffer.clear();
           break;
         case ST_VALUE:
           base::TrimWhitespaceASCII(buffer, base::TRIM_LEADING, &header_value);
-          // TODO(mbelshe): Deal better with duplicate headers
-          DCHECK(info->headers.find(header_name) == info->headers.end());
-          info->headers[header_name] = header_value;
+          it = info->headers.find(header_name);
+          // See last paragraph ("Multiple message-header fields...")
+          // of www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+          if (it == info->headers.end()) {
+            info->headers[header_name] = header_value;
+          } else {
+            it->second.append(",");
+            it->second.append(header_value);
+          }
           buffer.clear();
           break;
         case ST_SEPARATOR:
           break;
       }
       state = next_state;
     } else {
       // Do any actions based on current state
       switch (state) {
         case ST_METHOD:
@@ skipping 23 matching lines @@
 }
 
 HttpConnection* HttpServer::FindConnection(StreamListenSocket* socket) {
   SocketToConnectionMap::iterator it = socket_to_connection_.find(socket);
   if (it == socket_to_connection_.end())
     return NULL;
   return it->second;
 }
 
 }  // namespace net