httpserver.cc

Go to the documentation of this file.

#include "ion/remote/httpserver.h"

#if !ION_PRODUCTION

#include <stdio.h>

#include <algorithm>
#include <cstring>
#include <sstream>

#include "ion/base/lockguards.h"
#include "ion/base/logging.h"
#include "ion/base/scopedallocation.h"
#include "ion/base/stringutils.h"

#include "third_party/mongoose/mongoose.h"

#endif  // !ION_PRODUCTION

namespace ion {
namespace remote {

#if !ION_PRODUCTION

class HttpServer::WebsocketHelper {
 public:
  explicit WebsocketHelper(mg_connection* conn)
      : connection_(conn), ready_(false), binary_(false) {
  }
  ~WebsocketHelper() {
    websocket_->helper_ = NULL;
  }

  void SetWebsocket(const WebsocketPtr& websocket) {
    websocket_ = websocket;
    websocket_->SetHelper(this);
  }
  void Register(HttpServer* server) {
    server->RegisterWebsocket(connection_, this);
  }
  void Unregister(HttpServer* server) {
    server->UnregisterWebsocket(connection_);
  }

  void ConnectionReady() {
    ready_ = true;
    websocket_->ConnectionReady();
  }

  enum Opcode {
    CONTINUATION = 0,
    TEXT         = 1,
    BINARY       = 2,
    CLOSE        = 8,
    PING         = 9,
    PONG         = 10
  };

  int ReceiveData(uint8 bits, char* data, size_t data_len);
  void SendData(Opcode opcode, const char* data, size_t data_len);

  static WebsocketHelper* FindWebsocket(HttpServer* server,
                                        mg_connection* connection) {
    return server->FindWebsocket(connection);
  }

 private:
  int BeginContinuation(bool is_binary, char* data, size_t data_len);
  void AppendContinuationData(char data[], size_t data_len);

  mg_connection* connection_;
  WebsocketPtr websocket_;
  bool ready_;
  std::vector<char> continuation_;
  bool binary_;
  port::Mutex mutex_;
};

int HttpServer::WebsocketHelper::ReceiveData(
    uint8 bits, char* data, size_t data_len) {

  Opcode opcode = static_cast<Opcode>(bits & 0xF);
  bool fin = bits & 0x80;

  switch (opcode) {
    case CONTINUATION:
      if (continuation_.size() == 0) {
        return 0;
      }
      AppendContinuationData(data, data_len);
      if (fin) {
        int result = websocket_->ReceiveData(
            &(continuation_[0]), continuation_.size(), binary_);
        continuation_.clear();
        return result;
      } else {
        return 1;
      }
    case TEXT:
      if (fin) {
        return websocket_->ReceiveData(data, data_len, false);
      } else {
        return BeginContinuation(false, data, data_len);
      }
    case BINARY:
      if (fin) {
        return websocket_->ReceiveData(data, data_len, true);
      } else {
        return BeginContinuation(true, data, data_len);
      }
    case CLOSE:
      return 0;
    case PING:
      SendData(PONG, data, data_len);
      return 1;
    case PONG:
      return 0;
    default:
      LOG(WARNING) << "Unrecognized websocket opcode: " << opcode;
      return 0;
  }
}

int HttpServer::WebsocketHelper::BeginContinuation(
    bool is_binary, char* data, size_t data_len) {
  if (continuation_.size() > 0) {
    continuation_.clear();
    return 0;
  }
  binary_ = is_binary;
  AppendContinuationData(data, data_len);
  return 1;
}

void HttpServer::WebsocketHelper::AppendContinuationData(
    char data[], size_t data_len) {
  continuation_.insert(continuation_.end(), data, data + data_len);
}

void HttpServer::WebsocketHelper::SendData(
    Opcode opcode, const char* data, size_t data_len) {
  uint8 header[10];
  size_t header_size;

  header[0] = static_cast<uint8>(0x80 | (opcode & 0xF));

  if (data_len < 126) {
    header[1] = static_cast<uint8>(data_len);
    header_size = 2;
  } else if (data_len <= 0xFFFF) {
    header[1] = 126;
    header[2] = static_cast<uint8>(data_len >> 8);
    header[3] = static_cast<uint8>(data_len & 0xFF);
    header_size = 4;
  } else {
    header[1] = 127;
    size_t shifted_len = data_len;
    for (int i = 7; i >= 0; i--) {
      header[2+i] = static_cast<uint8>(shifted_len & 0xFF);
      shifted_len >>= 8;
    }
    header_size = 10;
  }

  base::LockGuard lock(&mutex_);
  mg_write(connection_, header, header_size);
  mg_write(connection_, data, data_len);
}

namespace {

static int LogCallback(const mg_connection*, const char* message) {
  LOG(ERROR) << "Mongoose: " << message;
  return 1;
}

static HttpServer::QueryMap BuildQueryMap(const char* query_string) {
  HttpServer::QueryMap args;
  if (query_string) {
    const std::vector<std::string> queries =
        base::SplitString(query_string, "&");
    const size_t num_queries = queries.size();
    for (size_t i = 0; i < num_queries; ++i) {
      const std::vector<std::string> pairs =
          base::SplitString(queries[i], "=");
      DCHECK(pairs.size() == 1 || pairs.size() == 2);
      if (pairs.size() > 1) {
        const size_t buffer_length = pairs[1].length() * 5;
        base::ScopedAllocation<char> buffer(base::kShortTerm, buffer_length);
        mg_url_decode(pairs[1].c_str(), static_cast<int>(pairs[1].length()),
                      buffer.Get(), static_cast<int>(buffer_length), 1);

        args[pairs[0]] = buffer.Get();
      } else {
        args[pairs[0]] = "";
      }
    }
  }
  return args;
}

static const std::string MakeRelativePath(
  const HttpServer::RequestHandlerPtr& handler, const std::string& full_path) {
  const std::string& base_path = handler->GetBasePath();
  const std::string path = full_path.length() < base_path.length()
      ? std::string()
      : full_path.substr(base_path.length(),
                         full_path.length() - base_path.length());

  size_t start_pos = path.find_first_not_of('/');
  if (start_pos == std::string::npos)
    start_pos = 0;
  if (path == "/")
    start_pos = 1;
  size_t end_pos = path.find_last_not_of('/');
  if (end_pos == std::string::npos)
    end_pos = path.length();
  else
    end_pos++;

  return path.substr(start_pos, end_pos - start_pos);
}

static const std::string EmbedAllLocalTags(
    const std::string& source, const HttpServer::HandlerMap& handlers);


static HttpServer::RequestHandlerPtr FindHandlerForPath(
    const std::string& path, const HttpServer::HandlerMap& handlers) {
  std::string search_path = path;
  while (search_path.length()) {
    HttpServer::HandlerMap::const_iterator found = handlers.find(search_path);
    if (found != handlers.end()) {
      return found->second;
    } else {
      const size_t pos = search_path.rfind("/");
      if (pos == 0U && search_path.length() > 1) {
        search_path = "/";
      } else {
        search_path = search_path.substr(0, pos);
      }
    }
  }
  static const HttpServer::RequestHandlerPtr no_handler;
  return no_handler;
}

static const std::string GetFileData(const std::string& path,
                                     const char* query_string,
                                     const std::string& header_html,
                                     const std::string& footer_html,
                                     const HttpServer::HandlerMap& handlers,
                                     std::string* content_type,
                                     bool embed_local_sourced_files) {
  HttpServer::RequestHandlerPtr handler = FindHandlerForPath(path, handlers);
  if (!handler.Get()) {
    return std::string();
  }

  const HttpServer::QueryMap args = BuildQueryMap(query_string);

  std::string response = handler->HandleRequest(
      MakeRelativePath(handler, path), args, content_type);

  if (*content_type == "text/html") {
    if (!header_html.empty())
      response = base::ReplaceString(response, "<!--HEADER-->", header_html);
    if (!footer_html.empty())
      response = base::ReplaceString(response, "<!--FOOTER-->", footer_html);
    if (embed_local_sourced_files)
      response = EmbedAllLocalTags(response, handlers);
  }
  return response;
}

static bool FindLocallyReferencedTag(
    const std::string& html, const HttpServer::HandlerMap& handlers,
    const std::string& tag_in, const std::string& attribute, size_t* pos,
    std::string* target, std::string* data, std::string* content_type) {
  data->clear();
  target->clear();
  const std::string tag = "<" + tag_in;
  *pos = html.find(tag, *pos);
  if (*pos == std::string::npos) {
    return false;
  } else {
    const size_t end = html.find(">", *pos);
    if (end != std::string::npos) {
      *target = html.substr(*pos, end - *pos + 1U);
      const std::vector<std::string> attributes =
          base::SplitString(*target, " =>");
      const size_t count = attributes.size();
      for (size_t i = 0; i < count; ++i) {
        if (attributes[i] == attribute && i < count - 1U) {
          const std::string& attr = attributes[i + 1U];
          const std::string path = attr.substr(attr.find_first_not_of("\"'"),
                                               attr.find_last_not_of("\"'"));
          if (base::StartsWith(path, "/")) {
            *content_type = mg_get_builtin_mime_type(path.c_str());
            *data = GetFileData(path, "", "", "", handlers, content_type, true);
          }
          break;
        }
      }
    }
    return true;
  }
}

static const std::string FormatImgTag(const std::string& content_type,
                                      const std::string& data) {
  return "<img src='data:" + content_type + ";base64," +
      base::MimeBase64EncodeString(data) + "'>";
}
static const std::string FormatLinkTag(const std::string& content_type,
                                       const std::string& data) {
  return "<style>\n" + data + "\n</style>\n";
}
static const std::string FormatScriptTag(const std::string& content_type,
                                         const std::string& data) {
  return "<script>\n" + data + "\n";
}

static const std::string EmbedLocalTags(
    const std::string& source,
    const HttpServer::HandlerMap& handlers,
    const std::string& tag,
    const std::string& attribute,
    const std::string (*formatter)(const std::string& content_type,
                                   const std::string& data)) {
  std::string html = source;
  size_t pos = 0U;
  std::string data;
  std::string target;
  std::string content_type;
  while (FindLocallyReferencedTag(
      html, handlers, tag, attribute, &pos, &target, &data, &content_type)) {
    if (!data.empty()) {
      const std::string replacement = formatter(content_type, data);
      html = base::ReplaceString(html, target, replacement);
      pos += replacement.length();
    } else {
      pos += target.length();
    }
  }
  return html;
}

static const std::string EmbedAllLocalTags(
    const std::string& source, const HttpServer::HandlerMap& handlers) {
  std::string html = source;
  html = EmbedLocalTags(html, handlers, "img", "src", FormatImgTag);
  html = EmbedLocalTags(html, handlers, "link", "href", FormatLinkTag);
  html = EmbedLocalTags(html, handlers, "script", "src", FormatScriptTag);
  return html;
}

static void SendStatusCode(mg_connection* connection, const std::string& status,
                           const std::string& text) {
  std::stringstream header_stream;
  header_stream << "HTTP/1.1 " << status << "\r\n"
                << "Content-Length: " << text.length() << "\r\n"
                << "Connection: close\r\n\r\n" << text;
  const std::string headers = header_stream.str();
  mg_printf(connection, "%s", headers.c_str());
}

static bool ParseRangeRequest(const char* range_header,
                              int64 content_length,
                              int64* range_start,
                              int64* range_end,
                              std::string* range) {
  static const size_t kEqualPos = 5U;

  bool valid_request = false;
  const std::string header_string(range_header);
  if (header_string.find("=") == kEqualPos &&
      header_string.substr(0, kEqualPos) == "bytes") {
    std::istringstream header(header_string.substr(kEqualPos + 1U));
    int64 start = 0, end = 0;
    header >> start >> end;
    valid_request = !header.fail() && end < 0;
    if (valid_request) {
      *range_start = start;
      *range_end = std::min(-end, content_length);
      std::stringstream range_stream;
      range_stream << "Content-Range: bytes " << *range_start << "-"
                   << *range_end << "/" << content_length << "\r\n";
      *range = range_stream.str();
    }
  }
  return valid_request;
}

static void SendFileData(mg_connection* connection,
                         const std::string& method,  // GET, HEAD, or POST.
                         const std::string& content_type,
                         const std::string& data) {
  std::string status("200 OK");
  int64 range_start = 0;
  int64 range_end = static_cast<int64>(data.length());
  std::string range;
  if (const char* header = mg_get_header(connection, "Range"))
    if (ParseRangeRequest(header, range_end, &range_start, &range_end, &range))
      status = "206 Partial Content";

  std::stringstream header_stream;
  header_stream << "HTTP/1.1 " << status << "\r\n"
                << "Content-Type: " << content_type << "\r\n"
                << "Content-Length: " << data.length() << "\r\n"
                << "Connection: close\r\n"
                << "Accept-Ranges: bytes\r\n" << range << "\r\n";

  const std::string headers = header_stream.str();
  mg_printf(connection, "%s", headers.c_str());
  if (method != "HEAD") {
    const size_t size = static_cast<size_t>(range_end - range_start + 1);
    mg_write(connection, &data[static_cast<size_t>(range_start)], size);
  }
}

static int BeginRequestCallback(mg_connection* connection) {
  const mg_request_info* info = mg_get_request_info(connection);
  if (NULL != mg_get_header(connection, "Sec-WebSocket-Key")) {
    return 0;
  }
  const std::string method(info->request_method);
  if (method == "GET" || method == "POST" || method == "HEAD") {
    HttpServer* server = reinterpret_cast<HttpServer*>(info->user_data);
    DCHECK(server);
    std::string content_type = mg_get_builtin_mime_type(info->uri);
    const std::string data =
        GetFileData(info->uri, info->query_string, server->GetHeaderHtml(),
                    server->GetFooterHtml(), server->GetHandlers(),
                    &content_type, server->EmbedLocalSourcedFiles());

    if (data.empty()) {
      SendStatusCode(connection, "404 Not Found",
                     "Error 404: Not Found\nThe requested file was not found.");
    } else {
      SendFileData(connection, method, content_type, data);
    }
    return 1;
  } else {
    return 0;
  }
}

static int WebsocketConnect(const mg_connection* connection) {
  mg_connection* unconst_connection = const_cast<mg_connection*>(connection);
  const mg_request_info* info = mg_get_request_info(unconst_connection);

  HttpServer* server = reinterpret_cast<HttpServer*>(info->user_data);
  HttpServer::RequestHandlerPtr handler =
      FindHandlerForPath(info->uri, server->GetHandlers());
  if (!handler.Get()) {
    return -1;
  }

  const HttpServer::QueryMap args = BuildQueryMap(info->query_string);
  const std::string path = MakeRelativePath(handler, info->uri);

  HttpServer::WebsocketPtr websocket = handler->ConnectWebsocket(path, args);
  if (!websocket.Get()) {
    return -1;
  }
  HttpServer::WebsocketHelper* helper =
      new HttpServer::WebsocketHelper(unconst_connection);
  helper->SetWebsocket(websocket);
  helper->Register(server);
  return 0;
}

static void WebsocketReady(mg_connection* connection) {
  const mg_request_info* info = mg_get_request_info(connection);
  HttpServer* server = reinterpret_cast<HttpServer*>(info->user_data);
  HttpServer::WebsocketHelper::FindWebsocket(server, connection)->
      ConnectionReady();
}

static int WebsocketData(mg_connection* connection, int bits,
                         char* data, size_t data_len) {
  const mg_request_info* info = mg_get_request_info(connection);
  HttpServer* server = reinterpret_cast<HttpServer*>(info->user_data);
  HttpServer::WebsocketHelper* helper =
      HttpServer::WebsocketHelper::FindWebsocket(server, connection);
  DCHECK(helper) << "WebsocketData(): failed websocket lookup";
  int result = 0;
  if (helper) {
    result = helper->ReceiveData(static_cast<uint8>(bits), data, data_len);
    if (result == 0) {
      helper->Unregister(server);
      delete helper;
    }
  }
  return result;
}

}  // anonymous namespace

HttpServer::RequestHandler::RequestHandler(const std::string& base_path)
    : base_path_(base_path) {}

HttpServer::RequestHandler::~RequestHandler() {}

HttpServer::HttpServer(int port, int num_threads)
    : context_(NULL),
      embed_local_sourced_files_(false) {
  if (port) {
    std::stringstream int_to_string;
    int_to_string << port;
    const std::string port_cstr = int_to_string.str();
    int_to_string.str("");
    int_to_string << num_threads;
    const std::string num_threads_cstr = int_to_string.str();

    mg_callbacks callbacks;
    const char* options[] = { "listening_ports", port_cstr.c_str(),
                              "num_threads", num_threads_cstr.c_str(),
                              NULL };

    memset(&callbacks, 0, sizeof(callbacks));
    callbacks.log_message = LogCallback;
    callbacks.begin_request = BeginRequestCallback;
    callbacks.websocket_connect = WebsocketConnect;
    callbacks.websocket_ready = WebsocketReady;
    callbacks.websocket_data = WebsocketData;
    context_ = mg_start(&callbacks, this, options);
  }
}

HttpServer::~HttpServer() {
  if (context_) {
    mg_stop(context_);
    context_ = NULL;
  }
}

const std::string HttpServer::GetUriData(const std::string& uri) const {
  std::string content_type = mg_get_builtin_mime_type(uri.c_str());

  const size_t query_pos = uri.find('?');
  const std::string path = uri.substr(0, query_pos);
  const std::string query_string = query_pos == std::string::npos ?
      "" : uri.substr(query_pos + 1U, std::string::npos);

  return GetFileData(base::StartsWith(path, "/") ? path : '/' + path,
                     query_string.c_str(), header_, footer_, GetHandlers(),
                     &content_type, embed_local_sourced_files_);
}

bool HttpServer::IsRunning() const {
  return context_ != NULL;
}

void HttpServer::RegisterHandler(const RequestHandlerPtr& handler) {
  DCHECK(handler.Get());
  std::string chomped_path = handler->GetBasePath();
  while (chomped_path.length() > 1 && base::RemoveSuffix("/", &chomped_path)) {}

  ion::base::LockGuard lock(&handlers_mutex_);
  handlers_[chomped_path] = handler;
}

void HttpServer::UnregisterHandler(const std::string& path) {
  ion::base::LockGuard lock(&handlers_mutex_);
  handlers_.erase(path);
}

HttpServer::HandlerMap HttpServer::GetHandlers() const {
  ion::base::LockGuard lock(&handlers_mutex_);
  return handlers_;
}

void HttpServer::RegisterWebsocket(void* key, WebsocketHelper* helper) {
  base::LockGuard lock(&websocket_mutex_);
  DCHECK(websockets_.find(key) == websockets_.end());
  websockets_[key] = helper;
}

HttpServer::WebsocketHelper* HttpServer::FindWebsocket(void* key) {
  base::LockGuard lock(&websocket_mutex_);
  WebsocketMap::iterator it = websockets_.find(key);
  return (it == websockets_.end())
      ? static_cast<HttpServer::WebsocketHelper*>(NULL)
      : it->second;
}

void HttpServer::UnregisterWebsocket(void* key) {
  base::LockGuard lock(&websocket_mutex_);
  WebsocketMap::iterator it = websockets_.find(key);
  DCHECK(it != websockets_.end()) << "could not find websocket to unregister";
  if (it != websockets_.end()) {
    websockets_.erase(it);
  }
}

void HttpServer::Websocket::SendData(
    const char* data, size_t data_len, bool is_binary) {
  HttpServer::WebsocketHelper::Opcode opcode = is_binary
      ? HttpServer::WebsocketHelper::BINARY
      : HttpServer::WebsocketHelper::TEXT;
  helper_->SendData(opcode, data, data_len);
}

size_t HttpServer::WebsocketCount() {
  base::LockGuard lock(&websocket_mutex_);
  return websockets_.size();
}

#else

HttpServer::HttpServer(int port, int num_threads)
    : context_(NULL),
      embed_local_sourced_files_(false) {}

HttpServer::~HttpServer() {}

#endif  // !ION_PRODUCTION

}  // namespace remote
}  // namespace ion