haiku.git

/*
 * Copyright 2015-2017 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Axel Dörfler, axeld@pinc-software.de
 */


#include <LaunchRoster.h>

#include <Application.h>
#include <String.h>
#include <StringList.h>

#include <launch.h>
#include <LaunchDaemonDefs.h>
#include <LaunchRosterPrivate.h>
#include <MessengerPrivate.h>


using namespace BPrivate;


BLaunchRoster::Private::Private(BLaunchRoster* roster)
	:
	fRoster(roster)
{
}


BLaunchRoster::Private::Private(BLaunchRoster& roster)
	:
	fRoster(&roster)
{
}


status_t
BLaunchRoster::Private::RegisterSessionDaemon(const BMessenger& daemon)
{
	BMessage request(B_REGISTER_SESSION_DAEMON);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK)
		status = request.AddMessenger("daemon", daemon);
	if (status != B_OK)
		return status;

	// send the request
	BMessage result;
	status = fRoster->fMessenger.SendMessage(&request, &result);

	// evaluate the reply
	if (status == B_OK)
		status = result.what;

	return status;
}


// #pragma mark -


BLaunchRoster::BLaunchRoster()
{
	_InitMessenger();
}


BLaunchRoster::~BLaunchRoster()
{
}


status_t
BLaunchRoster::InitCheck() const
{
	return fMessenger.Team() >= 0 ? B_OK : B_ERROR;
}


status_t
BLaunchRoster::GetData(BMessage& data)
{
	if (be_app == NULL)
		return B_BAD_VALUE;

	return GetData(be_app->Signature(), data);
}


status_t
BLaunchRoster::GetData(const char* signature, BMessage& data)
{
	if (signature == NULL || signature[0] == '\0')
		return B_BAD_VALUE;

	BMessage request(B_GET_LAUNCH_DATA);
	status_t status = request.AddString("name", signature);
	if (status == B_OK)
		status = request.AddInt32("user", getuid());
	if (status != B_OK)
		return status;

	return _SendRequest(request, data);
}


port_id
BLaunchRoster::GetPort(const char* name)
{
	if (be_app == NULL)
		return B_BAD_VALUE;

	return GetPort(be_app->Signature(), name);
}


port_id
BLaunchRoster::GetPort(const char* signature, const char* name)
{
	BMessage data;
	status_t status = GetData(signature, data);
	if (status == B_OK) {
		BString fieldName;
		if (name != NULL)
			fieldName << name << "_";
		fieldName << "port";

		port_id port = data.GetInt32(fieldName.String(), B_NAME_NOT_FOUND);
		if (port >= 0)
			return port;
	}

	return -1;
}


status_t
BLaunchRoster::Target(const char* name, const BMessage& data,
	const char* baseName)
{
	return Target(name, &data, baseName);
}


status_t
BLaunchRoster::Target(const char* name, const BMessage* data,
	const char* baseName)
{
	if (name == NULL)
		return B_BAD_VALUE;

	BMessage request(B_LAUNCH_TARGET);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK)
		status = request.AddString("target", name);
	if (status == B_OK && data != NULL && !data->IsEmpty())
		status = request.AddMessage("data", data);
	if (status == B_OK && baseName != NULL)
		status = request.AddString("base target", baseName);
	if (status != B_OK)
		return status;

	return _SendRequest(request);
}


status_t
BLaunchRoster::StopTarget(const char* name, bool force)
{
	if (name == NULL)
		return B_BAD_VALUE;

	BMessage request(B_STOP_LAUNCH_TARGET);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK)
		status = request.AddString("target", name);
	if (status == B_OK)
		status = request.AddBool("force", force);
	if (status != B_OK)
		return status;

	return _SendRequest(request);
}


status_t
BLaunchRoster::Start(const char* name)
{
	if (name == NULL)
		return B_BAD_VALUE;

	BMessage request(B_LAUNCH_JOB);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK)
		status = request.AddString("name", name);
	if (status != B_OK)
		return status;

	return _SendRequest(request);
}


status_t
BLaunchRoster::Stop(const char* name, bool force)
{
	if (name == NULL)
		return B_BAD_VALUE;

	BMessage request(B_STOP_LAUNCH_JOB);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK)
		status = request.AddString("name", name);
	if (status == B_OK)
		status = request.AddBool("force", force);
	if (status != B_OK)
		return status;

	return _SendRequest(request);
}


status_t
BLaunchRoster::SetEnabled(const char* name, bool enable)
{
	if (name == NULL)
		return B_BAD_VALUE;

	BMessage request(B_ENABLE_LAUNCH_JOB);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK)
		status = request.AddString("name", name);
	if (status == B_OK)
		status = request.AddBool("enable", enable);
	if (status != B_OK)
		return status;

	return _SendRequest(request);
}


status_t
BLaunchRoster::StartSession(const char* login)
{
	if (login == NULL)
		return B_BAD_VALUE;

	BMessage request(B_LAUNCH_SESSION);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK)
		status = request.AddString("login", login);
	if (status != B_OK)
		return status;

	return _SendRequest(request);
}


status_t
BLaunchRoster::RegisterEvent(const BMessenger& source, const char* name,
	uint32 flags)
{
	return _UpdateEvent(B_REGISTER_LAUNCH_EVENT, source, name, flags);
}


status_t
BLaunchRoster::UnregisterEvent(const BMessenger& source, const char* name)
{
	return _UpdateEvent(B_UNREGISTER_LAUNCH_EVENT, source, name);
}


status_t
BLaunchRoster::NotifyEvent(const BMessenger& source, const char* name)
{
	return _UpdateEvent(B_NOTIFY_LAUNCH_EVENT, source, name);
}


status_t
BLaunchRoster::ResetStickyEvent(const BMessenger& source, const char* name)
{
	return _UpdateEvent(B_RESET_STICKY_LAUNCH_EVENT, source, name);
}


status_t
BLaunchRoster::GetTargets(BStringList& targets)
{
	BMessage request(B_GET_LAUNCH_TARGETS);
	status_t status = request.AddInt32("user", getuid());
	if (status != B_OK)
		return status;

	// send the request
	BMessage result;
	status = _SendRequest(request, result);
	if (status == B_OK)
		status = result.FindStrings("target", &targets);

	return status;
}


status_t
BLaunchRoster::GetTargetInfo(const char* name, BMessage& info)
{
	return _GetInfo(B_GET_LAUNCH_TARGET_INFO, name, info);
}


status_t
BLaunchRoster::GetJobs(const char* target, BStringList& jobs)
{
	BMessage request(B_GET_LAUNCH_JOBS);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK && target != NULL)
		status = request.AddString("target", target);
	if (status != B_OK)
		return status;

	// send the request
	BMessage result;
	status = _SendRequest(request, result);
	if (status == B_OK)
		status = result.FindStrings("job", &jobs);

	return status;
}


status_t
BLaunchRoster::GetJobInfo(const char* name, BMessage& info)
{
	return _GetInfo(B_GET_LAUNCH_JOB_INFO, name, info);
}


status_t
BLaunchRoster::GetLog(BMessage& info)
{
	return _GetLog(NULL, info);
}


status_t
BLaunchRoster::GetLog(const BMessage& filter, BMessage& info)
{
	return _GetLog(&filter, info);
}


void
BLaunchRoster::_InitMessenger()
{
#ifdef TEST_MODE
	port_id daemonPort = find_port(B_LAUNCH_DAEMON_PORT_NAME);
#else
	// find the launch_daemon port
	port_id daemonPort = BPrivate::get_launch_daemon_port();
#endif
	port_info info;
	if (daemonPort >= 0 && get_port_info(daemonPort, &info) == B_OK) {
		BMessenger::Private(fMessenger).SetTo(info.team, daemonPort,
			B_PREFERRED_TOKEN);
	}
}


status_t
BLaunchRoster::_SendRequest(BMessage& request)
{
	BMessage result;
	return _SendRequest(request, result);
}


status_t
BLaunchRoster::_SendRequest(BMessage& request, BMessage& result)
{
	// Send the request, and evaluate the reply
	status_t status = fMessenger.SendMessage(&request, &result);
	if (status == B_OK)
		status = result.what;

	return status;
}


status_t
BLaunchRoster::_UpdateEvent(uint32 what, const BMessenger& source,
	const char* name, uint32 flags)
{
	if (be_app == NULL || name == NULL || name[0] == '\0')
		return B_BAD_VALUE;

	BMessage request(what);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK)
		status = request.AddMessenger("source", source);
	if (status == B_OK)
		status = request.AddString("owner", be_app->Signature());
	if (status == B_OK)
		status = request.AddString("name", name);
	if (status == B_OK && flags != 0)
		status = request.AddUInt32("flags", flags);
	if (status != B_OK)
		return status;

	return _SendRequest(request);
}


status_t
BLaunchRoster::_GetInfo(uint32 what, const char* name, BMessage& info)
{
	if (name == NULL || name[0] == '\0')
		return B_BAD_VALUE;

	BMessage request(what);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK)
		status = request.AddString("name", name);
	if (status != B_OK)
		return status;

	return _SendRequest(request, info);
}


status_t
BLaunchRoster::_GetLog(const BMessage* filter, BMessage& info)
{
	BMessage request(B_GET_LAUNCH_LOG);
	status_t status = request.AddInt32("user", getuid());
	if (status == B_OK && filter != NULL)
		status = request.AddMessage("filter", filter);
	if (status != B_OK)
		return status;

	return _SendRequest(request, info);
}