Renaming Gnubby and RemoteSecurityKey files/classes/members

remoting/host/security_key/gnubby_extension_session.cc

-// Copyright 2016 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/security_key/gnubby_extension_session.h"
-
-#include "base/bind.h"
-#include "base/json/json_reader.h"
-#include "base/json/json_writer.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/values.h"
-#include "remoting/base/logging.h"
-#include "remoting/host/client_session_details.h"
-#include "remoting/host/security_key/gnubby_auth_handler.h"
-#include "remoting/proto/control.pb.h"
-#include "remoting/protocol/client_stub.h"
-
-namespace {
-
-// Used as the type attribute of all Security Key protocol::ExtensionMessages.
-const char kExtensionMessageType[] = "gnubby-auth";
-
-// Gnubby extension message data members.
-const char kConnectionId[] = "connectionId";
-const char kControlMessage[] = "control";
-const char kControlOption[] = "option";
-const char kDataMessage[] = "data";
-const char kDataPayload[] = "data";
-const char kErrorMessage[] = "error";
-const char kGnubbyAuthV1[] = "auth-v1";
-const char kMessageType[] = "type";
-
-// Returns the command code (the first byte of the data) if it exists, or -1 if
-// the data is empty.
-unsigned int GetCommandCode(const std::string& data) {
-  return data.empty() ? -1 : static_cast<unsigned int>(data[0]);
-}
-
-// Creates a string of byte data from a ListValue of numbers. Returns true if
-// all of the list elements are numbers.
-bool ConvertListValueToString(base::ListValue* bytes, std::string* out) {
-  out->clear();
-
-  unsigned int byte_count = bytes->GetSize();
-  if (byte_count != 0) {
-    out->reserve(byte_count);
-    for (unsigned int i = 0; i < byte_count; i++) {
-      int value;
-      if (!bytes->GetInteger(i, &value)) {
-        return false;
-      }
-      out->push_back(static_cast<char>(value));
-    }
-  }
-  return true;
-}
-
-}  // namespace
-
-namespace remoting {
-
-GnubbyExtensionSession::GnubbyExtensionSession(
-    ClientSessionDetails* client_session_details,
-    protocol::ClientStub* client_stub)
-    : client_stub_(client_stub) {
-  DCHECK(client_stub_);
-
-  gnubby_auth_handler_ = remoting::GnubbyAuthHandler::Create(
-      client_session_details,
-      base::Bind(&GnubbyExtensionSession::SendMessageToClient,
-                 base::Unretained(this)));
-}
-
-GnubbyExtensionSession::~GnubbyExtensionSession() {}
-
-// Returns true if the |message| is a Security Key ExtensionMessage.
-// This is done so the host does not pass |message| to other HostExtensions.
-// TODO(joedow): Use |client_session_details| to disconnect the session if we
-//               receive an invalid extension message.
-bool GnubbyExtensionSession::OnExtensionMessage(
-    ClientSessionDetails* client_session_details,
-    protocol::ClientStub* client_stub,
-    const protocol::ExtensionMessage& message) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (message.type() != kExtensionMessageType) {
-    return false;
-  }
-
-  std::unique_ptr<base::Value> value = base::JSONReader::Read(message.data());
-  base::DictionaryValue* client_message;
-  if (!value || !value->GetAsDictionary(&client_message)) {
-    LOG(WARNING) << "Failed to retrieve data from gnubby-auth message.";
-    return true;
-  }
-
-  std::string type;
-  if (!client_message->GetString(kMessageType, &type)) {
-    LOG(WARNING) << "Invalid gnubby-auth message format.";
-    return true;
-  }
-
-  if (type == kControlMessage) {
-    ProcessControlMessage(client_message);
-  } else if (type == kDataMessage) {
-    ProcessDataMessage(client_message);
-  } else if (type == kErrorMessage) {
-    ProcessErrorMessage(client_message);
-  } else {
-    VLOG(2) << "Unknown gnubby-auth message type: " << type;
-  }
-
-  return true;
-}
-
-void GnubbyExtensionSession::ProcessControlMessage(
-    base::DictionaryValue* message_data) const {
-  std::string option;
-  if (!message_data->GetString(kControlOption, &option)) {
-    LOG(WARNING) << "Could not extract control option from message.";
-    return;
-  }
-
-  if (option == kGnubbyAuthV1) {
-    gnubby_auth_handler_->CreateGnubbyConnection();
-  } else {
-    VLOG(2) << "Invalid gnubby-auth control option: " << option;
-  }
-}
-
-void GnubbyExtensionSession::ProcessDataMessage(
-    base::DictionaryValue* message_data) const {
-  int connection_id;
-  if (!message_data->GetInteger(kConnectionId, &connection_id)) {
-    LOG(WARNING) << "Could not extract connection id from message.";
-    return;
-  }
-
-  if (!gnubby_auth_handler_->IsValidConnectionId(connection_id)) {
-    LOG(WARNING) << "Unknown gnubby-auth data connection: '" << connection_id
-                 << "'";
-    return;
-  }
-
-  base::ListValue* bytes;
-  std::string response;
-  if (message_data->GetList(kDataPayload, &bytes) &&
-      ConvertListValueToString(bytes, &response)) {
-    HOST_LOG << "Sending gnubby response: " << GetCommandCode(response);
-    gnubby_auth_handler_->SendClientResponse(connection_id, response);
-  } else {
-    LOG(WARNING) << "Could not extract response data from message.";
-    gnubby_auth_handler_->SendErrorAndCloseConnection(connection_id);
-    return;
-  }
-}
-
-void GnubbyExtensionSession::ProcessErrorMessage(
-    base::DictionaryValue* message_data) const {
-  int connection_id;
-  if (!message_data->GetInteger(kConnectionId, &connection_id)) {
-    LOG(WARNING) << "Could not extract connection id from message.";
-    return;
-  }
-
-  if (gnubby_auth_handler_->IsValidConnectionId(connection_id)) {
-    HOST_LOG << "Sending gnubby error";
-    gnubby_auth_handler_->SendErrorAndCloseConnection(connection_id);
-  } else {
-    LOG(WARNING) << "Unknown gnubby-auth data connection: '" << connection_id
-                 << "'";
-  }
-}
-
-void GnubbyExtensionSession::SendMessageToClient(
-    int connection_id,
-    const std::string& data) const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(client_stub_);
-
-  base::DictionaryValue request;
-  request.SetString(kMessageType, kDataMessage);
-  request.SetInteger(kConnectionId, connection_id);
-
-  std::unique_ptr<base::ListValue> bytes(new base::ListValue());
-  for (std::string::const_iterator i = data.begin(); i != data.end(); ++i) {
-    bytes->AppendInteger(static_cast<unsigned char>(*i));
-  }
-  request.Set(kDataPayload, bytes.release());
-
-  std::string request_json;
-  CHECK(base::JSONWriter::Write(request, &request_json));
-
-  protocol::ExtensionMessage message;
-  message.set_type(kExtensionMessageType);
-  message.set_data(request_json);
-
-  client_stub_->DeliverHostMessage(message);
-}
-
-void GnubbyExtensionSession::SetGnubbyAuthHandlerForTesting(
-    std::unique_ptr<GnubbyAuthHandler> gnubby_auth_handler) {
-  DCHECK(gnubby_auth_handler);
-
-  gnubby_auth_handler_ = std::move(gnubby_auth_handler);
-  gnubby_auth_handler_->SetSendMessageCallback(base::Bind(
-      &GnubbyExtensionSession::SendMessageToClient, base::Unretained(this)));
-}
-
-}  // namespace remoting