2005-11-20 19:24:23 +03:00
|
|
|
/*
|
2009-08-01 02:19:36 +04:00
|
|
|
* Copyright 2005-2009, Haiku Inc. All rights reserved.
|
2005-11-20 19:24:23 +03:00
|
|
|
* Distributed under the terms of the MIT License.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Michael Lotz <mmlr@mlotz.ch>
|
|
|
|
*/
|
2005-11-13 14:31:07 +03:00
|
|
|
#ifndef _MESSAGE_PRIVATE_H_
|
|
|
|
#define _MESSAGE_PRIVATE_H_
|
|
|
|
|
|
|
|
#include <Message.h>
|
|
|
|
#include <Messenger.h>
|
|
|
|
#include <MessengerPrivate.h>
|
|
|
|
#include <TokenSpace.h>
|
|
|
|
|
|
|
|
|
2009-08-01 02:19:36 +04:00
|
|
|
#define MESSAGE_BODY_HASH_TABLE_SIZE 5
|
2005-11-13 14:31:07 +03:00
|
|
|
#define MAX_DATA_PREALLOCATION B_PAGE_SIZE * 10
|
|
|
|
#define MAX_FIELD_PREALLOCATION 50
|
|
|
|
|
|
|
|
|
2006-02-23 12:02:03 +03:00
|
|
|
static const int32 kPortMessageCode = 'pjpp';
|
2006-02-18 15:29:05 +03:00
|
|
|
|
|
|
|
|
2005-11-13 14:31:07 +03:00
|
|
|
enum {
|
|
|
|
MESSAGE_FLAG_VALID = 0x0001,
|
|
|
|
MESSAGE_FLAG_REPLY_REQUIRED = 0x0002,
|
|
|
|
MESSAGE_FLAG_REPLY_DONE = 0x0004,
|
|
|
|
MESSAGE_FLAG_IS_REPLY = 0x0008,
|
|
|
|
MESSAGE_FLAG_WAS_DELIVERED = 0x0010,
|
|
|
|
MESSAGE_FLAG_HAS_SPECIFIERS = 0x0020,
|
2009-08-01 02:19:36 +04:00
|
|
|
MESSAGE_FLAG_WAS_DROPPED = 0x0040,
|
|
|
|
MESSAGE_FLAG_PASS_BY_AREA = 0x0080
|
2005-11-13 14:31:07 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
FIELD_FLAG_VALID = 0x0001,
|
|
|
|
FIELD_FLAG_FIXED_SIZE = 0x0002,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-11-21 01:24:03 +03:00
|
|
|
struct BMessage::field_header {
|
2009-08-01 02:19:36 +04:00
|
|
|
uint16 flags;
|
|
|
|
uint16 name_length;
|
2005-11-13 14:31:07 +03:00
|
|
|
type_code type;
|
2009-08-01 02:19:36 +04:00
|
|
|
uint32 count;
|
|
|
|
uint32 data_size;
|
|
|
|
uint32 offset;
|
2005-11-21 01:24:03 +03:00
|
|
|
int32 next_field;
|
2009-08-01 02:19:36 +04:00
|
|
|
} _PACKED;
|
2005-11-13 14:31:07 +03:00
|
|
|
|
|
|
|
|
2005-11-21 01:24:03 +03:00
|
|
|
struct BMessage::message_header {
|
2005-11-13 14:31:07 +03:00
|
|
|
uint32 format;
|
|
|
|
uint32 what;
|
|
|
|
uint32 flags;
|
|
|
|
|
|
|
|
int32 target;
|
2005-11-21 01:24:03 +03:00
|
|
|
int32 current_specifier;
|
2008-03-09 16:35:41 +03:00
|
|
|
area_id message_area;
|
2005-11-13 14:31:07 +03:00
|
|
|
|
|
|
|
// reply info
|
2005-11-21 01:24:03 +03:00
|
|
|
port_id reply_port;
|
|
|
|
int32 reply_target;
|
|
|
|
team_id reply_team;
|
2005-11-13 14:31:07 +03:00
|
|
|
|
|
|
|
// body info
|
2009-08-01 02:19:36 +04:00
|
|
|
uint32 data_size;
|
|
|
|
uint32 field_count;
|
|
|
|
uint32 hash_table_size;
|
2005-11-21 01:24:03 +03:00
|
|
|
int32 hash_table[MESSAGE_BODY_HASH_TABLE_SIZE];
|
2005-11-13 14:31:07 +03:00
|
|
|
|
|
|
|
/* The hash table does contain indexes into the field list and
|
|
|
|
not direct offsets to the fields. This has the advantage
|
|
|
|
of not needing to update offsets in two locations.
|
|
|
|
The hash table must be reevaluated when we remove a field
|
|
|
|
though.
|
|
|
|
*/
|
2009-08-01 02:19:36 +04:00
|
|
|
} _PACKED;
|
2005-11-13 14:31:07 +03:00
|
|
|
|
|
|
|
|
|
|
|
class BMessage::Private {
|
2005-11-20 19:24:23 +03:00
|
|
|
public:
|
|
|
|
Private(BMessage *msg)
|
2009-08-01 02:19:36 +04:00
|
|
|
:
|
|
|
|
fMessage(msg)
|
2005-11-20 19:24:23 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
Private(BMessage &msg)
|
2009-08-01 02:19:36 +04:00
|
|
|
:
|
|
|
|
fMessage(&msg)
|
2005-11-20 19:24:23 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SetTarget(int32 token)
|
|
|
|
{
|
|
|
|
fMessage->fHeader->target = token;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SetReply(BMessenger messenger)
|
|
|
|
{
|
|
|
|
BMessenger::Private messengerPrivate(messenger);
|
2005-11-21 01:24:03 +03:00
|
|
|
fMessage->fHeader->reply_port = messengerPrivate.Port();
|
|
|
|
fMessage->fHeader->reply_target = messengerPrivate.Token();
|
|
|
|
fMessage->fHeader->reply_team = messengerPrivate.Team();
|
2005-11-20 19:24:23 +03:00
|
|
|
}
|
|
|
|
|
2006-03-12 16:21:08 +03:00
|
|
|
void
|
|
|
|
SetReply(team_id team, port_id port, int32 target)
|
|
|
|
{
|
|
|
|
fMessage->fHeader->reply_port = port;
|
|
|
|
fMessage->fHeader->reply_target = target;
|
|
|
|
fMessage->fHeader->reply_team = team;
|
|
|
|
}
|
|
|
|
|
2005-11-20 19:24:23 +03:00
|
|
|
int32
|
|
|
|
GetTarget()
|
|
|
|
{
|
|
|
|
return fMessage->fHeader->target;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
UsePreferredTarget()
|
|
|
|
{
|
|
|
|
return fMessage->fHeader->target == B_PREFERRED_TOKEN;
|
|
|
|
}
|
|
|
|
|
2006-04-11 01:22:05 +04:00
|
|
|
void
|
|
|
|
SetWasDropped(bool wasDropped)
|
|
|
|
{
|
|
|
|
if (wasDropped)
|
|
|
|
fMessage->fHeader->flags |= MESSAGE_FLAG_WAS_DROPPED;
|
|
|
|
else
|
|
|
|
fMessage->fHeader->flags &= ~MESSAGE_FLAG_WAS_DROPPED;
|
|
|
|
}
|
|
|
|
|
2005-11-20 19:24:23 +03:00
|
|
|
status_t
|
|
|
|
Clear()
|
|
|
|
{
|
|
|
|
return fMessage->_Clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
status_t
|
|
|
|
InitHeader()
|
|
|
|
{
|
|
|
|
return fMessage->_InitHeader();
|
|
|
|
}
|
|
|
|
|
2005-11-21 01:24:03 +03:00
|
|
|
BMessage::message_header*
|
2005-11-20 19:24:23 +03:00
|
|
|
GetMessageHeader()
|
|
|
|
{
|
|
|
|
return fMessage->fHeader;
|
|
|
|
}
|
|
|
|
|
2005-11-21 01:24:03 +03:00
|
|
|
BMessage::field_header*
|
2005-11-20 19:24:23 +03:00
|
|
|
GetMessageFields()
|
|
|
|
{
|
|
|
|
return fMessage->fFields;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8*
|
|
|
|
GetMessageData()
|
|
|
|
{
|
|
|
|
return fMessage->fData;
|
|
|
|
}
|
|
|
|
|
2006-02-18 15:29:05 +03:00
|
|
|
status_t
|
|
|
|
FlattenToArea(message_header **header) const
|
|
|
|
{
|
|
|
|
return fMessage->_FlattenToArea(header);
|
|
|
|
}
|
|
|
|
|
2005-11-20 19:24:23 +03:00
|
|
|
status_t
|
2007-01-26 16:59:56 +03:00
|
|
|
SendMessage(port_id port, team_id portOwner, int32 token,
|
|
|
|
bigtime_t timeout, bool replyRequired, BMessenger &replyTo) const
|
2005-11-20 19:24:23 +03:00
|
|
|
{
|
2007-01-26 16:59:56 +03:00
|
|
|
return fMessage->_SendMessage(port, portOwner, token,
|
2005-11-20 19:24:23 +03:00
|
|
|
timeout, replyRequired, replyTo);
|
|
|
|
}
|
|
|
|
|
|
|
|
status_t
|
|
|
|
SendMessage(port_id port, team_id portOwner, int32 token,
|
|
|
|
BMessage *reply, bigtime_t sendTimeout,
|
|
|
|
bigtime_t replyTimeout) const
|
|
|
|
{
|
|
|
|
return fMessage->_SendMessage(port, portOwner, token,
|
|
|
|
reply, sendTimeout, replyTimeout);
|
|
|
|
}
|
|
|
|
|
|
|
|
// static methods
|
|
|
|
|
|
|
|
static status_t
|
|
|
|
SendFlattenedMessage(void *data, int32 size, port_id port,
|
|
|
|
int32 token, bigtime_t timeout)
|
|
|
|
{
|
|
|
|
return BMessage::_SendFlattenedMessage(data, size,
|
|
|
|
port, token, timeout);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
StaticInit()
|
|
|
|
{
|
|
|
|
BMessage::_StaticInit();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
StaticCleanup()
|
|
|
|
{
|
|
|
|
BMessage::_StaticCleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
StaticCacheCleanup()
|
|
|
|
{
|
|
|
|
BMessage::_StaticCacheCleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
BMessage* fMessage;
|
2005-11-13 14:31:07 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif // _MESSAGE_PRIVATE_H_
|