/*
* 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
*/
#include "jobs-posix.h"
#include "application-impl-base.h"
#include "registry-impl.h"
#include "second-exec-core.h"
#include "string-util.h"
#include "utils.h"
#include "lomiri-app-launch-trace.h"
#include
#include
#include
#include
#include
#include
#include
using namespace lomiri::util;
namespace lomiri
{
namespace app_launch
{
namespace jobs
{
namespace instance
{
class POSIX : public instance::Base
{
friend class manager::POSIX;
public:
explicit POSIX(const AppID& appId,
const std::string& job,
const std::string& instance,
const std::vector& urls,
const std::shared_ptr& registry);
virtual ~POSIX()
{
g_debug("Destroying a POSIX for '%s' instance '%s'", std::string(appId_).c_str(), instance_.c_str());
}
/* Query lifecycle */
pid_t primaryPid() override;
std::vector pids() override;
/* Manage lifecycle */
void stop() override;
}; // class POSIX
POSIX::POSIX(const AppID& appId,
const std::string& job,
const std::string& instance,
const std::vector& urls,
const std::shared_ptr& registry)
: Base(appId, job, instance, urls, registry)
{
g_debug("Creating a new POSIX for '%s' instance '%s'", std::string(appId).c_str(), instance.c_str());
}
pid_t POSIX::primaryPid()
{
auto manager = std::dynamic_pointer_cast(registry_->jobs());
return manager->unitPrimaryPid(appId_, job_, instance_);
}
std::vector POSIX::pids()
{
auto manager = std::dynamic_pointer_cast(registry_->jobs());
return manager->unitPids(appId_, job_, instance_);
}
void POSIX::stop()
{
auto manager = std::dynamic_pointer_cast(registry_->jobs());
manager->stopUnit(appId_, job_, instance_);
}
} // namespace instance
namespace manager
{
// static const char* SYSTEMD_DBUS_ADDRESS{"org.freedesktop.systemd1"};
// static const char* SYSTEMD_DBUS_IFACE_MANAGER{"org.freedesktop.systemd1.Manager"};
// static const char* SYSTEMD_DBUS_PATH_MANAGER{"/org/freedesktop/systemd1"};
// static const char * SYSTEMD_DBUS_IFACE_UNIT{"org.freedesktop.systemd1.Unit"};
// static const char* SYSTEMD_DBUS_IFACE_SERVICE{"org.freedesktop.systemd1.Service"};
POSIX::POSIX(const std::shared_ptr& registry)
: Base(registry)
{
// TODO STUB
g_debug("POSIX constructor stub called...");
}
POSIX::~POSIX()
{
}
void POSIX::copyEnv(const std::string& envname, std::list>& env)
{
if (!findEnv(envname, env).empty())
{
g_debug("Already a value set for '%s' ignoring", envname.c_str());
return;
}
auto cvalue = getenv(envname.c_str());
g_debug("Copying Environment: %s", envname.c_str());
if (cvalue != nullptr)
{
std::string value{cvalue};
env.emplace_back(std::make_pair(envname, value));
}
else
{
g_debug("Unable to copy environment '%s'", envname.c_str());
}
}
void POSIX::copyEnvByPrefix(const std::string& prefix, std::list>& env)
{
for (unsigned int i = 0; environ[i] != nullptr; i++)
{
if (g_str_has_prefix(environ[i], prefix.c_str()))
{
std::string envname = environ[i];
envname.erase(envname.find('='));
copyEnv(envname, env);
}
}
}
std::shared_ptr POSIX::launch(
const AppID& appId,
const std::string& job,
const std::string& instance,
const std::vector& urls,
launchMode mode,
std::function>(void)>& getenv)
{
if (appId.empty())
return {};
auto appJobs = getAllApplicationJobs();
bool isApplication = std::find(appJobs.begin(), appJobs.end(), job) != appJobs.end();
auto reg = getReg();
return reg->thread.executeOnThread>([&]() -> std::shared_ptr {
auto manager = std::dynamic_pointer_cast(reg->jobs());
std::string appIdStr{appId};
g_debug("Initializing params for an new instance::POSIX for: %s", appIdStr.c_str());
tracepoint(lomiri_app_launch, liblal_start, appIdStr.c_str());
int timeout = 1;
if (lomiri::app_launch::Registry::Impl::isWatchingAppStarting())
{
timeout = 0;
}
handshake_t* handshake{nullptr};
if (isApplication)
{
handshake = starting_handshake_start(appIdStr.c_str(), instance.c_str(), timeout);
if (handshake == nullptr)
{
g_warning("Unable to setup starting handshake");
}
}
/* Build up our environment */
auto env = getenv();
env.emplace_back(std::make_pair("APP_ID", appIdStr)); /* Application ID */
env.emplace_back(std::make_pair("APP_LAUNCHER_PID", std::to_string(getpid()))); /* Who we are, for bugs */
copyEnv("DISPLAY", env);
for (const auto& prefix : {"DBUS_", "MIR_", "LOMIRI_APP_LAUNCH_"})
{
copyEnvByPrefix(prefix, env);
}
/* If we're in deb mode and launching legacy apps, they're gonna need
* more context, they really have no other way to get it. */
if (g_getenv("SNAP") == nullptr && appId.package.value().empty())
{
copyEnvByPrefix("QT_", env);
copyEnvByPrefix("XDG_", env);
/* If we're in Lomiri we don't want to pass it's platform, we want
* an application platform. */
removeEnv("QT_QPA_PLATFORM", env);
}
/* Mir socket if we don't have one in our env */
if (findEnv("MIR_SOCKET", env).empty())
{
env.emplace_back(std::make_pair("MIR_SOCKET", g_get_user_runtime_dir() + std::string{"/mir_socket"}));
}
if (!urls.empty())
{
auto accumfunc = [](const std::string& prev, Application::URL thisurl) -> std::string {
gchar* gescaped = g_shell_quote(thisurl.value().c_str());
std::string escaped;
if (gescaped != nullptr)
{
escaped = gescaped;
g_free(gescaped);
}
else
{
g_warning("Unable to escape URL: %s", thisurl.value().c_str());
return prev;
}
if (prev.empty())
{
return escaped;
}
else
{
return prev + " " + escaped;
}
};
auto urlstring = std::accumulate(urls.begin(), urls.end(), std::string{}, accumfunc);
env.emplace_back(std::make_pair("APP_URIS", urlstring));
}
if (mode == launchMode::TEST)
{
env.emplace_back(std::make_pair("QT_LOAD_TESTABILITY", "1"));
}
/* ExecStart */
auto commands = parseExec(env);
if (commands.empty())
{
// TODO: Handle???
g_debug("Commands stuff is empty!!");
return nullptr;
}
/* Working Directory */
if (!findEnv("APP_DIR", env).empty())
{
// g_variant_builder_open(&builder, G_VARIANT_TYPE_TUPLE);
// g_variant_builder_add_value(&builder, g_variant_new_string("WorkingDirectory"));
// g_variant_builder_open(&builder, G_VARIANT_TYPE_VARIANT);
// g_variant_builder_add_value(&builder, g_variant_new_string(findEnv("APP_DIR", env).c_str()));
}
/* Clean up env before shipping it */
for (const auto& rmenv :
{"APP_DIR", "APP_URIS", "APP_EXEC", "APP_EXEC_POLICY", "APP_LAUNCHER_PID",
"INSTANCE_ID", "MIR_SERVER_PLATFORM_PATH", "MIR_SERVER_PROMPT_FILE", "MIR_SERVER_HOST_SOCKET",
"LOMIRI_APP_LAUNCH_OOM_HELPER", "LOMIRI_APP_LAUNCH_LEGACY_ROOT"})
{
removeEnv(rmenv, env);
}
g_debug("Environment length: %d", envSize(env));
/* Environment */
for (const auto& envvar : env)
{
if (!envvar.first.empty() && !envvar.second.empty())
{
// g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf(
// "%s=%s", envvar.first.c_str(), envvar.second.c_str())));
// g_debug("Setting environment: %s=%s", envvar.first.c_str(), envvar.second.c_str());
}
}
auto retval = std::make_shared(appId, job, instance, urls, reg);
tracepoint(lomiri_app_launch, handshake_wait, appIdStr.c_str());
starting_handshake_wait(handshake);
tracepoint(lomiri_app_launch, handshake_complete, appIdStr.c_str());
// From https://stackoverflow.com/a/7026414
g_debug("PREPARING ARGV...");
std::vector argv;
for(auto loop = commands.begin(); loop != commands.end(); ++loop)
{
argv.push_back(&(*loop)[0]);
g_debug("%s", argv.back());
}
argv.push_back(NULL);
g_debug("PREPARING ENVP...");
std::vector envp_str;
std::vector envp;
for(auto loop = env.begin(); loop != env.end(); ++loop)
{
std::string envStr;
envStr += (*loop).first;
envStr += "=";
envStr += (*loop).second;
envp_str.push_back(envStr);
envp.push_back(&envp_str.back()[0]);
}
envp.push_back(NULL);
std::cout << "printing members of envp:" << std::endl;
for(char* n : envp) {
std::cout << n << std::endl;
}
pid_t child_pid = fork();
if(child_pid == 0) {
/* Call the job start function */
g_debug("argv[0]: %s", argv[0]);
execvpe(argv[0], &argv[0], &envp[0]);
g_debug("execvpe failed from child.");
g_debug("errno: %d", errno);
g_debug("errmsg: %s", strerror(errno));
}
g_debug("child_pid: %d", child_pid);
launchedpids.emplace_back(child_pid);
tracepoint(lomiri_app_launch, liblal_start_message_sent, appIdStr.c_str());
return retval;
});
}
std::shared_ptr POSIX::existing(const AppID& appId,
const std::string& job,
const std::string& instance,
const std::vector& urls)
{
return std::make_shared(appId, job, instance, urls, getReg());
}
std::vector> POSIX::instances(const AppID& appID, const std::string& job)
{
// TODO: STUB
g_debug("instances stub called...");
auto reg = getReg();
std::vector> instances;
std::vector urls;
std::string instance = "somestring";
instances.emplace_back(std::make_shared(appID, job, instance, urls, reg));
g_debug("Found %d instances for AppID '%s'", int(instances.size()), std::string(appID).c_str());
return instances;
}
std::list POSIX::runningAppIds(const std::list& allJobs)
{
// TODO: STUB
g_debug("runningAppIds stub called...");
std::set appids;
return {appids.begin(), appids.end()};
}
pid_t POSIX::unitPrimaryPid(const AppID& appId, const std::string& job, const std::string& instance)
{
// TODO: STUB
g_debug("unitPrimaryPid stub called...");
return 0;
}
std::vector POSIX::unitPids(const AppID& appId, const std::string& job, const std::string& instance)
{
// TODO: STUB
g_debug("unitPids stub called...");
return launchedpids;
}
void POSIX::stopUnit(const AppID& appId, const std::string& job, const std::string& instance)
{
// TODO: STUB
g_debug("stopUnit stub called...");
}
core::Signal& POSIX::jobStarted()
{
/* Ensure we're connecting to the signals */
return sig_jobStarted;
}
core::Signal& POSIX::jobStopped()
{
/* Ensure we're connecting to the signals */
return sig_jobStopped;
}
core::Signal& POSIX::jobFailed()
{
// TODO: STUB
g_debug("jobFailed stub called...");
return sig_jobFailed;
}
std::string POSIX::findEnv(const std::string& value, std::list>& env)
{
std::string retval;
auto entry = std::find_if(env.begin(), env.end(),
[&value](std::pair& entry) { return entry.first == value; });
if (entry != env.end())
{
retval = entry->second;
}
return retval;
}
void POSIX::removeEnv(const std::string& value, std::list>& env)
{
auto entry = std::find_if(env.begin(), env.end(),
[&value](std::pair& entry) { return entry.first == value; });
if (entry != env.end())
{
env.erase(entry);
}
}
int POSIX::envSize(std::list>& env)
{
int len = std::string{"Environment="}.length();
for (const auto& entry : env)
{
len += 3; /* two quotes, one space */
len += entry.first.length();
len += entry.second.length();
}
len -= 1; /* We account for a space each time but the first doesn't have */
return len;
}
std::vector POSIX::parseExec(std::list>& env)
{
auto exec = findEnv("APP_EXEC", env);
if (exec.empty())
{
g_warning("Application exec line is empty?!?!?");
return {};
}
auto uris = findEnv("APP_URIS", env);
g_debug("Exec line: %s", exec.c_str());
g_debug("App URLS: %s", uris.c_str());
auto execarray = desktop_exec_parse(exec.c_str(), uris.c_str());
std::vector retval;
for (unsigned int i = 0; i < execarray->len; i++)
{
auto cstr = g_array_index(execarray, gchar*, i);
if (cstr != nullptr)
{
retval.emplace_back(cstr);
}
}
/* This seems to work better than array_free(), I can't figure out why */
auto strv = (gchar**)g_array_free(execarray, FALSE);
g_strfreev(strv);
if (retval.empty())
{
g_warning("After parsing 'APP_EXEC=%s' we ended up with no tokens", exec.c_str());
}
/* See if we're doing apparmor by hand */
auto appexecpolicy = findEnv("APP_EXEC_POLICY", env);
if (!appexecpolicy.empty() && appexecpolicy != "unconfined")
{
retval.emplace(retval.begin(), "--");
retval.emplace(retval.begin(), appexecpolicy);
retval.emplace(retval.begin(), "-p");
retval.emplace(retval.begin(), AA_EXEC_PATH);
}
return retval;
}
} // namespace manager
} // namespace jobs
} // namespace app_launch
} // namespace lomiri