Implement binder response object

With this, we can now call the actual request handler.

Change-Id: I836ba7f5c90273186709664bb5fb9fa7aff2972b
Test: Build continues to pass in binder mode
Bug: 27204884

6 files changed, 183 insertions, 14 deletions

diff --git a/libwebserv/Android.mk b/libwebserv/Android.mk
index a4ec9c1..4b3d858 100644
--- a/libwebserv/Android.mk
+++ b/libwebserv/Android.mk
@@ -45,7 +45,8 @@ LOCAL_SHARED_LIBRARIES += libwebserv-binder-internal
 LOCAL_SRC_FILES += \
     binder_server.cc \
     binder_request_handler.cc \
-    binder_request_impl.cc
+    binder_request_impl.cc \
+    binder_response.cc
 endif
 
 $(eval $(webservd_common))
diff --git a/libwebserv/binder_request_handler.cc b/libwebserv/binder_request_handler.cc
index cafccc5..3891135 100644
--- a/libwebserv/binder_request_handler.cc
+++ b/libwebserv/binder_request_handler.cc
@@ -15,6 +15,7 @@
 #include "libwebserv/binder_request_handler.h"
 
 #include "libwebserv/binder_request_impl.h"
+#include "libwebserv/binder_response.h"
 
 using android::binder::Status;
 using android::sp;
@@ -80,6 +81,10 @@ Status BinderRequestHandler::ProcessRequest(const sp<IHttpRequest>& request) {
   unique_ptr<Request> internal_request(
       new BinderRequestImpl(url, method, headers, query_params,
                             post_params, std::move(body)));
+  unique_ptr<Response> internal_response(new BinderResponse(request));
+
+  handler_->HandleRequest(std::move(internal_request),
+                          std::move(internal_response));
 
   return Status::ok();
 }
diff --git a/libwebserv/binder_response.cc b/libwebserv/binder_response.cc
new file mode 100644
index 0000000..ddcffab
--- /dev/null
+++ b/libwebserv/binder_response.cc
@@ -0,0 +1,79 @@
+// Copyright 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "libwebserv/binder_response.h"
+
+#include <base/bind.h>
+#include <brillo/bind_lambda.h>
+
+#include <brillo/http/http_request.h>
+#include <brillo/mime_utils.h>
+#include <brillo/streams/file_stream.h>
+#include <brillo/streams/stream_utils.h>
+
+using std::pair;
+using std::string;
+using std::vector;
+
+using android::sp;
+using android::binder::Status;
+using android::webservd::IHttpRequest;
+
+namespace libwebserv {
+
+BinderResponse::BinderResponse(const sp<IHttpRequest>& request)
+    : request_(request) {}
+
+void BinderResponse::AddHeaders(const vector<pair<string, string>>& headers) {
+  headers_.insert(headers.begin(), headers.end());
+}
+
+void BinderResponse::Reply(int status_code,
+                           brillo::StreamPtr data_stream,
+                           const std::string& mime_type) {
+  vector<string> headers;
+  AddHeader(brillo::http::response_header::kContentType, mime_type);
+  ScopedFd data_out;
+
+  for (const auto& header : headers_) {
+    headers.emplace_back(header.first);
+    headers.emplace_back(header.second);
+  }
+
+  int64_t data_size = -1;
+  if (data_stream->CanGetSize()) {
+    data_size = data_stream->GetRemainingSize();
+  }
+
+  if (!request_->Respond(status_code, headers,
+                         data_size, &data_out).isOk()) {
+    LOG(WARNING) << "Could not communicate response to server.";
+    return;
+  }
+
+  int dupfd = dup(data_out.get());
+  auto dest_stream =
+      brillo::FileStream::FromFileDescriptor(dupfd, true, nullptr);
+  CHECK(dest_stream);
+  // Dummy callbacks for success/error of data-copy operation. We ignore both
+  // notifications here.
+  auto on_success = [](brillo::StreamPtr, brillo::StreamPtr, uint64_t) {};
+  auto on_error = [](brillo::StreamPtr, brillo::StreamPtr,
+                     const brillo::Error*) {};
+  brillo::stream_utils::CopyData(
+      std::move(data_stream), std::move(dest_stream), base::Bind(on_success),
+      base::Bind(on_error));
+}
+
+}  // namespace libwebserv
diff --git a/libwebserv/binder_response.h b/libwebserv/binder_response.h
new file mode 100644
index 0000000..2d6c738
--- /dev/null
+++ b/libwebserv/binder_response.h
@@ -0,0 +1,50 @@
+// Copyright 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef WEBSERVER_LIBWEBSERV_BINDER_RESPONSE_H_
+#define WEBSERVER_LIBWEBSERV_BINDER_RESPONSE_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include <brillo/streams/file_stream.h>
+
+#include "libwebserv/response.h"
+#include "android/webservd/IHttpRequest.h"
+
+namespace libwebserv {
+
+class BinderResponse : public Response {
+ public:
+  BinderResponse(const android::sp<android::webservd::IHttpRequest>& request);
+
+  // Overrides
+  void AddHeaders(
+      const std::vector<std::pair<std::string, std::string>>& headers) override;
+  void Reply(int status_code,
+             brillo::StreamPtr data_stream,
+             const std::string& mime_type) override;
+
+ private:
+  std::multimap<std::string, std::string> headers_;
+  android::sp<android::webservd::IHttpRequest> request_;
+
+  DISALLOW_COPY_AND_ASSIGN(BinderResponse);
+};
+
+}  // namespace libwebserv
+
+#endif  // WEBSERVER_LIBWEBSERV_BINDER_RESPONSE_H_
+
diff --git a/webservd/Android.mk b/webservd/Android.mk
index 7d072bd..2224f0d 100644
--- a/webservd/Android.mk
+++ b/webservd/Android.mk
@@ -26,8 +26,12 @@ LOCAL_MODULE := webservd
 LOCAL_SHARED_LIBRARIES := \
     libcrypto \
     libfirewalld-client \
-    libwebserv \
-    libwebserv-proxies-internal \
+    libwebserv
+
+ifeq ($(system_webservd_use_dbus),true)
+LOCAL_SHARED_LIBRARIES += \
+    libwebserv-proxies-internal
+endif
 
 ifdef BRILLO
 
@@ -39,18 +43,12 @@ endif
 
 LOCAL_SRC_FILES := \
     config.cc \
-    dbus_bindings/dbus-service-config.json \
-    dbus_bindings/org.chromium.WebServer.ProtocolHandler.dbus-xml \
-    dbus_bindings/org.chromium.WebServer.Server.dbus-xml \
-    dbus_protocol_handler.cc \
-    dbus_request_handler.cc \
     error_codes.cc \
     firewalld_firewall.cc \
     log_manager.cc \
     main.cc \
     protocol_handler.cc \
     request.cc \
-    server.cc \
     temp_file_manager.cc \
     utils.cc \
 
@@ -64,6 +62,16 @@ LOCAL_SRC_FILES += \
     binder_server.cc
 endif
 
+ifeq ($(system_webservd_use_dbus),true)
+LOCAL_SRC_FILES += \
+    dbus_bindings/dbus-service-config.json \
+    dbus_bindings/org.chromium.WebServer.ProtocolHandler.dbus-xml \
+    dbus_bindings/org.chromium.WebServer.Server.dbus-xml \
+    dbus_protocol_handler.cc \
+    dbus_request_handler.cc \
+    server.cc
+endif
+
 ifdef BRILLO
 LOCAL_SRC_FILES += keystore_encryptor.cc
 else
diff --git a/webservd/main.cc b/webservd/main.cc
index c32b138..c6bf364 100644
--- a/webservd/main.cc
+++ b/webservd/main.cc
@@ -22,10 +22,13 @@
 #ifdef WEBSERV_USE_BINDER
 #include <binderwrapper/binder_wrapper.h>
 #include <brillo/binder_watcher.h>
+#include <brillo/daemons/daemon.h>
 #endif  // WEBSERV_USE_BINDER
+#ifdef WEBSERV_USE_DBUS
 #include <brillo/dbus/async_event_sequencer.h>
 #include <brillo/dbus/exported_object_manager.h>
 #include <brillo/daemons/dbus_daemon.h>
+#endif  // WEBSERV_USE_DBUS
 #include <brillo/flag_helper.h>
 #if !defined(__ANDROID__)
 #include <brillo/minijail/minijail.h>
@@ -37,7 +40,9 @@
 #endif  // WEBSERV_USE_BINDER
 #include "webservd/config.h"
 #include "webservd/log_manager.h"
+#ifdef WEBSERV_USE_DBUS
 #include "webservd/server.h"
+#endif
 #include "webservd/utils.h"
 
 #ifdef WEBSERV_USE_BINDER
@@ -54,23 +59,39 @@ using FirewallImpl = webservd::PermissionBrokerFirewall;
 
 using brillo::dbus_utils::AsyncEventSequencer;
 
+#ifdef WEBSERV_USE_DBUS
+using BaseDaemon = brillo::DBusServiceDaemon;
+#else
+using BaseDaemon = brillo::Daemon;
+#endif  // WEBSERV_USE_DBUS
+
 namespace {
 
 const char kDefaultConfigFilePath[] = "/etc/webservd/config";
+
+#ifdef WEBSERV_USE_DBUS
 const char kServiceName[] = "org.chromium.WebServer";
 const char kRootServicePath[] = "/org/chromium/WebServer";
+#endif  // WEBSERV_USE_DBUS
+
 #if !defined(__ANDROID__)
 const char kWebServerUserName[] = "webservd";
 const char kWebServerGroupName[] = "webservd";
 #endif  // !defined(__ANDROID__)
 
-class Daemon final : public brillo::DBusServiceDaemon {
+class Daemon final : public BaseDaemon {
  public:
+#ifdef WEBSERV_USE_DBUS
   explicit Daemon(webservd::Config config)
       : DBusServiceDaemon{kServiceName, kRootServicePath},
         config_{std::move(config)} {}
+#else
+  explicit Daemon(webservd::Config config)
+      : config_{std::move(config)} {}
+#endif  // WEBSERV_USE_DBUS
 
  protected:
+#ifdef WEBSERV_USE_DBUS
   void RegisterDBusObjectsAsync(AsyncEventSequencer* sequencer) override {
     webservd::LogManager::Init(base::FilePath{config_.log_directory});
     server_.reset(new webservd::Server{
@@ -83,11 +104,12 @@ class Daemon final : public brillo::DBusServiceDaemon {
   void OnShutdown(int* /* return_code */) override {
     server_.reset();
   }
+#endif  // WEBSERV_USE_DBUS
 
  private:
 #ifdef WEBSERV_USE_BINDER
   int OnInit() override {
-    int result = brillo::DBusServiceDaemon::OnInit();
+    int result = brillo::Daemon::OnInit();
     if (result != EX_OK) {
       return result;
     }
@@ -97,9 +119,11 @@ class Daemon final : public brillo::DBusServiceDaemon {
         return EX_OSERR;
     }
 
+    server_.reset(new webservd::BinderServer(config_));
+
     if (!android::BinderWrapper::Get()->RegisterService(
             webservd::kWebserverBinderServiceName,
-            new webservd::BinderServer(config_))) {
+            server_.get())) {
       return EX_OSERR;
     }
 
@@ -109,10 +133,12 @@ class Daemon final : public brillo::DBusServiceDaemon {
 #endif  // WEBSERV_USE_BINDER
 
   webservd::Config config_;
+#ifdef WEBSERV_USE_DBUS
   std::unique_ptr<webservd::Server> server_;
-#ifdef WEBSERV_USE_BINDER
+#else
+  std::unique_ptr<webservd::BinderServer> server_;
   brillo::BinderWatcher binder_watcher_;
-#endif  // WEBSERV_USE_BINDER
+#endif  // WEBSERV_USE_DBUS
 
   DISALLOW_COPY_AND_ASSIGN(Daemon);
 };