--- /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 "anbox/cmds/launch.h"
+#include "anbox/dbus/stub/application_manager.h"
+#include "anbox/dbus/interface.h"
+#include "anbox/ui/splash_screen.h"
+#include "anbox/system_configuration.h"
+#include "anbox/logger.h"
+
+#include "core/posix/exec.h"
+#include "core/posix/fork.h"
+#include "core/posix/signal.h"
+
+#include <boost/filesystem.hpp>
+
+#include <fcntl.h>
+#include <sys/stat.h>
+
+namespace fs = boost::filesystem;
+
+namespace {
+constexpr unsigned int max_session_mgr_wait_attempts{10};
+const std::chrono::seconds session_mgr_wait_interval{5};
+constexpr unsigned int max_dbus_service_wait_attempts{10};
+const std::chrono::seconds dbus_service_wait_interval{5};
+
+static int redirect_to_null(int flags, int fd) {
+ int fd2;
+ if ((fd2 = open("/dev/null", flags)) < 0)
+ return -1;
+
+ if (fd2 == fd)
+ return fd;
+
+ if (dup2(fd2, fd) < 0)
+ return -1;
+
+ close(fd2);
+ return fd;
+}
+} // namespace
+
+bool anbox::cmds::Launch::launch_session_manager() {
+ std::vector<std::string> args = {"session-manager"};
+ const auto should_force_software_rendering = utils::get_env_value("ANBOX_FORCE_SOFTWARE_RENDERING", "false");
+ if (should_force_software_rendering == "true")
+ args.push_back("--software-rendering");
+
+ std::map<std::string,std::string> env;
+ core::posix::this_process::env::for_each([&](const std::string &name, const std::string &value) {
+ env.insert({name, value});
+ });
+
+ const auto exe_path = utils::process_get_exe_path(::getpid());
+ if (!fs::exists(exe_path)) {
+ ERROR("Can't find correct anbox executable to run. Found %s but does not exist", exe_path);
+ return false;
+ }
+
+ try {
+ auto flags = core::posix::StandardStream::empty;
+ auto child = core::posix::fork([&]() {
+
+ // We redirect all in/out/err to /dev/null as they can't be seen
+ // anywhere. All logging output will directly go to syslog as we
+ // will become a session leader below which will get us rid of a
+ // controlling terminal.
+ if (redirect_to_null(O_RDONLY, 0) < 0 ||
+ redirect_to_null(O_WRONLY, 1) < 0 ||
+ redirect_to_null(O_WRONLY, 2) < 0) {
+ ERROR("Failed to redirect stdout/stderr/stdin: %s", strerror(errno));
+ return core::posix::exit::Status::failure;
+ }
+
+ // As we forked one time already we're sure that our process is
+ // not the session leader anymore so we can safely become the
+ // new one and lead the process group.
+ if (setsid() < 0) {
+ ERROR("Failed to become new session leader: %s", strerror(errno));
+ return core::posix::exit::Status::failure;
+ }
+
+ umask(0077);
+
+ if (chdir("/") < 0) {
+ ERROR("Failed to change current directory: %s", strerror(errno));
+ return core::posix::exit::Status::failure;
+ }
+
+ auto grandchild = core::posix::exec(exe_path, args, env, flags);
+ grandchild.dont_kill_on_cleanup();
+ return core::posix::exit::Status::success;
+ }, flags);
+
+ // We don't wait for the grandchild but the child as we use double forking
+ // here to break through the process hierarchy and make the grandchild a
+ // direct child of the init process so it keeps running on its own and
+ // indepent of our short living process here.
+ child.wait_for(core::posix::wait::Flags::untraced);
+
+ DEBUG("Started session manager, will now try to connect ..");
+ }
+ catch (...) {
+ ERROR("Failed to start session manager instance");
+ }
+
+ return true;
+}
+
+bool anbox::cmds::Launch::try_launch_activity(const std::shared_ptr<dbus::stub::ApplicationManager> &stub) {
+ try {
+ DEBUG("Sending launch intent %s to Android ..", intent_);
+ stub->launch(intent_, graphics::Rect::Invalid, stack_);
+ } catch (const std::exception &err) {
+ ERROR("Failed to launch activity: %s", err.what());
+ return false;
+ } catch (...) {
+ ERROR("Failed to launch activity");
+ return false;
+ }
+
+ return true;
+}
+
+anbox::cmds::Launch::Launch()
+ : CommandWithFlagsAndAction{
+ cli::Name{"launch"}, cli::Usage{"launch"},
+ cli::Description{"Launch an Activity by sending an intent"}} {
+ flag(cli::make_flag(cli::Name{"action"},
+ cli::Description{"Action of the intent"},
+ intent_.action));
+ flag(cli::make_flag(cli::Name{"type"},
+ cli::Description{"MIME type for the intent"},
+ intent_.type));
+ flag(cli::make_flag(cli::Name{"uri"},
+ cli::Description{"URI used as data within the intent"},
+ intent_.uri));
+ flag(cli::make_flag(cli::Name{"package"},
+ cli::Description{"Package the intent should go to"},
+ intent_.package));
+ flag(cli::make_flag(cli::Name{"component"},
+ cli::Description{"Component of a package the intent should go"},
+ intent_.component));
+ flag(cli::make_flag(cli::Name{"stack"},
+ cli::Description{"Which window stack the activity should be started on. Possible: default, fullscreen, freeform"},
+ stack_));
+ flag(cli::make_flag(cli::Name{"use-system-dbus"},
+ cli::Description{"Use system instead of session DBus"},
+ use_system_dbus_));
+
+
+ action([this](const cli::Command::Context&) {
+ if (!intent_.valid()) {
+ ERROR("The intent you provided is invalid. Please provide a correct launch intent.");
+ ERROR("For example to launch the application manager, run:");
+ ERROR("$ anbox launch --package=org.anbox.appmgr --component=org.anbox.appmgr.AppViewActivity");
+ return EXIT_FAILURE;
+ }
+
+ auto bus_type = anbox::dbus::Bus::Type::Session;
+ if (use_system_dbus_)
+ bus_type = anbox::dbus::Bus::Type::System;
+ auto bus = std::make_shared<anbox::dbus::Bus>(bus_type);
+
+ std::shared_ptr<ui::SplashScreen> ss;
+ if (!bus->has_service_with_name(dbus::interface::Service::name())) {
+ DEBUG("Session manager is not yet running, trying to start it");
+
+ if (!launch_session_manager())
+ return EXIT_FAILURE;
+
+ // Give us a splash screen as long as we're trying to connect
+ // with the session manager so the user knows something is
+ // happening after he started Anbox.
+ ss = std::make_shared<ui::SplashScreen>();
+ }
+
+ unsigned int n = 0;
+ while (n < max_dbus_service_wait_attempts) {
+ if (bus->has_service_with_name(dbus::interface::Service::name()))
+ break;
+
+ std::this_thread::sleep_for(dbus_service_wait_interval);
+ n++;
+ }
+
+ auto app_mgr = dbus::stub::ApplicationManager::create_for_bus(bus);
+ n = 0;
+ while (n < max_session_mgr_wait_attempts) {
+ app_mgr->update_properties();
+ if (app_mgr->ready().get())
+ break;
+
+ std::this_thread::sleep_for(session_mgr_wait_interval);
+ n++;
+ }
+
+ if (!app_mgr->ready()) {
+ ERROR("Session manager failed to become ready");
+ return EXIT_FAILURE;
+ }
+
+ // If we have a splash screen now is the time to drop it as we're
+ // going to launch the real application now.
+ ss.reset();
+
+ const auto success = try_launch_activity(app_mgr);
+ return success ? EXIT_SUCCESS : EXIT_FAILURE;
+ });
+}
Code Review / iec.git / blobdiff