i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* made the dano and r5 message more similar to use (naming).

Browse Source 
* coding style changes to structure naming.
* but no bug fixes yet...


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@15055 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2005-11-20 22:24:03 +00:00
parent 5232a619c1
commit e489029756
7 changed files with 397 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/os/app/Message4.h
+38 -43
View File
@@ -5,7 +5,6 @@
* Authors:
* Michael Lotz <[email protected]>
*/
#ifndef _MESSAGE_H
#define _MESSAGE_H
@@ -23,13 +22,10 @@
#include <AppDefs.h> /* For convenience */
#include <TypeConstants.h> /* For convenience */
class BBlockCache;
class BMessenger;
class BHandler;
class BString;
struct message_header_s;
struct field_header_s;
class BBlockCache;
class BMessenger;
class BHandler;
class BString;
// Private or reserved ---------------------------------------------------------
extern "C" void _msg_cache_cleanup_();
@@ -37,7 +33,6 @@ extern "C" int _init_message_();
extern "C" int _delete_message_();
//------------------------------------------------------------------------------
// Name lengths and Scripting specifiers ---------------------------------------
#define B_FIELD_NAME_LENGTH 255
#define B_PROPERTY_NAME_LENGTH 255
@@ -55,18 +50,15 @@ enum {
B_SPECIFIERS_END = 128
// app-defined specifiers start at B_SPECIFIERS_END + 1
};
//------------------------------------------------------------------------------
class BMessage {
public:
public:
uint32 what;
BMessage();
BMessage(uint32 what);
BMessage(const BMessage &other);
virtual ~BMessage();
virtual ~BMessage();
BMessage &operator=(const BMessage &other);
@@ -265,11 +257,13 @@ virtual ~BMessage();
float FindFloat(const char *, int32 n = 0) const;
double FindDouble(const char *, int32 n = 0) const;
class Private;
class Private;
struct message_header;
struct field_header;
private:
friend class Private;
friend class BMessageQueue;
private:
friend class Private;
friend class BMessageQueue;
status_t _InitCommon();
status_t _InitHeader();
@@ -277,54 +271,55 @@ friend class BMessageQueue;
status_t _ResizeData(int32 offset, int32 change);
uint32 _HashName(const char *name) const;
status_t _FindField(const char *name, type_code type,
field_header_s **result) const;
status_t _AddField(const char *name, type_code type,
bool isFixedSize, field_header_s **result);
status_t _RemoveField(field_header_s *field);
uint32 _HashName(const char* name) const;
status_t _FindField(const char* name, type_code type,
field_header** _result) const;
status_t _AddField(const char* name, type_code type,
bool isFixedSize, field_header** _result);
status_t _RemoveField(field_header* field);
ssize_t _NativeFlattenedSize() const;
status_t _NativeFlatten(char *buffer, ssize_t size) const;
status_t _NativeFlatten(BDataIO *stream, ssize_t *size = NULL) const;
message_header_s*fHeader;
field_header_s *fFields;
uint8 *fData;
private:
message_header* fHeader;
field_header* fFields;
uint8* fData;
mutable BMessage *fOriginal;
mutable BMessage* fOriginal;
// fQueueLink is used by BMessageQueue to build a linked list
BMessage *fQueueLink;
BMessage* fQueueLink;
// fQueueLink is used by BMessageQueue to build a linked list
uint32 fReserved[11];
// deprecated
BMessage(BMessage *a_message);
BMessage(BMessage *message);
virtual void _ReservedMessage1();
virtual void _ReservedMessage2();
virtual void _ReservedMessage3();
virtual void _ReservedMessage1();
virtual void _ReservedMessage2();
virtual void _ReservedMessage3();
status_t _SendMessage(port_id port, int32 token, bigtime_t timeout,
bool replyRequired, BMessenger &replyTo) const;
status_t _SendMessage(port_id port, team_id portOwner,
int32 token, BMessage *reply, bigtime_t sendTimeout,
bigtime_t replyTimeout) const;
static status_t _SendFlattenedMessage(void *data, int32 size,
static status_t _SendFlattenedMessage(void *data, int32 size,
port_id port, int32 token, bigtime_t timeout);
static void _StaticInit();
static void _StaticCleanup();
static void _StaticCacheCleanup();
static int32 _StaticGetCachedReplyPort();
static void _StaticInit();
static void _StaticCleanup();
static void _StaticCacheCleanup();
static int32 _StaticGetCachedReplyPort();
enum { sNumReplyPorts = 3 };
static port_id sReplyPorts[sNumReplyPorts];
static long sReplyPortInUse[sNumReplyPorts];
static int32 sGetCachedReplyPort();
static port_id sReplyPorts[sNumReplyPorts];
static long sReplyPortInUse[sNumReplyPorts];
static int32 sGetCachedReplyPort();
static BBlockCache *sMsgCache;
static BBlockCache* sMsgCache;
};
#endif // _MESSAGE_H
headers/private/app/MessagePrivate4.h
+23 -23
View File
@@ -37,40 +37,40 @@ enum {
};
typedef struct field_header_s {
struct BMessage::field_header {
uint32 flags;
type_code type;
int32 nameLength;
int32 name_length;
int32 count;
ssize_t dataSize;
ssize_t data_size;
ssize_t allocated;
int32 offset;
int32 nextField;
} FieldHeader;
int32 next_field;
};
typedef struct message_header_s {
struct BMessage::message_header {
uint32 format;
uint32 what;
uint32 flags;
ssize_t fieldsSize;
ssize_t dataSize;
ssize_t fieldsAvailable;
ssize_t dataAvailable;
ssize_t fields_size;
ssize_t data_size;
ssize_t fields_available;
ssize_t data_available;
int32 target;
int32 currentSpecifier;
int32 current_specifier;
// reply info
port_id replyPort;
int32 replyTarget;
team_id replyTeam;
port_id reply_port;
int32 reply_target;
team_id reply_team;
// body info
int32 fieldCount;
int32 hashTableSize;
int32 hashTable[MESSAGE_BODY_HASH_TABLE_SIZE];
int32 field_count;
int32 hash_table_size;
int32 hash_table[MESSAGE_BODY_HASH_TABLE_SIZE];
/* The hash table does contain indexes into the field list and
not direct offsets to the fields. This has the advantage
@@ -78,7 +78,7 @@ typedef struct message_header_s {
The hash table must be reevaluated when we remove a field
though.
*/
} MessageHeader;
};
class BMessage::Private {
@@ -103,9 +103,9 @@ class BMessage::Private {
SetReply(BMessenger messenger)
{
BMessenger::Private messengerPrivate(messenger);
fMessage->fHeader->replyPort = messengerPrivate.Port();
fMessage->fHeader->replyTarget = messengerPrivate.Token();
fMessage->fHeader->replyTeam = messengerPrivate.Team();
fMessage->fHeader->reply_port = messengerPrivate.Port();
fMessage->fHeader->reply_target = messengerPrivate.Token();
fMessage->fHeader->reply_team = messengerPrivate.Team();
}
int32
@@ -132,13 +132,13 @@ class BMessage::Private {
return fMessage->_InitHeader();
}
MessageHeader*
BMessage::message_header*
GetMessageHeader()
{
return fMessage->fHeader;
}
FieldHeader*
BMessage::field_header*
GetMessageFields()
{
return fMessage->fFields;
src/kits/app/Message4.cpp
+236 -235
View File
File diff suppressed because it is too large Load Diff
src/kits/app/dano_message.cpp
+1 -1
View File
@@ -80,7 +80,7 @@ pad_to_8(int32 value)
ssize_t
BPrivate::dano_message_size(const char *buffer)
BPrivate::dano_message_flattened_size(const char *buffer)
{
section_header *header = (section_header *)buffer;
src/kits/app/dano_message.h
+16 -2
View File
@@ -1,11 +1,25 @@
/*
* Copyright 2005, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Axel Dörfler, axeld@pinc-software.de
*/
#ifndef DANO_MESSAGE_H
#define DANO_MESSAGE_H
#include <SupportDefs.h>
class BMessage;
class BDataIO;
namespace BPrivate {
status_t unflatten_dano_message(uint32 magic, BDataIO& stream, BMessage& message);
ssize_t dano_message_size(const char* buffer);
status_t unflatten_dano_message(uint32 magic, BDataIO& stream, BMessage& message);
ssize_t dano_message_flattened_size(const char* buffer);
}
#endif // DANO_MESSAGE_H
src/kits/app/r5_message.cpp
+66 -57
View File
@@ -1,3 +1,10 @@
/*
* Copyright 2005, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Michael Lotz <mmlr@mlotz.ch>
*/
#ifdef USING_MESSAGE4
#include <DataIO.h>
@@ -22,13 +29,13 @@ static const uint32 kR5MessageMagic = 'FOB1';
static const uint32 kR5MessageMagicSwapped = '1BOF';
typedef struct r5_message_header_s {
struct r5_message_header {
uint32 magic; // kR5MessageMagic
uint32 checksum;
ssize_t flattenedSize;
ssize_t flattened_size;
int32 what;
uint8 flags;
} _PACKED R5MessageHeader;
} _PACKED;
inline int32
@@ -39,52 +46,54 @@ pad_to_8(int32 value)
ssize_t
R5MessageFlattenedSize(const BMessage *message)
r5_message_flattened_size(const BMessage *message)
{
BMessage::Private messagePrivate((BMessage *)message);
MessageHeader *header = messagePrivate.GetMessageHeader();
ssize_t flattenedSize = sizeof(R5MessageHeader);
BMessage::message_header* header = messagePrivate.GetMessageHeader();
// header size (variable, depending on the flags)
ssize_t flattenedSize = sizeof(r5_message_header);
if (header->target != B_NULL_TOKEN)
flattenedSize += sizeof(int32);
if (header->replyPort >= 0 && header->replyTarget != B_NULL_TOKEN
&& header->replyTeam >= 0) {
// reply info
flattenedSize += sizeof(port_id) + sizeof(int32) + sizeof(team_id);
// big flags
flattenedSize += 4;
if (header->reply_port >= 0 && header->reply_target != B_NULL_TOKEN
&& header->reply_team >= 0) {
// reply info + big flags
flattenedSize += sizeof(port_id) + sizeof(int32) + sizeof(team_id) + 4;
}
// field size
uint8 *data = messagePrivate.GetMessageData();
FieldHeader *field = messagePrivate.GetMessageFields();
for (int32 i = 0; i < header->fieldCount; i++, field++) {
BMessage::field_header* field = messagePrivate.GetMessageFields();
for (int32 i = 0; i < header->field_count; i++, field++) {
// flags and type
flattenedSize += 1 + sizeof(type_code);
// item count
#if 0
bool miniData = field->dataSize <= 255 && field->count <= 255;
#else
// ToDo: we don't know the R5 dataSize yet (padding)
bool miniData = false;
#endif
// item count
if (field->count > 1)
flattenedSize += (miniData ? sizeof(uint8) : sizeof(int32));
flattenedSize += (miniData ? sizeof(uint8) : sizeof(uint32));
// data size
flattenedSize += (miniData ? sizeof(uint8) : sizeof(ssize_t));
flattenedSize += (miniData ? sizeof(uint8) : sizeof(size_t));
// name length and name
flattenedSize += 1 + min_c(field->nameLength - 1, 255);
flattenedSize += 1 + min_c(field->name_length - 1, 255);
// data
if (field->flags & FIELD_FLAG_FIXED_SIZE)
flattenedSize += field->dataSize;
flattenedSize += field->data_size;
else {
uint8 *source = data + field->offset + field->nameLength;
uint8 *source = data + field->offset + field->name_length;
for (int32 i = 0; i < field->count; i++) {
ssize_t itemSize = *(ssize_t *)source + sizeof(ssize_t);
@@ -100,14 +109,14 @@ R5MessageFlattenedSize(const BMessage *message)
status_t
R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
flatten_r5_message(const BMessage *message, char *buffer, ssize_t size)
{
BMessage::Private messagePrivate((BMessage *)message);
MessageHeader *header = messagePrivate.GetMessageHeader();
uint8 *data = messagePrivate.GetMessageData();
BMessage::message_header* header = messagePrivate.GetMessageHeader();
uint8* data = messagePrivate.GetMessageData();
R5MessageHeader *r5header = (R5MessageHeader *)buffer;
uint8 *pointer = (uint8 *)buffer + sizeof(R5MessageHeader);
r5_message_header* r5header = (r5_message_header *)buffer;
uint8* pointer = (uint8 *)buffer + sizeof(r5_message_header);
r5header->magic = kR5MessageMagic;
r5header->what = message->what;
@@ -120,18 +129,18 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
flags |= R5_MESSAGE_FLAG_INCLUDE_TARGET;
}
if (header->replyPort >= 0 && header->replyTarget != B_NULL_TOKEN
&& header->replyTeam >= 0) {
if (header->reply_port >= 0 && header->reply_target != B_NULL_TOKEN
&& header->reply_team >= 0) {
// reply info
*(port_id *)pointer = header->replyPort;
*(port_id *)pointer = header->reply_port;
pointer += sizeof(port_id);
*(int32 *)pointer = header->replyTarget;
*(int32 *)pointer = header->reply_target;
pointer += sizeof(int32);
*(team_id *)pointer = header->replyTeam;
*(team_id *)pointer = header->reply_team;
pointer += sizeof(team_id);
// big flags
*pointer = (header->replyTarget == B_PREFERRED_TOKEN ? 1 : 0);
*pointer = (header->reply_target == B_PREFERRED_TOKEN ? 1 : 0);
pointer++;
*pointer = (header->flags & MESSAGE_FLAG_REPLY_REQUIRED ? 1 : 0);
@@ -155,14 +164,14 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
ssize_t headerSize = (uint32)pointer - (uint32)buffer;
// collect and add the data
FieldHeader *field = messagePrivate.GetMessageFields();
for (int32 i = 0; i < header->fieldCount; i++, field++) {
BMessage::field_header* field = messagePrivate.GetMessageFields();
for (int32 i = 0; i < header->field_count; i++, field++) {
flags = R5_FIELD_FLAG_VALID;
if (field->count == 1)
flags |= R5_FIELD_FLAG_SINGLE_ITEM;
// ToDo: we don't really know the data size now (padding missing)
if (field->dataSize <= 255 && field->count <= 255)
if (field->data_size <= 255 && field->count <= 255)
;//flags |= R5_FIELD_FLAG_MINI_DATA;
if (field->flags & FIELD_FLAG_FIXED_SIZE)
flags |= R5_FIELD_FLAG_FIXED_SIZE;
@@ -186,15 +195,15 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
// we may have to adjust this to account for padding later
uint8 *fieldSize = pointer;
if (flags & R5_FIELD_FLAG_MINI_DATA) {
*pointer = (uint8)field->dataSize;
*pointer = (uint8)field->data_size;
pointer++;
} else {
*(ssize_t *)pointer = field->dataSize;
*(ssize_t *)pointer = field->data_size;
pointer += sizeof(ssize_t);
}
// name
int32 nameLength = min_c(field->nameLength - 1, 255);
int32 nameLength = min_c(field->name_length - 1, 255);
*pointer = (uint8)nameLength;
pointer++;
@@ -202,10 +211,10 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
pointer += nameLength;
// data
uint8 *source = data + field->offset + field->nameLength;
uint8 *source = data + field->offset + field->name_length;
if (flags & R5_FIELD_FLAG_FIXED_SIZE) {
memcpy(pointer, source, field->dataSize);
pointer += field->dataSize;
memcpy(pointer, source, field->data_size);
pointer += field->data_size;
} else {
uint8 *previous = pointer;
for (int32 i = 0; i < field->count; i++) {
@@ -228,7 +237,7 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
pointer++;
// calculate the flattened size from the pointers
r5header->flattenedSize = (uint32)pointer - (uint32)buffer;
r5header->flattened_size = (uint32)pointer - (uint32)buffer;
r5header->checksum = BPrivate::CalculateChecksum((uint8 *)(buffer + 8),
headerSize - 8);
return B_OK;
@@ -236,15 +245,15 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
status_t
R5MessageFlatten(const BMessage *message, BDataIO *stream, ssize_t *_size)
flatten_r5_message(const BMessage *message, BDataIO *stream, ssize_t *_size)
{
// ToDo: This is not very cheap...
ssize_t size = R5MessageFlattenedSize(message);
ssize_t size = r5_message_flattened_size(message);
char *buffer = (char *)malloc(size);
if (!buffer)
return B_NO_MEMORY;
status_t result = R5MessageFlatten(message, buffer, size);
status_t result = flatten_r5_message(message, buffer, size);
if (result < B_OK) {
free(buffer);
return result;
@@ -265,23 +274,23 @@ R5MessageFlatten(const BMessage *message, BDataIO *stream, ssize_t *_size)
status_t
R5MessageUnflatten(BMessage *message, const char *flatBuffer)
unflatten_r5_message(BMessage *message, const char *flatBuffer)
{
R5MessageHeader *r5header = (R5MessageHeader *)flatBuffer;
BMemoryIO stream(flatBuffer + 4, r5header->flattenedSize - 4);
return R5MessageUnflatten(message, &stream);
r5_message_header *r5header = (r5_message_header *)flatBuffer;
BMemoryIO stream(flatBuffer + 4, r5header->flattened_size - 4);
return unflatten_r5_message(message, &stream);
}
status_t
R5MessageUnflatten(BMessage *message, BDataIO *stream)
unflatten_r5_message(BMessage *message, BDataIO *stream)
{
TReadHelper reader(stream);
BMessage::Private messagePrivate(message);
MessageHeader *header = messagePrivate.GetMessageHeader();
BMessage::message_header *header = messagePrivate.GetMessageHeader();
// the stream is already advanced by the size of the "format"
R5MessageHeader r5header;
r5_message_header r5header;
reader(((uint8 *)&r5header) + sizeof(uint32),
sizeof(r5header) - sizeof(uint32));
@@ -294,15 +303,15 @@ R5MessageUnflatten(BMessage *message, BDataIO *stream)
if (r5header.flags & R5_MESSAGE_FLAG_INCLUDE_REPLY) {
// reply info
reader(header->replyPort);
reader(header->replyTarget);
reader(header->replyTeam);
reader(header->reply_port);
reader(header->reply_target);
reader(header->reply_team);
// big flags
uint8 bigFlag;
reader(bigFlag);
if (bigFlag)
header->replyTarget = B_PREFERRED_TOKEN;
header->reply_target = B_PREFERRED_TOKEN;
reader(bigFlag);
if (bigFlag)
src/kits/app/r5_message.h
+17 -6
View File
@@ -1,17 +1,28 @@
/*
* Copyright 2005, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Michael Lotz <mmlr@mlotz.ch>
*/
#ifndef _R5_MESSAGE_H_
#define _R5_MESSAGE_H_
#include <sys/types.h>
class BMessage;
class BDataIO;
namespace BPrivate {
ssize_t R5MessageFlattenedSize(const BMessage *message);
status_t R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size);
status_t R5MessageFlatten(const BMessage *message, BDataIO *stream, ssize_t *size);
status_t R5MessageUnflatten(BMessage *message, const char *flatBuffer);
status_t R5MessageUnflatten(BMessage *message, BDataIO *stream);
ssize_t r5_message_flattened_size(const BMessage *message);
status_t flatten_r5_message(const BMessage *message, char *buffer, ssize_t size);
status_t flatten_r5_message(const BMessage *message, BDataIO *stream, ssize_t *size);
status_t unflatten_r5_message(BMessage *message, const char *flatBuffer);
status_t unflatten_r5_message(BMessage *message, BDataIO *stream);
}
#endif
#endif // _R5_MESSAGE_H_