Add gnubby authentication to remoting host

remoting/host/gnubby_auth_handler.cc

+// Copyright 2014 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 "remoting/host/gnubby_auth_handler.h"
+
+#include "base/base64.h"
+#include "base/json/json_reader.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/values.h"
+#include "net/base/net_errors.h"
+#include "net/socket/client_socket_factory.h"
+#include "remoting/base/logging.h"
+#include "remoting/host/gnubby_advertiser.h"
+#include "remoting/host/gnubby_connection.h"
+#include "remoting/host/gnubby_connection_factory.h"
+#include "remoting/proto/control.pb.h"
+#include "remoting/protocol/client_stub.h"
+
+namespace remoting {
+
+GnubbyAuthHandler::GnubbyAuthHandler(
+    GnubbyConnectionFactory* gnubby_connection_factory,
+    protocol::ClientStub* client_stub)
+    : gnubby_connection_factory_(gnubby_connection_factory),
+      client_stub_(client_stub),
+      current_connection_id_(0),
+      gnubbyd_listener_port_(0) {
+  DCHECK(gnubby_connection_factory_);
+  DCHECK(client_stub_);
+}
+
+GnubbyAuthHandler::~GnubbyAuthHandler() {
+  for (ConnectionMap::iterator iter = active_connections_.begin();
+       iter != active_connections_.end();
+       ++iter) {
+    delete iter->second;
+  }
+}
+
+void GnubbyAuthHandler::DeliverClientMessage(const std::string message) {
+  DCHECK(CalledOnValidThread());
+
+  scoped_ptr<base::Value> value;
+  value.reset(base::JSONReader::Read(message));
+  DCHECK(value->IsType(base::Value::TYPE_LIST));
+
+  base::ListValue* list = NULL;
+  DCHECK(value->GetAsList(&list));
+
+  std::string auth_message_type;
+  DCHECK(list->GetString(0, &auth_message_type));
+
+  if (auth_message_type == "control") {
+    std::string payload;
+    DCHECK(list->GetString(1, &payload));
+
+    if (payload == "auth-v1") {
+      CreateGnubbydSocket();
+      AcceptGnubbydConnections();
+
+      scoped_refptr<GnubbyAdvertiser> advertiser = new GnubbyAdvertiser(
+          net::ClientSocketFactory::GetDefaultFactory());
+      advertiser->Advertise(gnubbyd_listener_port_);
+    }
+  } else if (auth_message_type == "data") {
+    std::string connection_id_str;
+    DCHECK(list->GetString(1, &connection_id_str));
+
+    std::string payload;
+    DCHECK(list->GetString(2, &payload));
+
+    std::string decoded_payload;
+    base::Base64Decode(payload, &decoded_payload);
+
+    int connection_id = 0;
+    base::StringToInt(connection_id_str, &connection_id);
+
+    ConnectionMap::iterator iter = active_connections_.find(connection_id);
+    if (iter != active_connections_.end()) {
+      iter->second->Write(decoded_payload);
+    }
+  }
+}
+
+void GnubbyAuthHandler::ConnectionClosed(int connection_id) {
+  DCHECK(CalledOnValidThread());
+
+  DeliverHostControlMessage("close", base::IntToString(connection_id));
+
+  ConnectionMap::iterator iter = active_connections_.find(connection_id);
+  if (iter != active_connections_.end()) {
+    delete iter->second;
+    active_connections_.erase(iter);
+  }
+}
+
+void GnubbyAuthHandler::ConnectionError(int connection_id, int result) {
+  DCHECK(CalledOnValidThread());
+
+  HOST_LOG << "Error on connection " << connection_id << ": " << result;
+  ConnectionClosed(connection_id);
+}
+
+void GnubbyAuthHandler::DeliverHostControlMessage(
+    const std::string control_type,
+    const std::string data) const {
+  DCHECK(CalledOnValidThread());
+
+  protocol::ExtensionMessage message;
+  message.set_type("gnubby-auth");
+  message.set_data("control " + control_type + " " + data);
+
+  client_stub_->DeliverHostMessage(message);
+}
+
+void GnubbyAuthHandler::DeliverHostDataMessage(int connection_id,
+                                               const std::string data) const {
+  DCHECK(CalledOnValidThread());
+
+  std::string encoded_data;
+  base::Base64Encode(data, &encoded_data);
+
+  protocol::ExtensionMessage message;
+  message.set_type("gnubby-auth");
+  message.set_data("data " + base::IntToString(connection_id) + " " +
+                   encoded_data);
+
+  client_stub_->DeliverHostMessage(message);
+}
+
+void GnubbyAuthHandler::SetGnubbydSocketForTesting(
+    net::TCPServerSocket* gnubbyd_socket) {
+  gnubbyd_socket_.reset(gnubbyd_socket);
+  AcceptGnubbydConnections();
+}
+
+int GnubbyAuthHandler::AddGnubbyConnectionForTesting(
+    net::StreamSocket* pending_socket) {
+  pending_socket_.reset(pending_socket);
+  OnAccept(net::ERR_IO_PENDING);
+  return current_connection_id_;
+}
+
+bool GnubbyAuthHandler::HasGnubbyConnectionForTesting(int connection_id) const {
+  return active_connections_.find(connection_id) != active_connections_.end();
+}
+
+void GnubbyAuthHandler::CreateGnubbydSocket() {
+  DCHECK(CalledOnValidThread());
+
+  net::NetLog::Source source;
+  gnubbyd_socket_.reset(new net::TCPServerSocket(NULL, source));
+
+  net::IPAddressNumber local_ip;
+  net::ParseIPLiteralToNumber("127.0.0.1", &local_ip);
+
+  net::IPEndPoint local_endpoint(local_ip, 0);
+  int result = gnubbyd_socket_->Listen(local_endpoint, 1);
+  if (result != net::OK) {
+    HOST_LOG << "Failed to listen: " << result;
+    return;
+  }
+
+  net::IPEndPoint listener_endpoint;
+  result = gnubbyd_socket_->GetLocalAddress(&listener_endpoint);
+  if (result != net::OK) {
+    HOST_LOG << "Failed to get local endpoint: " << result;
+    return;
+  }
+
+  HOST_LOG << "Listening on endpoint: " << listener_endpoint.ToString();
+
+  gnubbyd_listener_port_ = listener_endpoint.port();
+}
+
+void GnubbyAuthHandler::AcceptGnubbydConnections() {
+  DCHECK(CalledOnValidThread());
+
+  int result = gnubbyd_socket_->Accept(
+      &pending_socket_,
+      base::Bind(&GnubbyAuthHandler::OnAccept, base::Unretained(this)));
+  if (result != net::ERR_IO_PENDING) {
+    OnAccept(result);
+  }
+}
+
+void GnubbyAuthHandler::OnAccept(int result) {
+  DCHECK(CalledOnValidThread());
+
+  if (result == net::OK) {
+    int connection_id = ++current_connection_id_;
+    active_connections_[connection_id] = gnubby_connection_factory_->Create(
+        this, connection_id, pending_socket_.release());
+    active_connections_[connection_id]->Read();
+    AcceptGnubbydConnections();
+  }
+}
+
+}  // namespace remoting