[iec.git] / src / type3_AndroidCloud / anbox-master / src / anbox / qemu / adb_message_processor.cpp

/*
 * Copyright (C) 2016 Simon Fels <morphis@gravedo.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 3, as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "anbox/qemu/adb_message_processor.h"
#include "anbox/network/delegate_connection_creator.h"
#include "anbox/network/delegate_message_processor.h"
#include "anbox/network/tcp_socket_messenger.h"
#include "anbox/utils.h"

#include <fstream>
#include <functional>

namespace {
const unsigned short default_adb_client_port{5037};
// For the listening port we have to use an odd port in the 5555-5585 range so
// the host can find us on start. See
// https://developer.android.com/studio/command-line/adb.html.
const unsigned short default_host_listen_port{5559};
constexpr const char *loopback_address{"127.0.0.1"};
const std::string accept_command{"accept"};
const std::string ok_command{"ok"};
const std::string ko_command{"ko"};
const std::string start_command{"start"};
// This timeount should be too high to not cause a too long wait time for the
// user until we connect to the adb host instance after it appeared and not
// too short to not put unnecessary burden on the CPU.
const boost::posix_time::seconds default_adb_wait_time{1};
}

using namespace std::placeholders;

namespace anbox {
namespace qemu {
std::mutex AdbMessageProcessor::active_instance_{};

AdbMessageProcessor::AdbMessageProcessor(
    const std::shared_ptr<Runtime> &rt,
    const std::shared_ptr<network::SocketMessenger> &messenger)
    : runtime_(rt),
      state_(waiting_for_guest_accept_command),
      expected_command_(accept_command),
      messenger_(messenger),
      lock_(active_instance_, std::defer_lock) {
}

AdbMessageProcessor::~AdbMessageProcessor() {
  state_ = closed_by_host;

  host_connector_.reset();
}

void AdbMessageProcessor::advance_state() {
  switch (state_) {
    case waiting_for_guest_accept_command:
      // Try to get a lock here as if we already have another processor
      // running we don't have to do anything here until that one is done.
      // The container directly starts a second connection once the first
      // one is established but will not use it until the active one is closed.
      lock_.lock();

      if (state_ == closed_by_host) {
        host_connector_.reset();
        return;
      }

      wait_for_host_connection();
      break;
    case waiting_for_host_connection:
      messenger_->send(reinterpret_cast<const char *>(ok_command.data()),
                       ok_command.size());
      state_ = waiting_for_guest_start_command;
      expected_command_ = start_command;
      break;
    case waiting_for_guest_start_command:
      state_ = proxying_data;
      read_next_host_message();
      break;
    case proxying_data:
      break;
    case closed_by_host:
      // Close the connection to the container as our adb host connection
      // turned down. The container will try to establish a connection
      // immediately again and we will handle that by waiting for the
      // host adb to run up again.
      messenger_->close();
      break;
    case closed_by_container:
      // In this case the container will close the pipe connection and this
      // message processor will be deleted once the owning socket connection
      // is closed.
      break;
    default:
      break;
  }
}

void AdbMessageProcessor::wait_for_host_connection() {
  if (state_ != waiting_for_guest_accept_command)
    return;

  if (!host_connector_) {
    host_connector_ = std::make_shared<network::TcpSocketConnector>(
        boost::asio::ip::address_v4::from_string(loopback_address),
        default_host_listen_port, runtime_,
        std::make_shared<
            network::DelegateConnectionCreator<boost::asio::ip::tcp>>(
            std::bind(&AdbMessageProcessor::on_host_connection, this, _1)));
  }

  try {
    // Notify the adb host instance so that it knows on which port our
    // proxy is waiting for incoming connections.
    auto messenger = std::make_shared<network::TcpSocketMessenger>(
        boost::asio::ip::address_v4::from_string(loopback_address), default_adb_client_port, runtime_);
    auto message = utils::string_format("host:emulator:%d", default_host_listen_port);
    auto handshake = utils::string_format("%04x%s", message.size(), message.c_str());
    messenger->send(handshake.data(), handshake.size());
  } catch (...) {
    // Server not up. No problem, it will contact us when started.
  }
}

void AdbMessageProcessor::on_host_connection(std::shared_ptr<boost::asio::basic_stream_socket<boost::asio::ip::tcp>> const &socket) {
  host_messenger_ = std::make_shared<network::TcpSocketMessenger>(socket);

  // set_no_delay() reduces the latency of sending data, at the cost
  // of creating more TCP packets on the connection. It's useful when
  // doing lots of small send() calls, like the ADB protocol requires.
  // And since this is on localhost, the packet increase should not be
  // noticeable.
  host_messenger_->set_no_delay();

  // Let adb inside the container know that we have a connection to
  // the adb host instance
  messenger_->send(reinterpret_cast<const char *>(ok_command.data()), ok_command.size());

  state_ = waiting_for_guest_start_command;
  expected_command_ = start_command;
}

void AdbMessageProcessor::read_next_host_message() {
  auto callback = std::bind(&AdbMessageProcessor::on_host_read_size, this, _1, _2);
  host_messenger_->async_receive_msg(callback, boost::asio::buffer(host_buffer_));
}

void AdbMessageProcessor::on_host_read_size(const boost::system::error_code &error, std::size_t bytes_read) {
  if (error) {
    // When AdbMessageProcessor is destroyed on program termination, the sockets
    // are closed and the standing operations are canceled. But, the callback is
    // still called even in that case, and the object has already been
    // deleted. We detect that condition by looking at the error code and avoid
    // touching *this in that case.
    if (error == boost::system::errc::operation_canceled)
      return;

    // For other errors, we assume the connection with the host is dropped. We
    // close the connection to the container's adbd, which will trigger the
    // deletion of this AdbMessageProcessor instance and free resources (most
    // importantly, default_host_listen_port and the lock). The standing
    // connection that adbd opened can then proceed and wait for the host to be
    // up again.
    state_ = closed_by_host;
    messenger_->close();
    return;
  }

  messenger_->send(reinterpret_cast<const char *>(host_buffer_.data()), bytes_read);
  read_next_host_message();
}

bool AdbMessageProcessor::process_data(const std::vector<std::uint8_t> &data) {
  if (state_ == proxying_data) {
    host_messenger_->send(reinterpret_cast<const char *>(data.data()),
                          data.size());
    return true;
  }

  for (const auto &byte : data) buffer_.push_back(byte);

  if (expected_command_.size() > 0 &&
      buffer_.size() >= expected_command_.size()) {
    if (::memcmp(buffer_.data(), expected_command_.data(), data.size()) != 0) {
      // We got not the command we expected and will terminate here
      return false;
    }

    buffer_.erase(buffer_.begin(), buffer_.begin() + expected_command_.size());
    expected_command_.clear();

    advance_state();
  }

  return true;
}
}  // namespace qemu
}  // namespace anbox