libwebserv/protocol_handler.cc

// Copyright 2014 The Chromium OS 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 "webserver/libwebserv/protocol_handler.h"

#include <tuple>

#include <base/logging.h>
#include <chromeos/map_utils.h>

#include "libwebserv/org.chromium.WebServer.RequestHandler.h"
#include "webservd/dbus-proxies.h"
#include "webserver/libwebserv/request.h"
#include "webserver/libwebserv/request_handler_callback.h"
#include "webserver/libwebserv/response.h"
#include "webserver/libwebserv/server.h"

namespace libwebserv {

namespace {

// A dummy callback for async D-Bus errors.
void IgnoreError(chromeos::Error* error) {}

}  // anonymous namespace

const char ProtocolHandler::kHttp[] = "http";
const char ProtocolHandler::kHttps[] = "https";

ProtocolHandler::ProtocolHandler(const std::string& id, Server* server)
    : id_{id}, server_{server} {}

ProtocolHandler::~ProtocolHandler() {
  // Remove any existing handlers, so the web server knows that we don't
  // need them anymore.

  // We need to get a copy of the map keys since removing the handlers will
  // modify the map in the middle of the loop and that's not a good thing.
  auto handler_ids = chromeos::GetMapKeys(request_handlers_);
  for (int handler_id : handler_ids) {
    RemoveHandler(handler_id);
  }
}

std::string ProtocolHandler::GetID() const {
  return id_;
}

uint16_t ProtocolHandler::GetPort() const {
  CHECK(IsConnected());
  return proxy_->port();
}

std::string ProtocolHandler::GetProtocol() const {
  CHECK(IsConnected());
  return proxy_->protocol();
}

chromeos::Blob ProtocolHandler::GetCertificateFingerprint() const {
  CHECK(IsConnected());
  return proxy_->certificate_fingerprint();
}

int ProtocolHandler::AddHandler(
    const std::string& url,
    const std::string& method,
    std::unique_ptr<RequestHandlerInterface> handler) {
  request_handlers_.emplace(++last_handler_id_,
                            HandlerMapEntry{url, method, std::string{},
                                            std::move(handler)});
  if (proxy_) {
    proxy_->AddRequestHandlerAsync(
        url,
        method,
        server_->service_name_,
        base::Bind(&ProtocolHandler::AddHandlerSuccess,
                   weak_ptr_factory_.GetWeakPtr(),
                   last_handler_id_),
        base::Bind(&ProtocolHandler::AddHandlerError,
                   weak_ptr_factory_.GetWeakPtr(),
                   last_handler_id_));
  }
  return last_handler_id_;
}

int ProtocolHandler::AddHandlerCallback(
    const std::string& url,
    const std::string& method,
    const base::Callback<RequestHandlerInterface::HandlerSignature>&
        handler_callback) {
  std::unique_ptr<RequestHandlerInterface> handler{
      new RequestHandlerCallback{handler_callback}};
  return AddHandler(url, method, std::move(handler));
}

bool ProtocolHandler::RemoveHandler(int handler_id) {
  auto p = request_handlers_.find(handler_id);
  if (p == request_handlers_.end())
    return false;

  if (proxy_) {
    proxy_->RemoveRequestHandlerAsync(
        p->second.remote_handler_id,
        base::Bind(&base::DoNothing),
        base::Bind(&IgnoreError));
  }

  request_handlers_.erase(p);
  return true;
}

void ProtocolHandler::Connect(
    org::chromium::WebServer::ProtocolHandlerProxy* proxy) {
  proxy_ = proxy;
  for (const auto& pair : request_handlers_) {
    proxy_->AddRequestHandlerAsync(
        pair.second.url,
        pair.second.method,
        server_->service_name_,
        base::Bind(&ProtocolHandler::AddHandlerSuccess,
                   weak_ptr_factory_.GetWeakPtr(),
                   pair.first),
        base::Bind(&ProtocolHandler::AddHandlerError,
                   weak_ptr_factory_.GetWeakPtr(),
                   pair.first));
  }
}

void ProtocolHandler::Disconnect() {
  proxy_ = nullptr;
  remote_handler_id_map_.clear();
}

void ProtocolHandler::AddHandlerSuccess(int handler_id,
                                        const std::string& remote_handler_id) {
  auto p = request_handlers_.find(handler_id);
  CHECK(p != request_handlers_.end());
  p->second.remote_handler_id = remote_handler_id;

  remote_handler_id_map_.emplace(remote_handler_id, handler_id);
}

void ProtocolHandler::AddHandlerError(int handler_id, chromeos::Error* error) {
  // Nothing to do at the moment.
}

bool ProtocolHandler::ProcessRequest(const std::string& remote_handler_id,
                                     const std::string& request_id,
                                     std::unique_ptr<Request> request,
                                     chromeos::ErrorPtr* error) {
  auto id_iter = remote_handler_id_map_.find(remote_handler_id);
  if (id_iter == remote_handler_id_map_.end()) {
    chromeos::Error::AddToPrintf(error, FROM_HERE,
                                 chromeos::errors::dbus::kDomain,
                                 DBUS_ERROR_FAILED,
                                 "Unknown request handler '%s'",
                                 remote_handler_id.c_str());
    return false;
  }
  auto handler_iter = request_handlers_.find(id_iter->second);
  if (handler_iter == request_handlers_.end()) {
    chromeos::Error::AddToPrintf(error, FROM_HERE,
                                 chromeos::errors::dbus::kDomain,
                                 DBUS_ERROR_FAILED,
                                 "Handler # %d is no longer available",
                                 id_iter->second);
    return false;
  }
  handler_iter->second.handler->HandleRequest(
      scoped_ptr<Request>(request.release()),
      scoped_ptr<Response>(new Response{this, request_id}));
  return true;
}

void ProtocolHandler::CompleteRequest(
    const std::string& request_id,
    int status_code,
    const std::multimap<std::string, std::string>& headers,
    const std::vector<uint8_t>& data) {
  if (!proxy_) {
    LOG(WARNING) << "Completing a request after the handler proxy is removed";
    return;
  }

  std::vector<std::tuple<std::string, std::string>> header_list;
  header_list.reserve(headers.size());
  for (const auto& pair : headers)
    header_list.emplace_back(pair.first, pair.second);

  proxy_->CompleteRequestAsync(request_id, status_code, header_list, data,
                               base::Bind(&base::DoNothing),
                               base::Bind([](chromeos::Error*) {}));
}

void ProtocolHandler::GetFileData(
    const std::string& request_id,
    int file_id,
    const base::Callback<void(const std::vector<uint8_t>&)>& success_callback,
    const base::Callback<void(chromeos::Error*)>& error_callback) {
  CHECK(proxy_);
  proxy_->GetRequestFileDataAsync(
      request_id, file_id, success_callback, error_callback);
}


}  // namespace libwebserv