452 lines
9.3 KiB
C++
452 lines
9.3 KiB
C++
/*
|
|
* Copyright 2001-2015 Haiku, Inc. All rights reserved.
|
|
* Distributed under the terms of the MIT License.
|
|
*
|
|
* Authors:
|
|
* Ingo Weinhold (bonefish@users.sf.net)
|
|
*/
|
|
|
|
|
|
#include <Messenger.h>
|
|
|
|
#include <new>
|
|
#include <stdio.h>
|
|
#include <strings.h>
|
|
|
|
#include <Application.h>
|
|
#include <AutoLocker.h>
|
|
#include <Handler.h>
|
|
#include <Looper.h>
|
|
#include <Message.h>
|
|
#include <OS.h>
|
|
#include <Roster.h>
|
|
|
|
#include <AppMisc.h>
|
|
#include <LaunchRoster.h>
|
|
#include <LooperList.h>
|
|
#include <MessagePrivate.h>
|
|
#include <MessageUtils.h>
|
|
#include <TokenSpace.h>
|
|
|
|
|
|
// debugging
|
|
//#define DBG(x) x
|
|
#define DBG(x)
|
|
#define OUT printf
|
|
|
|
using BPrivate::gDefaultTokens;
|
|
using BPrivate::gLooperList;
|
|
using BPrivate::BLooperList;
|
|
|
|
|
|
BMessenger::BMessenger()
|
|
:
|
|
fPort(-1),
|
|
fHandlerToken(B_NULL_TOKEN),
|
|
fTeam(-1)
|
|
{
|
|
}
|
|
|
|
|
|
BMessenger::BMessenger(const char* signature, team_id team, status_t* result)
|
|
:
|
|
fPort(-1),
|
|
fHandlerToken(B_NULL_TOKEN),
|
|
fTeam(-1)
|
|
{
|
|
_InitData(signature, team, result);
|
|
}
|
|
|
|
|
|
BMessenger::BMessenger(const BHandler* handler, const BLooper* looper,
|
|
status_t* _result)
|
|
:
|
|
fPort(-1),
|
|
fHandlerToken(B_NULL_TOKEN),
|
|
fTeam(-1)
|
|
{
|
|
_InitData(handler, looper, _result);
|
|
}
|
|
|
|
|
|
BMessenger::BMessenger(const BMessenger& other)
|
|
:
|
|
fPort(other.fPort),
|
|
fHandlerToken(other.fHandlerToken),
|
|
fTeam(other.fTeam)
|
|
{
|
|
}
|
|
|
|
|
|
BMessenger::~BMessenger()
|
|
{
|
|
}
|
|
|
|
|
|
// #pragma mark - Target
|
|
|
|
|
|
bool
|
|
BMessenger::IsTargetLocal() const
|
|
{
|
|
return BPrivate::current_team() == fTeam;
|
|
}
|
|
|
|
|
|
BHandler*
|
|
BMessenger::Target(BLooper** _looper) const
|
|
{
|
|
BHandler* handler = NULL;
|
|
if (IsTargetLocal()
|
|
&& (fHandlerToken > B_NULL_TOKEN
|
|
|| fHandlerToken == B_PREFERRED_TOKEN)) {
|
|
gDefaultTokens.GetToken(fHandlerToken, B_HANDLER_TOKEN,
|
|
(void**)&handler);
|
|
if (_looper)
|
|
*_looper = BPrivate::gLooperList.LooperForPort(fPort);
|
|
} else if (_looper)
|
|
*_looper = NULL;
|
|
|
|
return handler;
|
|
}
|
|
|
|
|
|
bool
|
|
BMessenger::LockTarget() const
|
|
{
|
|
BLooper* looper = NULL;
|
|
Target(&looper);
|
|
if (looper != NULL && looper->Lock()) {
|
|
if (looper->fMsgPort == fPort)
|
|
return true;
|
|
|
|
looper->Unlock();
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMessenger::LockTargetWithTimeout(bigtime_t timeout) const
|
|
{
|
|
BLooper* looper = NULL;
|
|
Target(&looper);
|
|
if (looper == NULL)
|
|
return B_BAD_VALUE;
|
|
|
|
status_t result = looper->LockWithTimeout(timeout);
|
|
|
|
if (result == B_OK && looper->fMsgPort != fPort) {
|
|
looper->Unlock();
|
|
return B_BAD_PORT_ID;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// #pragma mark - Message sending
|
|
|
|
|
|
status_t
|
|
BMessenger::SendMessage(uint32 command, BHandler* replyTo) const
|
|
{
|
|
BMessage message(command);
|
|
return SendMessage(&message, replyTo);
|
|
}
|
|
|
|
|
|
status_t
|
|
BMessenger::SendMessage(BMessage* message, BHandler* replyTo,
|
|
bigtime_t timeout) const
|
|
{
|
|
DBG(OUT("BMessenger::SendMessage2(%.4s)\n", (char*)&message->what));
|
|
|
|
status_t result = message != NULL ? B_OK : B_BAD_VALUE;
|
|
if (result == B_OK) {
|
|
BMessenger replyMessenger(replyTo);
|
|
result = SendMessage(message, replyMessenger, timeout);
|
|
}
|
|
|
|
DBG(OUT("BMessenger::SendMessage2() done: %lx\n", result));
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMessenger::SendMessage(BMessage* message, BMessenger replyTo,
|
|
bigtime_t timeout) const
|
|
{
|
|
if (message == NULL)
|
|
return B_BAD_VALUE;
|
|
|
|
return BMessage::Private(message).SendMessage(fPort, fTeam, fHandlerToken,
|
|
timeout, false, replyTo);
|
|
}
|
|
|
|
|
|
status_t
|
|
BMessenger::SendMessage(uint32 command, BMessage* reply) const
|
|
{
|
|
BMessage message(command);
|
|
|
|
return SendMessage(&message, reply);
|
|
}
|
|
|
|
|
|
status_t
|
|
BMessenger::SendMessage(BMessage* message, BMessage* reply,
|
|
bigtime_t deliveryTimeout, bigtime_t replyTimeout) const
|
|
{
|
|
if (message == NULL || reply == NULL)
|
|
return B_BAD_VALUE;
|
|
|
|
status_t result = BMessage::Private(message).SendMessage(fPort, fTeam,
|
|
fHandlerToken, reply, deliveryTimeout, replyTimeout);
|
|
|
|
// map this result for now
|
|
if (result == B_BAD_TEAM_ID)
|
|
result = B_BAD_PORT_ID;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// #pragma mark - Operators and misc
|
|
|
|
|
|
status_t
|
|
BMessenger::SetTo(const char* signature, team_id team)
|
|
{
|
|
status_t result = B_OK;
|
|
_InitData(signature, team, &result);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMessenger::SetTo(const BHandler* handler, const BLooper* looper)
|
|
{
|
|
status_t result = B_OK;
|
|
_InitData(handler, looper, &result);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BMessenger&
|
|
BMessenger::operator=(const BMessenger& other)
|
|
{
|
|
if (this != &other) {
|
|
fPort = other.fPort;
|
|
fHandlerToken = other.fHandlerToken;
|
|
fTeam = other.fTeam;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
bool
|
|
BMessenger::operator==(const BMessenger& other) const
|
|
{
|
|
// Note: The fTeam fields are not compared.
|
|
return fPort == other.fPort && fHandlerToken == other.fHandlerToken;
|
|
}
|
|
|
|
|
|
bool
|
|
BMessenger::IsValid() const
|
|
{
|
|
port_info info;
|
|
return fPort >= 0 && get_port_info(fPort, &info) == B_OK;
|
|
}
|
|
|
|
|
|
team_id
|
|
BMessenger::Team() const
|
|
{
|
|
return fTeam;
|
|
}
|
|
|
|
|
|
uint32
|
|
BMessenger::HashValue() const
|
|
{
|
|
return fPort * 19 + fHandlerToken;
|
|
}
|
|
|
|
|
|
// #pragma mark - Private or reserved
|
|
|
|
|
|
/*! Sets the messenger's team, target looper port and handler token.
|
|
|
|
To target the preferred handler, use \c B_PREFERRED_TOKEN as token.
|
|
|
|
\param team The target's team.
|
|
\param port The target looper port.
|
|
\param token The target handler token.
|
|
*/
|
|
void
|
|
BMessenger::_SetTo(team_id team, port_id port, int32 token)
|
|
{
|
|
fTeam = team;
|
|
fPort = port;
|
|
fHandlerToken = token;
|
|
}
|
|
|
|
|
|
/*! Initializes the BMessenger object's data given the signature and/or
|
|
team ID of a target.
|
|
|
|
When only a signature is given, and multiple instances of the application
|
|
are running it is undeterminate which one is chosen as the target. In case
|
|
only a team ID is passed, the target application is identified uniquely.
|
|
If both are supplied, the application identified by the team ID must have
|
|
a matching signature, otherwise the initilization fails.
|
|
|
|
\param signature The target application's signature. May be \c NULL.
|
|
\param team The target application's team ID. May be < 0.
|
|
\param result An optional pointer to a pre-allocated status_t into which
|
|
the result of the initialization is written.
|
|
*/
|
|
void
|
|
BMessenger::_InitData(const char* signature, team_id team, status_t* _result)
|
|
{
|
|
status_t result = B_OK;
|
|
|
|
// get an app_info
|
|
app_info info;
|
|
if (team < 0) {
|
|
// no team ID given
|
|
if (signature != NULL) {
|
|
// Try existing launch communication data first
|
|
BMessage data;
|
|
if (BLaunchRoster().GetData(signature, data) == B_OK) {
|
|
info.port = data.GetInt32("port", -1);
|
|
team = data.GetInt32("team", -5);
|
|
}
|
|
if (info.port < 0) {
|
|
result = be_roster->GetAppInfo(signature, &info);
|
|
team = info.team;
|
|
// B_ERROR means that no application with the given signature
|
|
// is running. But we are supposed to return B_BAD_VALUE.
|
|
if (result == B_ERROR)
|
|
result = B_BAD_VALUE;
|
|
} else
|
|
info.flags = 0;
|
|
} else
|
|
result = B_BAD_TYPE;
|
|
} else {
|
|
// a team ID is given
|
|
result = be_roster->GetRunningAppInfo(team, &info);
|
|
// Compare the returned signature with the supplied one.
|
|
if (result == B_OK && signature != NULL
|
|
&& strcasecmp(signature, info.signature) != 0) {
|
|
result = B_MISMATCHED_VALUES;
|
|
}
|
|
}
|
|
// check whether the app flags say B_ARGV_ONLY
|
|
if (result == B_OK && (info.flags & B_ARGV_ONLY) != 0) {
|
|
result = B_BAD_TYPE;
|
|
// Set the team ID nevertheless -- that's what Be's implementation
|
|
// does. Don't know, if that is a bug, but at least it doesn't harm.
|
|
fTeam = team;
|
|
}
|
|
// init our members
|
|
if (result == B_OK) {
|
|
fTeam = team;
|
|
fPort = info.port;
|
|
fHandlerToken = B_PREFERRED_TOKEN;
|
|
}
|
|
|
|
// return the result
|
|
if (_result != NULL)
|
|
*_result = result;
|
|
}
|
|
|
|
|
|
/*! Initializes the BMessenger to target the local BHandler and/or BLooper.
|
|
|
|
When a \c NULL handler is supplied, the preferred handler in the given
|
|
looper is targeted. If no looper is supplied the looper the given handler
|
|
belongs to is used -- that means in particular, that the handler must
|
|
already belong to a looper. If both are supplied the handler must actually
|
|
belong to looper.
|
|
|
|
\param handler The target handler. May be \c NULL.
|
|
\param looper The target looper. May be \c NULL.
|
|
\param result An optional pointer to a pre-allocated status_t into which
|
|
the result of the initialization is written.
|
|
*/
|
|
void
|
|
BMessenger::_InitData(const BHandler* handler, const BLooper* looper,
|
|
status_t* _result)
|
|
{
|
|
status_t result = (handler != NULL || looper != NULL) ? B_OK : B_BAD_VALUE;
|
|
if (result == B_OK) {
|
|
if (handler != NULL) {
|
|
// BHandler is given, check/retrieve the looper.
|
|
if (looper != NULL) {
|
|
if (handler->Looper() != looper)
|
|
result = B_MISMATCHED_VALUES;
|
|
} else {
|
|
looper = handler->Looper();
|
|
if (looper == NULL)
|
|
result = B_MISMATCHED_VALUES;
|
|
}
|
|
}
|
|
|
|
// set port, token,...
|
|
if (result == B_OK) {
|
|
AutoLocker<BLooperList> locker(gLooperList);
|
|
if (locker.IsLocked() && gLooperList.IsLooperValid(looper)) {
|
|
fPort = looper->fMsgPort;
|
|
fHandlerToken = handler != NULL
|
|
? _get_object_token_(handler)
|
|
: B_PREFERRED_TOKEN;
|
|
fTeam = looper->Team();
|
|
} else
|
|
result = B_BAD_VALUE;
|
|
}
|
|
}
|
|
|
|
if (_result != NULL)
|
|
*_result = result;
|
|
}
|
|
|
|
|
|
// #pragma mark - Operator functions
|
|
|
|
|
|
bool
|
|
operator<(const BMessenger& _a, const BMessenger& _b)
|
|
{
|
|
BMessenger::Private a(const_cast<BMessenger&>(_a));
|
|
BMessenger::Private b(const_cast<BMessenger&>(_b));
|
|
|
|
// significance:
|
|
// 1. fPort
|
|
// 2. fHandlerToken
|
|
// 3. fPreferredTarget
|
|
// fTeam is insignificant
|
|
return (a.Port() < b.Port()
|
|
|| (a.Port() == b.Port()
|
|
&& (a.Token() < b.Token()
|
|
|| (a.Token() == b.Token()
|
|
&& !a.IsPreferredTarget()
|
|
&& b.IsPreferredTarget()))));
|
|
}
|
|
|
|
|
|
bool
|
|
operator!=(const BMessenger& a, const BMessenger& b)
|
|
{
|
|
return !(a == b);
|
|
}
|