src/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/stringprintf.h"
#include "base/string_number_conversions.h"
#include "base/string_util.h"
#include "base/sys_byteorder.h"
#include "build/build_config.h"
#include "net/base/net_errors.h"
#include "net/base/tcp_listen_socket.h"
#include "net/server/http_connection.h"
#include "net/server/http_server_request_info.h"
#include "net/server/web_socket.h"

namespace net {

HttpServer::HttpServer(const StreamListenSocketFactory& factory,
                       HttpServer::Delegate* delegate)
    : delegate_(delegate),
      ALLOW_THIS_IN_INITIALIZER_LIST(server_(factory.CreateAndListen(this))) {
  if (!server_) {
    DLOG(WARNING) << "Could not start HTTP server.";
  }
}

void HttpServer::AcceptWebSocket(
    int connection_id,
    const HttpServerRequestInfo& request) {
  DCHECK(thread_checker_.CalledOnValidThread());
  HttpConnection* connection = FindConnection(connection_id);
  if (connection == NULL)
    return;

  DCHECK(connection->web_socket_.get());
  connection->web_socket_->Accept(request);
}

void HttpServer::SendOverWebSocket(int connection_id,
                                   const std::string& data) {
  DCHECK(thread_checker_.CalledOnValidThread());
  HttpConnection* connection = FindConnection(connection_id);
  if (connection == NULL)
    return;
  DCHECK(connection->web_socket_.get());
  connection->web_socket_->Send(data);
}

void HttpServer::Send(int connection_id,
                      HttpStatusCode status_code,
                      const std::string& data,
                      const std::string& content_type,
                      const std::vector<std::string>& headers) {
  DCHECK(thread_checker_.CalledOnValidThread());
  HttpConnection* connection = FindConnection(connection_id);
  if (connection == NULL)
    return;
  connection->Send(status_code, data, content_type, headers);
}

void HttpServer::Send(int connection_id,
                      HttpStatusCode status_code,
                      const std::string& data,
                      const std::string& content_type) {
  DCHECK(thread_checker_.CalledOnValidThread());
  Send(connection_id, status_code, data, content_type,
       std::vector<std::string>());
}

void HttpServer::Send200(int connection_id,
                         const std::string& data,
                         const std::string& content_type) {
  DCHECK(thread_checker_.CalledOnValidThread());
  Send(connection_id, HTTP_OK, data, content_type);
}

void HttpServer::Send302(int connection_id,
                         const std::string& location) {
  DCHECK(thread_checker_.CalledOnValidThread());
  HttpConnection* connection = FindConnection(connection_id);
  if (connection == NULL)
    return;
  connection->SendRedirect(location);
}

void HttpServer::Send404(int connection_id) {
  DCHECK(thread_checker_.CalledOnValidThread());
  Send(connection_id, HTTP_NOT_FOUND, "", "text/html");
}

void HttpServer::Send500(int connection_id, const std::string& message) {
  DCHECK(thread_checker_.CalledOnValidThread());
  Send(connection_id, HTTP_INTERNAL_SERVER_ERROR, message, "text/html");
}

void HttpServer::Close(int connection_id) {
  DCHECK(thread_checker_.CalledOnValidThread());
  HttpConnection* connection = FindConnection(connection_id);
  if (connection == NULL)
    return;

  // Initiating close from server-side does not lead to the DidClose call.
  // Do it manually here.
  DidClose(connection->socket_);
}

int HttpServer::GetLocalAddress(IPEndPoint* address) {
  DCHECK(thread_checker_.CalledOnValidThread());
  if (server_) {
    return server_->GetLocalAddress(address);
  } else {
    return net::ERR_FAILED;
  }
}

void HttpServer::DidAccept(StreamListenSocket* server,
                           StreamListenSocket* socket) {
  DCHECK(thread_checker_.CalledOnValidThread());
  HttpConnection* connection = new HttpConnection(this, socket);
  id_to_connection_[connection->id()] = connection;
  socket_to_connection_[socket] = connection;
}

void HttpServer::DidRead(StreamListenSocket* socket,
                         const char* data,
                         int len) {
  DCHECK(thread_checker_.CalledOnValidThread());
  HttpConnection* connection = FindConnection(socket);
  DCHECK(connection != NULL);
  if (connection == NULL)
    return;

  connection->recv_data_.append(data, len);
  while (connection->recv_data_.length()) {
    if (connection->web_socket_.get()) {
      std::string message;
      WebSocket::ParseResult result = connection->web_socket_->Read(&message);
      if (result == WebSocket::FRAME_INCOMPLETE)
        break;

      if (result == WebSocket::FRAME_CLOSE ||
          result == WebSocket::FRAME_ERROR) {
        Close(connection->id());
        break;
      }
      delegate_->OnWebSocketMessage(connection->id(), message);
      continue;
    }

    HttpServerRequestInfo request;
    size_t pos = 0;
    if (!ParseHeaders(connection, &request, &pos)) {
#if defined(COBALT)
      Send500(connection->id(), "Error parsing HTTP headers.");
#endif
      break;
    }

    std::string connection_header = request.GetHeaderValue("Connection");
    if (connection_header == "Upgrade") {
      connection->web_socket_.reset(WebSocket::CreateWebSocket(connection,
                                                               request,
                                                               &pos));

      if (!connection->web_socket_.get())  // Not enought data was received.
        break;
      delegate_->OnWebSocketRequest(connection->id(), request);
      connection->Shift(pos);
      continue;
    }

    if (request.method == "POST" || request.method == "PUT") {
      // Get the remaining data.
      size_t content_length = 0;
      base::StringToSizeT(
          base::StringPiece(request.GetHeaderValue("Content-Length")),
          &content_length);
      if (content_length > 0 && pos < len) {
        request.data = connection->recv_data_.substr(pos);
      }
      pos += request.data.length();
    }

    delegate_->OnHttpRequest(connection->id(), request);
    connection->Shift(pos);
  }
}

void HttpServer::DidClose(StreamListenSocket* socket) {
  DCHECK(thread_checker_.CalledOnValidThread());
  HttpConnection* connection = FindConnection(socket);
  DCHECK(connection != NULL);
  id_to_connection_.erase(connection->id());
  socket_to_connection_.erase(connection->socket_);
  delete connection;
}

HttpServer::~HttpServer() {
  DCHECK(thread_checker_.CalledOnValidThread());
  STLDeleteContainerPairSecondPointers(
      id_to_connection_.begin(), id_to_connection_.end());
  server_ = NULL;
}

namespace { // anonymous

//
// 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.

// Input character types.
enum HeaderParseInputs {
  INPUT_SPACE,
  INPUT_CR,
  INPUT_LF,
  INPUT_COLON,
  INPUT_DEFAULT,
  MAX_INPUTS,
};

// Parser states.
enum HeaderParseStates {
  ST_METHOD,     // Receiving the method
  ST_URL,        // Receiving the URL
  ST_PROTO,      // Receiving the protocol
  ST_HEADER,     // Starting a Request Header
  ST_NAME,       // Receiving a request header name
  ST_SEPARATOR,  // Receiving the separator between header name and value
  ST_VALUE,      // Receiving a request header value
  ST_DONE,       // Parsing is complete and successful
  ST_ERR,        // Parsing encountered invalid syntax.
  MAX_STATES
};

// State transition table
HeaderParseStates parser_state[MAX_STATES][MAX_INPUTS] = {
/* METHOD    */ { ST_URL,       ST_ERR,     ST_ERR,   ST_ERR,       ST_METHOD },
/* URL       */ { ST_PROTO,     ST_ERR,     ST_ERR,   ST_URL,       ST_URL },
/* PROTOCOL  */ { ST_ERR,       ST_HEADER,  ST_NAME,  ST_ERR,       ST_PROTO },
/* HEADER    */ { ST_ERR,       ST_ERR,     ST_NAME,  ST_ERR,       ST_ERR },
/* NAME      */ { ST_SEPARATOR, ST_DONE,    ST_ERR,   ST_SEPARATOR, ST_NAME },
/* SEPARATOR */ { ST_SEPARATOR, ST_ERR,     ST_ERR,   ST_SEPARATOR, ST_VALUE },
/* 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.
HeaderParseInputs charToInput(char ch) {
  switch(ch) {
    case ' ':
      return INPUT_SPACE;
    case '\r':
      return INPUT_CR;
    case '\n':
      return INPUT_LF;
    case ':':
      return INPUT_COLON;
  }
  return INPUT_DEFAULT;
}

bool ParseHeadersInternal(const std::string& received_data,
                          HttpServerRequestInfo* info,
                          size_t* ppos) {
  size_t& pos = *ppos;
  size_t data_len = received_data.length();
  HeaderParseStates state = ST_METHOD;
  std::string buffer;
  std::string header_name;
  while (pos < data_len) {
    char ch = received_data[pos++];
    HeaderParseInputs input = charToInput(ch);
    HeaderParseStates next_state = parser_state[state][input];

    bool transition = (next_state != state);
    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.
          bool is_protocol_supported =
              buffer == "HTTP/1.0" || buffer == "HTTP/1.1";
#if defined(COBALT)
          if (!is_protocol_supported) {
            next_state = ST_ERR;
          }
#else
          DCHECK(is_protocol_supported);
#endif
          buffer.clear();
          break;
        }
        case ST_NAME: {
          header_name = buffer;
          buffer.clear();
          break;
        }
        case ST_VALUE: {
          HttpServerRequestInfo::HeadersMap::iterator
            header_entry = info->headers.find(header_name);
          if (header_entry != info->headers.end()) {
            // Combine duplicate headers, as allowed according to:
            // http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
            header_entry->second += "," + buffer;
          } else {
            info->headers[header_name] = buffer;
          }
          buffer.clear();
          break;
        }
        case ST_SEPARATOR: {
          buffer.append(&ch, 1);
          break;
        }
        default: {
          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:
          buffer.append(&ch, 1);
          break;
        case ST_DONE:
          DCHECK(input == INPUT_LF);
          return true;
        case ST_ERR:
          return false;
        default:
          break;
      }
    }
  }
  // No more characters, but we haven't finished parsing yet.
  return false;
}
} // anonymous namespace

bool HttpServer::ParseHeaders(HttpConnection* connection,
                              HttpServerRequestInfo* info,
                              size_t* ppos) {
  return ParseHeadersInternal(connection->recv_data_, info, ppos);
}

// static
bool HttpServer::ParseHeaders(const std::string& received_data,
                              HttpServerRequestInfo* info) {
  size_t pos = 0;
  return ParseHeadersInternal(received_data, info, &pos);
}

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;
}

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