/* * Copyright © 2016 Canonical Ltd. * * 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 . * * Authors: * Ted Gould */ #ifdef HAVE_LIBERTINE #include "application-impl-libertine.h" #include "libertine.h" #include "registry-impl.h" #include "string-util.h" #include using namespace lomiri::util; namespace lomiri { namespace app_launch { namespace app_impls { Libertine::Libertine(const AppID::Package& container, const AppID::AppName& appname, const std::shared_ptr& registry) : Base(registry) , _container(container) , _appname(appname) { auto gcontainer_path = unique_gchar(libertine_container_path(container.value().c_str())); if (gcontainer_path) { _container_path = gcontainer_path.get(); } if (!_keyfile) { auto system_app_path = unique_gchar(g_build_filename(_container_path.c_str(), "usr", "share", nullptr)); _basedir = system_app_path.get(); _keyfile = findDesktopFile(_basedir, "applications", appname.value() + ".desktop"); } if (!_keyfile) { auto container_home_path = unique_gchar(libertine_container_home_path(container.value().c_str())); auto local_app_path = unique_gchar(g_build_filename(container_home_path.get(), ".local", "share", nullptr)); _basedir = local_app_path.get(); _keyfile = findDesktopFile(_basedir, "applications", appname.value() + ".desktop"); } if (!_keyfile) throw std::runtime_error{"Unable to find a keyfile for application '" + appname.value() + "' in container '" + container.value() + "'"}; appinfo_ = std::make_shared(appId(), _keyfile, _basedir, _container_path, app_info::DesktopFlags::NO_SPLASH, registry_); g_debug("Application Libertine object for container '%s' app '%s'", container.value().c_str(), appname.value().c_str()); } std::shared_ptr Libertine::keyfileFromPath(const std::string& pathname) { auto keyfile = share_glib(g_key_file_new()); GError* error = nullptr; g_key_file_load_from_file(keyfile.get(), pathname.c_str(), G_KEY_FILE_NONE, &error); if (error != nullptr) { g_error_free(error); return {}; } return keyfile; } std::shared_ptr Libertine::findDesktopFile(const std::string& basepath, const std::string& subpath, const std::string& filename) { auto fullpath = unique_gchar(g_build_filename(basepath.c_str(), subpath.c_str(), filename.c_str(), nullptr)); std::string sfullpath(fullpath.get()); if (g_file_test(sfullpath.c_str(), G_FILE_TEST_IS_REGULAR)) { return keyfileFromPath(sfullpath); } GError* error = nullptr; auto dirpath = unique_gchar(g_build_filename(basepath.c_str(), subpath.c_str(), nullptr)); auto dir = unique_glib(g_dir_open(dirpath.get(), 0, &error)); if (error != nullptr) { g_error_free(error); return {}; } const gchar* file; while ((file = g_dir_read_name(dir.get())) != nullptr) { auto new_subpath = unique_gchar(g_build_filename(subpath.c_str(), file, nullptr)); auto new_fullpath = unique_gchar(g_build_filename(basepath.c_str(), new_subpath.get(), nullptr)); if (g_file_test(new_fullpath.get(), G_FILE_TEST_IS_DIR)) { auto desktop_file = findDesktopFile(basepath, new_subpath.get(), filename); if (desktop_file) { return desktop_file; } } } return {}; } std::shared_ptr Libertine::info() { return appinfo_; } std::vector> Libertine::instances() { auto vbase = registry_->jobs()->instances(appId(), "application-legacy"); return std::vector>(vbase.begin(), vbase.end()); } /** Grabs all the environment variables for the application to launch in. It sets up the confinement ones and then adds in the APP_EXEC line. This function adds 'libertine-launch' at the beginning of the Exec line with the container name as a parameter. The command can be overridden with the LOMIRI_APP_LAUNCH_LIBERTINE_LAUNCH environment variable. */ std::list> Libertine::launchEnv() { std::list> retval; info(); /* The container is our confinement */ retval.emplace_back(std::make_pair("APP_EXEC_POLICY", "unconfined")); auto libertine_launch = g_getenv("LOMIRI_APP_LAUNCH_LIBERTINE_LAUNCH"); if (libertine_launch == nullptr) { libertine_launch = LIBERTINE_LAUNCH; } auto desktopexec = appinfo_->execLine().value(); auto execline = std::string(libertine_launch) + " \"--id=" + _container.value() + "\" " + desktopexec; retval.emplace_back(std::make_pair("APP_EXEC", execline)); /* TODO: Go multi instance */ retval.emplace_back(std::make_pair("INSTANCE_ID", "")); return retval; } std::shared_ptr Libertine::launch(const std::vector& urls) { auto instance = getInstance(appinfo_); std::function>(void)> envfunc = [this]() { return launchEnv(); }; return registry_->jobs()->launch(appId(), "application-legacy", instance, urls, jobs::manager::launchMode::STANDARD, envfunc); } std::shared_ptr Libertine::launchTest(const std::vector& urls) { auto instance = getInstance(appinfo_); std::function>(void)> envfunc = [this]() { return launchEnv(); }; return registry_->jobs()->launch(appId(), "application-legacy", instance, urls, jobs::manager::launchMode::TEST, envfunc); } std::shared_ptr Libertine::findInstance(const std::string& instanceid) { return registry_->jobs()->existing(appId(), "application-legacy", instanceid, std::vector{}); } } // namespace app_impls } // namespace app_launch } // namespace lomiri #endif // HAVE_LIBERTINE