tools/android/forwarder2/host_controller.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "tools/android/forwarder2/host_controller.h"
   6
   7 #include <string>
   8
   9 #include "base/basictypes.h"
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/logging.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "tools/android/forwarder2/command.h"
  15 #include "tools/android/forwarder2/forwarder.h"
  16 #include "tools/android/forwarder2/socket.h"
  17
  18 namespace forwarder2 {
  19
  20 // static
  21 scoped_ptr<HostController> HostController::Create(
  22     int device_port,
  23     int host_port,
  24     int adb_port,
  25     int exit_notifier_fd,
  26     const ErrorCallback& error_callback) {
  27   scoped_ptr<HostController> host_controller;
  28   scoped_ptr<PipeNotifier> delete_controller_notifier(new PipeNotifier());
  29   scoped_ptr<Socket> adb_control_socket(new Socket());
  30   adb_control_socket->AddEventFd(exit_notifier_fd);
  31   adb_control_socket->AddEventFd(delete_controller_notifier->receiver_fd());
  32   if (!adb_control_socket->ConnectTcp(std::string(), adb_port)) {
  33     LOG(ERROR) << "Could not connect HostController socket on port: "
  34                << adb_port;
  35     return host_controller.Pass();
  36   }
  37   // Send the command to the device start listening to the "device_forward_port"
  38   bool send_command_success = SendCommand(
  39       command::LISTEN, device_port, adb_control_socket.get());
  40   CHECK(send_command_success);
  41   int device_port_allocated;
  42   command::Type command;
  43   if (!ReadCommand(
  44           adb_control_socket.get(), &device_port_allocated, &command) ||
  45       command != command::BIND_SUCCESS) {
  46     LOG(ERROR) << "Device binding error using port " << device_port;
  47     return host_controller.Pass();
  48   }
  49   host_controller.reset(
  50       new HostController(
  51           device_port_allocated, host_port, adb_port, exit_notifier_fd,
  52           error_callback, adb_control_socket.Pass(),
  53           delete_controller_notifier.Pass()));
  54   return host_controller.Pass();
  55 }
  56
  57 HostController::~HostController() {
  58   DCHECK(deletion_task_runner_->RunsTasksOnCurrentThread());
  59   delete_controller_notifier_->Notify();
  60 }
  61
  62 void HostController::Start() {
  63   thread_.Start();
  64   ReadNextCommandSoon();
  65 }
  66
  67 HostController::HostController(
  68     int device_port,
  69     int host_port,
  70     int adb_port,
  71     int exit_notifier_fd,
  72     const ErrorCallback& error_callback,
  73     scoped_ptr<Socket> adb_control_socket,
  74     scoped_ptr<PipeNotifier> delete_controller_notifier)
  75     : self_deleter_helper_(this, error_callback),
  76       device_port_(device_port),
  77       host_port_(host_port),
  78       adb_port_(adb_port),
  79       global_exit_notifier_fd_(exit_notifier_fd),
  80       adb_control_socket_(adb_control_socket.Pass()),
  81       delete_controller_notifier_(delete_controller_notifier.Pass()),
  82       deletion_task_runner_(base::MessageLoopProxy::current()),
  83       thread_("HostControllerThread") {
  84 }
  85
  86 void HostController::ReadNextCommandSoon() {
  87   thread_.message_loop_proxy()->PostTask(
  88       FROM_HERE,
  89       base::Bind(&HostController::ReadCommandOnInternalThread,
  90                  base::Unretained(this)));
  91 }
  92
  93 void HostController::ReadCommandOnInternalThread() {
  94   if (!ReceivedCommand(command::ACCEPT_SUCCESS, adb_control_socket_.get())) {
  95     LOG(ERROR) << "Did not receive ACCEPT_SUCCESS for port: "
  96                << host_port_;
  97     OnInternalThreadError();
  98     return;
  99   }
 100   // Try to connect to host server.
 101   scoped_ptr<Socket> host_server_data_socket(new Socket());
 102   if (!host_server_data_socket->ConnectTcp(std::string(), host_port_)) {
 103     LOG(ERROR) << "Could not Connect HostServerData socket on port: "
 104                << host_port_;
 105     SendCommand(
 106         command::HOST_SERVER_ERROR, device_port_, adb_control_socket_.get());
 107     if (ReceivedCommand(command::ACK, adb_control_socket_.get())) {
 108       // It can continue if the host forwarder could not connect to the host
 109       // server but the device acknowledged that, so that the device could
 110       // re-try later.
 111       ReadNextCommandSoon();
 112       return;
 113     }
 114     OnInternalThreadError();
 115     return;
 116   }
 117   LOG(INFO) << "Will send HOST_SERVER_SUCCESS: " << host_port_;
 118   SendCommand(
 119       command::HOST_SERVER_SUCCESS, device_port_, adb_control_socket_.get());
 120   StartForwarder(host_server_data_socket.Pass());
 121   ReadNextCommandSoon();
 122 }
 123
 124 void HostController::StartForwarder(
 125     scoped_ptr<Socket> host_server_data_socket) {
 126   scoped_ptr<Socket> adb_data_socket(new Socket());
 127   if (!adb_data_socket->ConnectTcp("", adb_port_)) {
 128     LOG(ERROR) << "Could not connect AdbDataSocket on port: " << adb_port_;
 129     OnInternalThreadError();
 130     return;
 131   }
 132   // Open the Adb data connection, and send a command with the
 133   // |device_forward_port| as a way for the device to identify the connection.
 134   SendCommand(command::DATA_CONNECTION, device_port_, adb_data_socket.get());
 135
 136   // Check that the device received the new Adb Data Connection. Note that this
 137   // check is done through the |adb_control_socket_| that is handled in the
 138   // DeviceListener thread just after the call to WaitForAdbDataSocket().
 139   if (!ReceivedCommand(command::ADB_DATA_SOCKET_SUCCESS,
 140                        adb_control_socket_.get())) {
 141     LOG(ERROR) << "Device could not handle the new Adb Data Connection.";
 142     OnInternalThreadError();
 143     return;
 144   }
 145   forwarders_manager_.CreateAndStartNewForwarder(
 146       host_server_data_socket.Pass(), adb_data_socket.Pass());
 147 }
 148
 149 void HostController::OnInternalThreadError() {
 150   UnmapPortOnDevice();
 151   self_deleter_helper_.MaybeSelfDeleteSoon();
 152 }
 153
 154 void HostController::UnmapPortOnDevice() {
 155   Socket socket;
 156   if (!socket.ConnectTcp("", adb_port_)) {
 157     LOG(ERROR) << "Could not connect to device on port " << adb_port_;
 158     return;
 159   }
 160   if (!SendCommand(command::UNLISTEN, device_port_, &socket)) {
 161     LOG(ERROR) << "Could not send unmap command for port " << device_port_;
 162     return;
 163   }
 164   if (!ReceivedCommand(command::UNLISTEN_SUCCESS, &socket)) {
 165     LOG(ERROR) << "Unamp command failed for port " << device_port_;
 166     return;
 167   }
 168 }
 169
 170 }  // namespace forwarder2