haiku.git

// SMTarget.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string>

#include <OS.h>
#include <String.h>
#include <TestShell.h>
#include <TestUtils.h>
#include <cppunit/TestAssert.h>

#include "SMTarget.h"
#include "SMLooper.h"
#include "SMRemoteTargetApp.h"


using namespace std;


// SMTarget

// constructor
SMTarget::SMTarget()
{
}

// destructor
SMTarget::~SMTarget()
{
}

// Init
void
SMTarget::Init(bigtime_t unblockTime, bigtime_t replyDelay)
{
}

// Handler
BHandler *
SMTarget::Handler()
{
	return NULL;
}

// Messenger
BMessenger
SMTarget::Messenger()
{
	return BMessenger();
}

// DeliverySuccess
bool
SMTarget::DeliverySuccess()
{
	return false;
}


// LocalSMTarget

// constructor
LocalSMTarget::LocalSMTarget(bool preferred)
			 : SMTarget(),
			   fHandler(NULL),
			   fLooper(NULL)
{
	// create looper and handler
	fLooper = new SMLooper;
	fLooper->Run();
	if (!preferred) {
		fHandler = new SMHandler;
		CHK(fLooper->Lock());
		fLooper->AddHandler(fHandler);
		fLooper->Unlock();
	}
}

// destructor
LocalSMTarget::~LocalSMTarget()
{
	if (fLooper) {
		fLooper->Lock();
		if (fHandler) {
			fLooper->RemoveHandler(fHandler);
			delete fHandler;
		}
		fLooper->Quit();
	}
}

// Init
void
LocalSMTarget::Init(bigtime_t unblockTime, bigtime_t replyDelay)
{
	fLooper->SetReplyDelay(replyDelay);
	fLooper->BlockUntil(unblockTime);
}

// Handler
BHandler *
LocalSMTarget::Handler()
{
	return fHandler;
}

// Messenger
BMessenger
LocalSMTarget::Messenger()
{
	return BMessenger(fHandler, fLooper);
}

// DeliverySuccess
bool
LocalSMTarget::DeliverySuccess()
{
	return fLooper->DeliverySuccess();
}


// RemoteSMTarget

static const char *kSMRemotePortName = "BMessenger_SMRemoteTarget";

// constructor
RemoteSMTarget::RemoteSMTarget(bool preferred)
			  : SMTarget(),
				fLocalPort(-1),
				fRemotePort(-1),
				fTarget()
{
	// create unused port name
	int32 id = atomic_add(&fID, 1);
	string portName(kSMRemotePortName);
	BString idString;
	idString << id;
	portName += idString.String();
	// create local port
	fLocalPort = create_port(5, portName.c_str());
	CHK(fLocalPort >= 0);
	// execute the remote app
	BString unescapedTestDir(BTestShell::GlobalTestDir());
	unescapedTestDir.CharacterEscape(" \t\n!\"'`$&()?*+{}[]<>|", '\\');
	string remoteApp(unescapedTestDir.String());
	remoteApp += "/SMRemoteTargetApp ";
	remoteApp += portName;
	if (preferred)
		remoteApp += " preferred";
	else
		remoteApp += " specific";
	remoteApp += " &";
	system(remoteApp.c_str());
	// wait for the remote app to send its init data
	smrt_init initData;
	CHK(_GetReply(SMRT_INIT, &initData, sizeof(smrt_init)) == B_OK);
	fRemotePort = initData.port;
	fTarget = initData.messenger;
}

// destructor
RemoteSMTarget::~RemoteSMTarget()
{
	_SendRequest(SMRT_QUIT);
	delete_port(fLocalPort);
}

// Init
void
RemoteSMTarget::Init(bigtime_t unblockTime, bigtime_t replyDelay)
{
	smrt_get_ready data;
	data.unblock_time = unblockTime;
	data.reply_delay = replyDelay;
	CHK(_SendRequest(SMRT_GET_READY, &data, sizeof(smrt_get_ready)) == B_OK);
}

// Messenger
BMessenger
RemoteSMTarget::Messenger()
{
	return fTarget;
}

// DeliverySuccess
bool
RemoteSMTarget::DeliverySuccess()
{
	CHK(_SendRequest(SMRT_DELIVERY_SUCCESS_REQUEST) == B_OK);
	smrt_delivery_success data;
	CHK(_GetReply(SMRT_DELIVERY_SUCCESS_REPLY, &data,
				  sizeof(smrt_delivery_success)) == B_OK);
	return data.success;
}

// _SendRequest
status_t
RemoteSMTarget::_SendRequest(int32 code, const void *buffer, size_t size)
{
	return write_port(fRemotePort, code, buffer, size);
}

// _GetReply
status_t
RemoteSMTarget::_GetReply(int32 expectedCode, void *buffer, size_t size)
{
	status_t error = B_OK;
	int32 code;
	ssize_t readSize = read_port(fLocalPort, &code, buffer, size);
	if (readSize < 0)
		error = readSize;
	else if ((uint32)readSize != size)
		error = B_ERROR;
	else if (code != expectedCode)
		error = B_ERROR;
	return error;
}

// ID
int32 RemoteSMTarget::fID = 0;