--- /dev/null
+/*
+ * 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 <string>
+
+#include "anbox/graphics/opengles_message_processor.h"
+#include "anbox/logger.h"
+#include "anbox/network/local_socket_messenger.h"
+#include "anbox/qemu/adb_message_processor.h"
+#include "anbox/qemu/boot_properties_message_processor.h"
+#include "anbox/qemu/bootanimation_message_processor.h"
+#include "anbox/qemu/camera_message_processor.h"
+#include "anbox/qemu/fingerprint_message_processor.h"
+#include "anbox/qemu/gsm_message_processor.h"
+#include "anbox/qemu/hwcontrol_message_processor.h"
+#include "anbox/qemu/null_message_processor.h"
+#include "anbox/qemu/pipe_connection_creator.h"
+#include "anbox/qemu/sensors_message_processor.h"
+
+namespace ba = boost::asio;
+
+namespace {
+std::string client_type_to_string(
+ const anbox::qemu::PipeConnectionCreator::client_type &type) {
+ switch (type) {
+ case anbox::qemu::PipeConnectionCreator::client_type::opengles:
+ return "opengles";
+ case anbox::qemu::PipeConnectionCreator::client_type::qemud_boot_properties:
+ return "boot-properties";
+ case anbox::qemu::PipeConnectionCreator::client_type::qemud_hw_control:
+ return "hw-control";
+ case anbox::qemu::PipeConnectionCreator::client_type::qemud_sensors:
+ return "sensors";
+ case anbox::qemu::PipeConnectionCreator::client_type::qemud_camera:
+ return "camera";
+ case anbox::qemu::PipeConnectionCreator::client_type::qemud_fingerprint:
+ return "fingerprint";
+ case anbox::qemu::PipeConnectionCreator::client_type::qemud_gsm:
+ return "gsm";
+ case anbox::qemu::PipeConnectionCreator::client_type::qemud_adb:
+ return "adb";
+ case anbox::qemu::PipeConnectionCreator::client_type::bootanimation:
+ return "boot-animation";
+ case anbox::qemu::PipeConnectionCreator::client_type::invalid:
+ break;
+ default:
+ break;
+ }
+ return "unknown";
+}
+}
+namespace anbox {
+namespace qemu {
+PipeConnectionCreator::PipeConnectionCreator(const std::shared_ptr<Renderer> &renderer, const std::shared_ptr<Runtime> &rt)
+ : renderer_(renderer),
+ runtime_(rt),
+ next_connection_id_(0),
+ connections_(
+ std::make_shared<network::Connections<network::SocketConnection>>()) {
+}
+
+PipeConnectionCreator::~PipeConnectionCreator() noexcept {
+ connections_->clear();
+}
+
+void PipeConnectionCreator::create_connection_for(
+ std::shared_ptr<boost::asio::local::stream_protocol::socket> const
+ &socket) {
+ auto const messenger = std::make_shared<network::LocalSocketMessenger>(socket);
+ const auto type = identify_client(messenger);
+ auto const processor = create_processor(type, messenger);
+ if (!processor)
+ BOOST_THROW_EXCEPTION(std::runtime_error("Unhandled client type"));
+
+ auto const &connection = std::make_shared<network::SocketConnection>(
+ messenger, messenger, next_id(), connections_, processor);
+ connection->set_name(client_type_to_string(type));
+ connections_->add(connection);
+ connection->read_next_message();
+}
+
+PipeConnectionCreator::client_type PipeConnectionCreator::identify_client(
+ std::shared_ptr<network::SocketMessenger> const &messenger) {
+ // The client will identify itself as first thing by writing a string
+ // in the format 'pipe:<name>[:<arguments>]\0' to the channel.
+ std::vector<char> buffer;
+ for (;;) {
+ unsigned char byte[1] = {0};
+ const auto err = messenger->receive_msg(ba::buffer(byte, 1));
+ if (err) break;
+ buffer.push_back(byte[0]);
+ if (byte[0] == 0x0) break;
+ }
+
+ std::string identifier_and_args = buffer.data();
+
+ if (utils::string_starts_with(identifier_and_args, "pipe:opengles"))
+ return client_type::opengles;
+ // Even if 'boot-properties' is an argument to the service 'qemud' here we
+ // take this as a own service instance as that is what it is.
+ else if (utils::string_starts_with(identifier_and_args,
+ "pipe:qemud:boot-properties"))
+ return client_type::qemud_boot_properties;
+ else if (utils::string_starts_with(identifier_and_args,
+ "pipe:qemud:hw-control"))
+ return client_type::qemud_hw_control;
+ else if (utils::string_starts_with(identifier_and_args, "pipe:qemud:sensors"))
+ return client_type::qemud_sensors;
+ else if (utils::string_starts_with(identifier_and_args, "pipe:qemud:camera"))
+ return client_type::qemud_camera;
+ else if (utils::string_starts_with(identifier_and_args,
+ "pipe:qemud:fingerprintlisten"))
+ return client_type::qemud_fingerprint;
+ else if (utils::string_starts_with(identifier_and_args, "pipe:qemud:gsm"))
+ return client_type::qemud_gsm;
+ else if (utils::string_starts_with(identifier_and_args,
+ "pipe:anbox:bootanimation"))
+ return client_type::bootanimation;
+ else if (utils::string_starts_with(identifier_and_args, "pipe:qemud:adb"))
+ return client_type::qemud_adb;
+
+ return client_type::invalid;
+}
+
+std::shared_ptr<network::MessageProcessor>
+PipeConnectionCreator::create_processor(
+ const client_type &type,
+ const std::shared_ptr<network::SocketMessenger> &messenger) {
+ if (type == client_type::opengles)
+ return std::make_shared<graphics::OpenGlesMessageProcessor>(renderer_, messenger);
+ else if (type == client_type::qemud_boot_properties)
+ return std::make_shared<qemu::BootPropertiesMessageProcessor>(messenger);
+ else if (type == client_type::qemud_hw_control)
+ return std::make_shared<qemu::HwControlMessageProcessor>(messenger);
+ else if (type == client_type::qemud_sensors)
+ return std::make_shared<qemu::SensorsMessageProcessor>(messenger);
+ else if (type == client_type::qemud_camera)
+ return std::make_shared<qemu::CameraMessageProcessor>(messenger);
+ else if (type == client_type::qemud_fingerprint)
+ return std::make_shared<qemu::FingerprintMessageProcessor>(messenger);
+ else if (type == client_type::qemud_gsm)
+ return std::make_shared<qemu::GsmMessageProcessor>(messenger);
+ else if (type == client_type::qemud_adb)
+ return std::make_shared<qemu::AdbMessageProcessor>(runtime_, messenger);
+
+ return std::make_shared<qemu::NullMessageProcessor>();
+}
+
+int PipeConnectionCreator::next_id() {
+ return next_connection_id_.fetch_add(1);
+}
+} // namespace qemu
+} // namespace anbox
Code Review / iec.git / blobdiff