diff --git a/headers/os/app/Message4.h b/headers/os/app/Message4.h
index bb4c3c390b..70371db750 100644
--- a/headers/os/app/Message4.h
+++ b/headers/os/app/Message4.h
@@ -5,7 +5,6 @@
  * Authors:
  *	Michael Lotz <mmlr@mlotz.ch>
  */
-
 #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
diff --git a/headers/private/app/MessagePrivate4.h b/headers/private/app/MessagePrivate4.h
index 5360b39da2..8624a5d43e 100644
--- a/headers/private/app/MessagePrivate4.h
+++ b/headers/private/app/MessagePrivate4.h
@@ -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;
diff --git a/src/kits/app/Message4.cpp b/src/kits/app/Message4.cpp
index 8890348f46..4527409438 100644
--- a/src/kits/app/Message4.cpp
+++ b/src/kits/app/Message4.cpp
@@ -7,16 +7,12 @@
  */
 
 
-#include <Message.h>
-#include <MessagePrivate.h>
-#include <MessageUtils.h>
 #include "dano_message.h"
 #include "r5_message.h"
 
-#include <ctype.h>
-#include <malloc.h>
-#include <stdio.h>
-#include <string.h>
+#include <Message.h>
+#include <MessagePrivate.h>
+#include <MessageUtils.h>
 
 #include <Application.h>
 #include <AppMisc.h>
@@ -31,6 +27,11 @@
 #include <String.h>
 #include <TokenSpace.h>
 
+#include <ctype.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <string.h>
+
 
 #define DEBUG_FUNCTION_ENTER	//debug_printf("%ld: %s\n", __LINE__, __PRETTY_FUNCTION__);
 
@@ -100,21 +101,21 @@ BMessage::operator=(const BMessage &other)
 	DEBUG_FUNCTION_ENTER;
 	_Clear();
 
-	fHeader = (MessageHeader *)malloc(sizeof(MessageHeader));
-	memcpy(fHeader, other.fHeader, sizeof(MessageHeader));
+	fHeader = (message_header *)malloc(sizeof(message_header));
+	memcpy(fHeader, other.fHeader, sizeof(message_header));
 
-	if (fHeader->fieldsSize > 0) {
-		fFields = (FieldHeader *)malloc(fHeader->fieldsSize);
-		memcpy(fFields, other.fFields, fHeader->fieldsSize);
+	if (fHeader->fields_size > 0) {
+		fFields = (field_header *)malloc(fHeader->fields_size);
+		memcpy(fFields, other.fFields, fHeader->fields_size);
 	}
 
-	if (fHeader->dataSize > 0) {
-		fData = (uint8 *)malloc(other.fHeader->dataSize);
-		memcpy(fData, other.fData, other.fHeader->dataSize);
+	if (fHeader->data_size > 0) {
+		fData = (uint8 *)malloc(other.fHeader->data_size);
+		memcpy(fData, other.fData, other.fHeader->data_size);
 	}
 
-	fHeader->fieldsAvailable = 0;
-	fHeader->dataAvailable = 0;
+	fHeader->fields_available = 0;
+	fHeader->data_available = 0;
 	what = fHeader->what;
 	fQueueLink = other.fQueueLink;
 	return *this;
@@ -168,21 +169,21 @@ status_t
 BMessage::_InitHeader()
 {
 	DEBUG_FUNCTION_ENTER;
-	fHeader = (MessageHeader *)malloc(sizeof(MessageHeader));
-	memset(fHeader, 0, sizeof(MessageHeader));
+	fHeader = (message_header *)malloc(sizeof(message_header));
+	memset(fHeader, 0, sizeof(message_header));
 
 	fHeader->format = kMessageMagic4;
 	fHeader->flags = MESSAGE_FLAG_VALID;
-	fHeader->currentSpecifier = -1;
+	fHeader->current_specifier = -1;
 
 	fHeader->target = B_NULL_TOKEN;
-	fHeader->replyTarget = B_NULL_TOKEN;
-	fHeader->replyPort = -1;
-	fHeader->replyTeam = -1;
+	fHeader->reply_target = B_NULL_TOKEN;
+	fHeader->reply_port = -1;
+	fHeader->reply_team = -1;
 
 	// initializing the hash table to -1 because 0 is a valid index
-	fHeader->hashTableSize = MESSAGE_BODY_HASH_TABLE_SIZE;
-	memset(&fHeader->hashTable, 255, sizeof(fHeader->hashTable));
+	fHeader->hash_table_size = MESSAGE_BODY_HASH_TABLE_SIZE;
+	memset(&fHeader->hash_table, 255, sizeof(fHeader->hash_table));
 	return B_OK;
 }
 
@@ -211,7 +212,7 @@ BMessage::GetInfo(type_code typeRequested, int32 index, char **nameFound,
 {
 	DEBUG_FUNCTION_ENTER;
 	if (typeRequested == B_ANY_TYPE) {
-		if (index >= fHeader->fieldCount)
+		if (index >= fHeader->field_count)
 			return B_BAD_INDEX;
 
 		if (nameFound)
@@ -224,8 +225,8 @@ BMessage::GetInfo(type_code typeRequested, int32 index, char **nameFound,
 	}
 
 	int32 counter = -1;
-	FieldHeader *field = fFields;
-	for (int32 i = 0; i < fHeader->fieldCount; i++, field++) {
+	field_header *field = fFields;
+	for (int32 i = 0; i < fHeader->field_count; i++, field++) {
 		if (field->type == typeRequested)
 			counter++;
 
@@ -255,7 +256,7 @@ BMessage::GetInfo(const char *name, type_code *typeFound, int32 *countFound)
 	if (countFound)
 		*countFound = 0;
 
-	FieldHeader *field = NULL;
+	field_header *field = NULL;
 	status_t result = _FindField(name, B_ANY_TYPE, &field);
 	if (result < B_OK || !field)
 		return result;
@@ -274,7 +275,7 @@ BMessage::GetInfo(const char *name, type_code *typeFound, bool *fixedSize)
 	const
 {
 	DEBUG_FUNCTION_ENTER;
-	FieldHeader *field = NULL;
+	field_header *field = NULL;
 	status_t result = _FindField(name, B_ANY_TYPE, &field);
 	if (result < B_OK || !field)
 		return result;
@@ -293,11 +294,11 @@ BMessage::CountNames(type_code type) const
 {
 	DEBUG_FUNCTION_ENTER;
 	if (type == B_ANY_TYPE)
-		return fHeader->fieldCount;
+		return fHeader->field_count;
 
 	int32 count = 0;
-	FieldHeader *field = fFields;
-	for (int32 i = 0; i < fHeader->fieldCount; i++, field++) {
+	field_header *field = fFields;
+	for (int32 i = 0; i < fHeader->field_count; i++, field++) {
 		if (field->type == type)
 			count++;
 	}
@@ -310,7 +311,7 @@ bool
 BMessage::IsEmpty() const
 {
 	DEBUG_FUNCTION_ENTER;
-	return fHeader->fieldCount == 0;
+	return fHeader->field_count == 0;
 }
 
 
@@ -399,26 +400,26 @@ BMessage::PrintToStream() const
 	printf(" (0x%lx, or %ld)\n", what, what);
 
 	char buffer[1024];
-	FieldHeader *field = fFields;
-	for (int32 i = 0; i < fHeader->fieldCount; i++, field++) {
+	field_header *field = fFields;
+	for (int32 i = 0; i < fHeader->field_count; i++, field++) {
 		value = B_BENDIAN_TO_HOST_INT32(field->type);
 		sprintf(buffer, "    entry %14s, type='%.4s', c=%ld, ",
 			(char *)(fData + field->offset), (char *)&value, field->count);
 
 		ssize_t size = 0;
 		if (field->flags & FIELD_FLAG_FIXED_SIZE)
-			size = field->dataSize / field->count;
+			size = field->data_size / field->count;
 
 		switch (field->type) {
 			case B_RECT_TYPE:
 				print_to_stream_type<BRect>(buffer,
-					(BRect *)(fData + field->offset + field->nameLength),
+					(BRect *)(fData + field->offset + field->name_length),
 					field->count, size);
 				break;
 
 			case B_POINT_TYPE:
 				print_to_stream_type<BPoint>(buffer,
-					(BPoint *)(fData + field->offset + field->nameLength),
+					(BPoint *)(fData + field->offset + field->name_length),
 					field->count, size);
 				break;
 
@@ -427,7 +428,7 @@ BMessage::PrintToStream() const
 				printf("%s", buffer);
 				memset(buffer, ' ', strlen(buffer));
 
-				uint8 *pointer = fData + field->offset + field->nameLength;
+				uint8 *pointer = fData + field->offset + field->name_length;
 				for (int32 i = 0; i < field->count; i++) {
 					if (i > 0) /* indent */
 						printf("%s", buffer);
@@ -443,43 +444,43 @@ BMessage::PrintToStream() const
 
 			case B_INT8_TYPE:
 				print_type<int8>(buffer, "0x%hx (%d \'%.1s\')\n",
-					(int8 *)(fData + field->offset + field->nameLength),
+					(int8 *)(fData + field->offset + field->name_length),
 					field->count, size, B_INT8_TYPE);
 				break;
 
 			case B_INT16_TYPE:
 				print_type<int16>(buffer, "0x%x (%d \'%.2s\')\n",
-					(int16 *)(fData + field->offset + field->nameLength),
+					(int16 *)(fData + field->offset + field->name_length),
 					field->count, size, B_INT16_TYPE);
 				break;
 
 			case B_INT32_TYPE:
 				print_type<int32>(buffer, "0x%lx (%ld \'%.4s\')\n",
-					(int32 *)(fData + field->offset + field->nameLength),
+					(int32 *)(fData + field->offset + field->name_length),
 					field->count, size, B_INT32_TYPE);
 				break;
 
 			case B_INT64_TYPE:
 				print_type<int64>(buffer, "0x%Lx (%Ld \'%.8s\')\n",
-					(int64 *)(fData + field->offset + field->nameLength),
+					(int64 *)(fData + field->offset + field->name_length),
 					field->count, size, B_INT64_TYPE);
 				break;
 
 			case B_BOOL_TYPE:
 				print_type<int8>(buffer, NULL,
-					(int8 *)(fData + field->offset + field->nameLength),
+					(int8 *)(fData + field->offset + field->name_length),
 					field->count, size, B_BOOL_TYPE);
 				break;
 
 			case B_FLOAT_TYPE:
 				print_type<float>(buffer, "%.4f\n",
-					(float *)(fData + field->offset + field->nameLength),
+					(float *)(fData + field->offset + field->name_length),
 					field->count, size, B_FLOAT_TYPE);
 				break;
 
 			case B_DOUBLE_TYPE:
 				print_type<double>(buffer, "%.8f\n",
-					(double *)(fData + field->offset + field->nameLength),
+					(double *)(fData + field->offset + field->name_length),
 					field->count, size, B_DOUBLE_TYPE);
 				break;
 
@@ -487,7 +488,7 @@ BMessage::PrintToStream() const
 				printf("%s", buffer);
 				memset(buffer, ' ', strlen(buffer));
 
-				uint8 *pointer = fData + field->offset + field->nameLength;
+				uint8 *pointer = fData + field->offset + field->name_length;
 				for (int32 i = 0; i < field->count; i++) {
 					if (i > 0) /* indent */
 						printf("%s", buffer);
@@ -524,33 +525,33 @@ BMessage::Rename(const char *oldEntry, const char *newEntry)
 	if (!oldEntry || !newEntry)
 		return B_BAD_VALUE;
 
-	uint32 hash = _HashName(oldEntry) % fHeader->hashTableSize;
-	int32 *nextField = &fHeader->hashTable[hash];
+	uint32 hash = _HashName(oldEntry) % fHeader->hash_table_size;
+	int32 *nextField = &fHeader->hash_table[hash];
 
 	while (*nextField >= 0) {
-		FieldHeader *field = &fFields[*nextField];
+		field_header *field = &fFields[*nextField];
 
 		if (strncmp((const char *)(fData + field->offset), oldEntry,
-			field->nameLength) == 0) {
+			field->name_length) == 0) {
 			// nextField points to the field for oldEntry, save it and unlink
 			int32 index = *nextField;
-			*nextField = field->nextField;
-			field->nextField = -1;
+			*nextField = field->next_field;
+			field->next_field = -1;
 
-			hash = _HashName(newEntry) % fHeader->hashTableSize;
-			nextField = &fHeader->hashTable[hash];
+			hash = _HashName(newEntry) % fHeader->hash_table_size;
+			nextField = &fHeader->hash_table[hash];
 			while (*nextField >= 0)
-				nextField = &fFields[*nextField].nextField;
+				nextField = &fFields[*nextField].next_field;
 			*nextField = index;
 
-			int32 oldLength = field->nameLength;
-			field->nameLength = strlen(newEntry) + 1;
-			_ResizeData(field->offset, field->nameLength - oldLength);
-			memcpy(fData + field->offset, newEntry, field->nameLength);
+			int32 oldLength = field->name_length;
+			field->name_length = strlen(newEntry) + 1;
+			_ResizeData(field->offset, field->name_length - oldLength);
+			memcpy(fData + field->offset, newEntry, field->name_length);
 			return B_OK;
 		}
 
-		nextField = &field->nextField;
+		nextField = &field->next_field;
 	}
 
 	return B_NAME_NOT_FOUND;
@@ -579,7 +580,7 @@ BMessage::IsSourceRemote() const
 {
 	DEBUG_FUNCTION_ENTER;
 	return (fHeader->flags & MESSAGE_FLAG_WAS_DELIVERED)
-		&& (fHeader->replyTeam != BPrivate::current_team());
+		&& (fHeader->reply_team != BPrivate::current_team());
 }
 
 
@@ -589,8 +590,8 @@ BMessage::ReturnAddress() const
 	DEBUG_FUNCTION_ENTER;
 	if (fHeader->flags & MESSAGE_FLAG_WAS_DELIVERED) {
 		BMessenger messenger;
-		BMessenger::Private(messenger).SetTo(fHeader->replyTeam,
-			fHeader->replyPort, fHeader->replyTarget);
+		BMessenger::Private(messenger).SetTo(fHeader->reply_team,
+			fHeader->reply_port, fHeader->reply_target);
 		return messenger;
 	}
 
@@ -660,8 +661,8 @@ BMessage::SendReply(BMessage *reply, BMessenger replyTo, bigtime_t timeout)
 	DEBUG_FUNCTION_ENTER;
 	BMessenger messenger;
 	BMessenger::Private messengerPrivate(messenger);
-	messengerPrivate.SetTo(fHeader->replyTeam, fHeader->replyPort,
-		fHeader->replyTarget);
+	messengerPrivate.SetTo(fHeader->reply_team, fHeader->reply_port,
+		fHeader->reply_target);
 
 	if (fHeader->flags & MESSAGE_FLAG_REPLY_REQUIRED) {
 		if (fHeader->flags & MESSAGE_FLAG_REPLY_DONE)
@@ -711,8 +712,8 @@ BMessage::SendReply(BMessage *reply, BMessage *replyToReply,
 	DEBUG_FUNCTION_ENTER;
 	BMessenger messenger;
 	BMessenger::Private messengerPrivate(messenger);
-	messengerPrivate.SetTo(fHeader->replyTeam, fHeader->replyPort,
-		fHeader->replyTarget);
+	messengerPrivate.SetTo(fHeader->reply_team, fHeader->reply_port,
+		fHeader->reply_target);
 
 	if (fHeader->flags & MESSAGE_FLAG_REPLY_REQUIRED) {
 		if (fHeader->flags & MESSAGE_FLAG_REPLY_DONE)
@@ -753,7 +754,7 @@ BMessage::FlattenedSize() const
 {
 	DEBUG_FUNCTION_ENTER;
 	//return _NativeFlattenedSize();
-	return BPrivate::R5MessageFlattenedSize(this);
+	return BPrivate::r5_message_flattened_size(this);
 }
 
 
@@ -762,7 +763,7 @@ BMessage::Flatten(char *buffer, ssize_t size) const
 {
 	DEBUG_FUNCTION_ENTER;
 	//return _NativeFlatten(buffer, size);
-	return BPrivate::R5MessageFlatten(this, buffer, size);
+	return BPrivate::flatten_r5_message(this, buffer, size);
 }
 
 
@@ -771,7 +772,7 @@ BMessage::Flatten(BDataIO *stream, ssize_t *size) const
 {
 	DEBUG_FUNCTION_ENTER;
 	//return _NativeFlatten(stream, size);
-	return BPrivate::R5MessageFlatten(this, stream, size);
+	return BPrivate::flatten_r5_message(this, stream, size);
 }
 
 
@@ -779,7 +780,7 @@ ssize_t
 BMessage::_NativeFlattenedSize() const
 {
 	DEBUG_FUNCTION_ENTER;
-	return sizeof(MessageHeader) + fHeader->fieldsSize + fHeader->dataSize;
+	return sizeof(message_header) + fHeader->fields_size + fHeader->data_size;
 }
 
 
@@ -796,16 +797,16 @@ BMessage::_NativeFlatten(char *buffer, ssize_t size) const
 	/* we have to sync the what code as it is a public member */
 	fHeader->what = what;
 
-	memcpy(buffer, fHeader, min_c(sizeof(MessageHeader), (size_t)size));
-	buffer += sizeof(MessageHeader);
-	size -= sizeof(MessageHeader);
+	memcpy(buffer, fHeader, min_c(sizeof(message_header), (size_t)size));
+	buffer += sizeof(message_header);
+	size -= sizeof(message_header);
 
-	memcpy(buffer, fFields, min_c(fHeader->fieldsSize, size));
-	buffer += fHeader->fieldsSize;
-	size -= fHeader->fieldsSize;
+	memcpy(buffer, fFields, min_c(fHeader->fields_size, size));
+	buffer += fHeader->fields_size;
+	size -= fHeader->fields_size;
 
-	memcpy(buffer, fData, min_c(fHeader->dataSize, size));
-	if (size >= fHeader->dataSize)
+	memcpy(buffer, fData, min_c(fHeader->data_size, size));
+	if (size >= fHeader->data_size)
 		return B_OK;
 
 	return B_NO_MEMORY;
@@ -825,21 +826,21 @@ BMessage::_NativeFlatten(BDataIO *stream, ssize_t *size) const
 	/* we have to sync the what code as it is a public member */
 	fHeader->what = what;
 
-	ssize_t result1 = stream->Write(fHeader, sizeof(MessageHeader));
-	if (result1 != sizeof(MessageHeader))
+	ssize_t result1 = stream->Write(fHeader, sizeof(message_header));
+	if (result1 != sizeof(message_header))
 		return (result1 >= 0 ? B_ERROR : result1);
 
 	ssize_t result2 = 0;
-	if (fHeader->fieldsSize > 0) {
-		stream->Write(fFields, fHeader->fieldsSize);
-		if (result2 != fHeader->fieldsSize)
+	if (fHeader->fields_size > 0) {
+		stream->Write(fFields, fHeader->fields_size);
+		if (result2 != fHeader->fields_size)
 			return (result2 >= 0 ? B_ERROR : result2);
 	}
 
 	ssize_t result3 = 0;
-	if (fHeader->dataSize > 0) {
-		stream->Write(fData, fHeader->dataSize);
-		if (result3 != fHeader->dataSize)
+	if (fHeader->data_size > 0) {
+		stream->Write(fData, fHeader->data_size);
+		if (result3 != fHeader->data_size)
 			return (result3 >= 0 ? B_ERROR : result3);
 	}
 
@@ -870,11 +871,11 @@ BMessage::Unflatten(const char *flatBuffer)
 		}
 
 		if (format == kMessageMagicR5 || format == kMessageMagicR5Swapped)
-			return BPrivate::R5MessageUnflatten(this, flatBuffer);
+			return BPrivate::unflatten_r5_message(this, flatBuffer);
 
 		if (format == kMessageMagicDano || format == kMessageMagicDanoSwapped) {
 			BMemoryIO stream(flatBuffer + sizeof(uint32),
-				BPrivate::dano_message_size(flatBuffer));
+				BPrivate::dano_message_flattened_size(flatBuffer));
 			return BPrivate::unflatten_dano_message(format, stream, *this);
 		}
 
@@ -884,12 +885,12 @@ BMessage::Unflatten(const char *flatBuffer)
 	// native message unflattening
 
 	free(fHeader);
-	fHeader = (MessageHeader *)malloc(sizeof(MessageHeader));
+	fHeader = (message_header *)malloc(sizeof(message_header));
 	if (!fHeader)
 		return B_NO_MEMORY;
 
-	memcpy(fHeader, flatBuffer, sizeof(MessageHeader));
-	flatBuffer += sizeof(MessageHeader);
+	memcpy(fHeader, flatBuffer, sizeof(message_header));
+	flatBuffer += sizeof(message_header);
 
 	/* ToDo: better message validation (checksum) */
 	if (fHeader->format != kMessageMagic4 ||
@@ -901,27 +902,27 @@ BMessage::Unflatten(const char *flatBuffer)
 
 	free(fFields);
 	fFields = NULL;
-	if (fHeader->fieldsSize > 0) {
-		fFields = (FieldHeader *)malloc(fHeader->fieldsSize);
+	if (fHeader->fields_size > 0) {
+		fFields = (field_header *)malloc(fHeader->fields_size);
 		if (!fFields)
 			return B_NO_MEMORY;
 
-		memcpy(fFields, flatBuffer, fHeader->fieldsSize);
-		flatBuffer += fHeader->fieldsSize;
+		memcpy(fFields, flatBuffer, fHeader->fields_size);
+		flatBuffer += fHeader->fields_size;
 	}
 
 	free(fData);
 	fData = NULL;
-	if (fHeader->dataSize > 0) {
-		fData = (uint8 *)malloc(fHeader->dataSize);
+	if (fHeader->data_size > 0) {
+		fData = (uint8 *)malloc(fHeader->data_size);
 		if (!fData)
 			return B_NO_MEMORY;
 
-		memcpy(fData, flatBuffer, fHeader->dataSize);
+		memcpy(fData, flatBuffer, fHeader->data_size);
 	}
 
-	fHeader->fieldsAvailable = 0;
-	fHeader->dataAvailable = 0;
+	fHeader->fields_available = 0;
+	fHeader->data_available = 0;
 	what = fHeader->what;
 	return B_OK;
 }
@@ -938,7 +939,7 @@ BMessage::Unflatten(BDataIO *stream)
 	stream->Read(&format, sizeof(uint32));
 	if (format != kMessageMagic4) {
 		if (format == kMessageMagicR5 || format == kMessageMagicR5Swapped)
-			return BPrivate::R5MessageUnflatten(this, stream);
+			return BPrivate::unflatten_r5_message(this, stream);
 
 		if (format == kMessageMagicDano || format == kMessageMagicDanoSwapped)
 			return BPrivate::unflatten_dano_message(format, *stream, *this);
@@ -949,15 +950,15 @@ BMessage::Unflatten(BDataIO *stream)
 	// native message unflattening
 
 	free(fHeader);
-	fHeader = (MessageHeader *)malloc(sizeof(MessageHeader));
+	fHeader = (message_header *)malloc(sizeof(message_header));
 	if (!fHeader)
 		return B_NO_MEMORY;
 
 	fHeader->format = format;
 	uint8 *header = (uint8 *)fHeader;
 	ssize_t result = stream->Read(header + sizeof(uint32),
-		sizeof(MessageHeader) - sizeof(uint32));
-	if (result != sizeof(MessageHeader) - sizeof(uint32)) {
+		sizeof(message_header) - sizeof(uint32));
+	if (result != sizeof(message_header) - sizeof(uint32)) {
 		_Clear();
 		_InitHeader();
 		return (result >= 0 ? B_ERROR : result);
@@ -973,13 +974,13 @@ BMessage::Unflatten(BDataIO *stream)
 
 	free(fFields);
 	fFields = NULL;
-	if (fHeader->fieldsSize > 0) {
-		fFields = (FieldHeader *)malloc(fHeader->fieldsSize);
+	if (fHeader->fields_size > 0) {
+		fFields = (field_header *)malloc(fHeader->fields_size);
 		if (!fFields)
 			return B_NO_MEMORY;
 
-		result = stream->Read(fFields, fHeader->fieldsSize);
-		if (result != fHeader->fieldsSize) {
+		result = stream->Read(fFields, fHeader->fields_size);
+		if (result != fHeader->fields_size) {
 			_Clear();
 			_InitHeader();
 			return (result >= 0 ? B_ERROR : result);
@@ -988,21 +989,21 @@ BMessage::Unflatten(BDataIO *stream)
 
 	free(fData);
 	fData = NULL;
-	if (fHeader->dataSize > 0) {
-		fData = (uint8 *)malloc(fHeader->dataSize);
+	if (fHeader->data_size > 0) {
+		fData = (uint8 *)malloc(fHeader->data_size);
 		if (!fData)
 			return B_NO_MEMORY;
 
-		result = stream->Read(fData, fHeader->dataSize);
-		if (result != fHeader->dataSize) {
+		result = stream->Read(fData, fHeader->data_size);
+		if (result != fHeader->data_size) {
 			_Clear();
 			_InitHeader();
 			return (result >= 0 ? B_ERROR : result);
 		}
 	}
 
-	fHeader->fieldsAvailable = 0;
-	fHeader->dataAvailable = 0;
+	fHeader->fields_available = 0;
+	fHeader->data_available = 0;
 	what = fHeader->what;
 	return B_OK;
 }
@@ -1086,7 +1087,7 @@ BMessage::AddSpecifier(const BMessage *specifier)
 	if (result < B_OK)
 		return result;
 
-	fHeader->currentSpecifier++;
+	fHeader->current_specifier++;
 	fHeader->flags |= MESSAGE_FLAG_HAS_SPECIFIERS;
 	return B_OK;
 }
@@ -1108,7 +1109,7 @@ BMessage::SetCurrentSpecifier(int32 index)
 	if (index > count)
 		return B_BAD_INDEX;
 
-	fHeader->currentSpecifier = index;
+	fHeader->current_specifier = index;
 	return B_OK;
 }
 
@@ -1118,15 +1119,15 @@ BMessage::GetCurrentSpecifier(int32 *index, BMessage *specifier, int32 *what,
 	const char **property) const
 {
 	DEBUG_FUNCTION_ENTER;
-	if (fHeader->currentSpecifier < 0
+	if (fHeader->current_specifier < 0
 		|| !(fHeader->flags & MESSAGE_FLAG_WAS_DELIVERED))
 		return B_BAD_SCRIPT_SYNTAX;
 
 	if (index)
-		*index = fHeader->currentSpecifier;
+		*index = fHeader->current_specifier;
 
 	if (specifier) {
-		if (FindMessage(B_SPECIFIER_ENTRY, fHeader->currentSpecifier,
+		if (FindMessage(B_SPECIFIER_ENTRY, fHeader->current_specifier,
 			specifier) < B_OK)
 			return B_BAD_SCRIPT_SYNTAX;
 
@@ -1155,12 +1156,12 @@ status_t
 BMessage::PopSpecifier()
 {
 	DEBUG_FUNCTION_ENTER;
-	if (fHeader->currentSpecifier < 0 ||
+	if (fHeader->current_specifier < 0 ||
 		!(fHeader->flags & MESSAGE_FLAG_WAS_DELIVERED))
 		return B_BAD_VALUE;
 
-	if (fHeader->currentSpecifier >= 0)
-		fHeader->currentSpecifier--;
+	if (fHeader->current_specifier >= 0)
+		fHeader->current_specifier--;
 
 	return B_OK;
 }
@@ -1173,54 +1174,54 @@ BMessage::_ResizeData(int32 offset, int32 change)
 		return B_OK;
 
 	/* optimize for the most usual case: appending data */
-	if (offset < fHeader->dataSize) {
-		FieldHeader *field = fFields;
-		for (int32 i = 0; i < fHeader->fieldCount; i++, field++) {
+	if (offset < fHeader->data_size) {
+		field_header *field = fFields;
+		for (int32 i = 0; i < fHeader->field_count; i++, field++) {
 			if (field->offset >= offset)
 				field->offset += change;
 		}
 	}
 
 	if (change > 0) {
-		if (fHeader->dataAvailable >= change) {
-			if (offset < fHeader->dataSize) {
-				ssize_t length = fHeader->dataSize - offset;
+		if (fHeader->data_available >= change) {
+			if (offset < fHeader->data_size) {
+				ssize_t length = fHeader->data_size - offset;
 				memmove(fData + offset + change, fData + offset, length);
 			}
 
-			fHeader->dataAvailable -= change;
-			fHeader->dataSize += change;
+			fHeader->data_available -= change;
+			fHeader->data_size += change;
 			return B_OK;
 		}
 
-		ssize_t size = fHeader->dataSize * 2;
-		size = min_c(size, fHeader->dataSize + MAX_DATA_PREALLOCATION);
-		size = max_c(size, fHeader->dataSize + change);
+		ssize_t size = fHeader->data_size * 2;
+		size = min_c(size, fHeader->data_size + MAX_DATA_PREALLOCATION);
+		size = max_c(size, fHeader->data_size + change);
 
 		fData = (uint8 *)realloc(fData, size);
 		if (!fData)
 			return B_NO_MEMORY;
 
-		if (offset < fHeader->dataSize) {
+		if (offset < fHeader->data_size) {
 			memmove(fData + offset + change, fData + offset,
-				fHeader->dataSize - offset - change);
+				fHeader->data_size - offset - change);
 		}
 
-		fHeader->dataSize += change;
-		fHeader->dataAvailable = size - fHeader->dataSize;
+		fHeader->data_size += change;
+		fHeader->data_available = size - fHeader->data_size;
 	} else {
-		ssize_t size = fHeader->dataSize;
+		ssize_t size = fHeader->data_size;
 		memmove(fData + offset, fData + offset - change, size - offset + change);
-		fHeader->dataSize += change;
-		fHeader->dataAvailable -= change;
+		fHeader->data_size += change;
+		fHeader->data_available -= change;
 
-		if (fHeader->dataAvailable > MAX_DATA_PREALLOCATION) {
+		if (fHeader->data_available > MAX_DATA_PREALLOCATION) {
 			ssize_t available = MAX_DATA_PREALLOCATION / 2;
-			fData = (uint8 *)realloc(fData, fHeader->dataSize + available);
+			fData = (uint8 *)realloc(fData, fHeader->data_size + available);
 			if (!fData)
 				return B_NO_MEMORY;
 
-			fHeader->dataAvailable = available;
+			fHeader->data_available = available;
 		}
 	}
 
@@ -1245,7 +1246,7 @@ BMessage::_HashName(const char *name) const
 
 
 status_t
-BMessage::_FindField(const char *name, type_code type, FieldHeader **result) const
+BMessage::_FindField(const char *name, type_code type, field_header **result) const
 {
 	if (!name)
 		return B_BAD_VALUE;
@@ -1253,14 +1254,14 @@ BMessage::_FindField(const char *name, type_code type, FieldHeader **result) con
 	if (!fHeader || !fFields || !fData)
 		return B_NAME_NOT_FOUND;
 
-	uint32 hash = _HashName(name) % fHeader->hashTableSize;
-	int32 nextField = fHeader->hashTable[hash];
+	uint32 hash = _HashName(name) % fHeader->hash_table_size;
+	int32 nextField = fHeader->hash_table[hash];
 
 	while (nextField >= 0) {
-		FieldHeader *field = &fFields[nextField];
+		field_header *field = &fFields[nextField];
 
 		if (strncmp((const char *)(fData + field->offset), name,
-			field->nameLength) == 0) {
+			field->name_length) == 0) {
 			if (type != B_ANY_TYPE && field->type != type)
 				return B_BAD_TYPE;
 
@@ -1268,7 +1269,7 @@ BMessage::_FindField(const char *name, type_code type, FieldHeader **result) con
 			return B_OK;
 		}
 
-		nextField = field->nextField;
+		nextField = field->next_field;
 	}
 
 	return B_NAME_NOT_FOUND;
@@ -1277,92 +1278,92 @@ BMessage::_FindField(const char *name, type_code type, FieldHeader **result) con
 
 status_t
 BMessage::_AddField(const char *name, type_code type, bool isFixedSize,
-	FieldHeader **result)
+	field_header **result)
 {
 	if (!fHeader)
 		return B_ERROR;
 
-	if (fHeader->fieldsAvailable <= 0) {
-		int32 count = fHeader->fieldCount * 2 + 1;
-		count = min_c(count, fHeader->fieldCount + MAX_FIELD_PREALLOCATION);
+	if (fHeader->fields_available <= 0) {
+		int32 count = fHeader->field_count * 2 + 1;
+		count = min_c(count, fHeader->field_count + MAX_FIELD_PREALLOCATION);
 
-		fFields = (FieldHeader *)realloc(fFields, count * sizeof(FieldHeader));
+		fFields = (field_header *)realloc(fFields, count * sizeof(field_header));
 		if (!fFields)
 			return B_NO_MEMORY;
 
-		fHeader->fieldsAvailable = count - fHeader->fieldCount;
+		fHeader->fields_available = count - fHeader->field_count;
 	}
 
-	uint32 hash = _HashName(name) % fHeader->hashTableSize;
+	uint32 hash = _HashName(name) % fHeader->hash_table_size;
 
-	int32 *nextField = &fHeader->hashTable[hash];
+	int32 *nextField = &fHeader->hash_table[hash];
 	while (*nextField >= 0)
-		nextField = &fFields[*nextField].nextField;
-	*nextField = fHeader->fieldCount;
+		nextField = &fFields[*nextField].next_field;
+	*nextField = fHeader->field_count;
 
-	FieldHeader *field = &fFields[fHeader->fieldCount];
+	field_header *field = &fFields[fHeader->field_count];
 	field->type = type;
 	field->flags = FIELD_FLAG_VALID;
 	if (isFixedSize)
 		field->flags |= FIELD_FLAG_FIXED_SIZE;
 
 	field->count = 0;
-	field->dataSize = 0;
+	field->data_size = 0;
 	field->allocated = 0;
-	field->nextField = -1;
-	field->offset = fHeader->dataSize;
-	field->nameLength = strlen(name) + 1;
-	_ResizeData(field->offset, field->nameLength);
-	memcpy(fData + field->offset, name, field->nameLength);
+	field->next_field = -1;
+	field->offset = fHeader->data_size;
+	field->name_length = strlen(name) + 1;
+	_ResizeData(field->offset, field->name_length);
+	memcpy(fData + field->offset, name, field->name_length);
 
-	fHeader->fieldsAvailable--;
-	fHeader->fieldsSize += sizeof(FieldHeader);
-	fHeader->fieldCount++;
+	fHeader->fields_available--;
+	fHeader->fields_size += sizeof(field_header);
+	fHeader->field_count++;
 	*result = field;
 	return B_OK;
 }
 
 
 status_t
-BMessage::_RemoveField(FieldHeader *field)
+BMessage::_RemoveField(field_header *field)
 {
-	int32 index = ((uint8 *)field - (uint8 *)fFields) / sizeof(FieldHeader);
-	int32 nextField = field->nextField;
+	int32 index = ((uint8 *)field - (uint8 *)fFields) / sizeof(field_header);
+	int32 nextField = field->next_field;
 	if (nextField > index)
 		nextField--;
 
-	int32 *value = fHeader->hashTable;
-	for (int32 i = 0; i < fHeader->hashTableSize; i++, value++) {
+	int32 *value = fHeader->hash_table;
+	for (int32 i = 0; i < fHeader->hash_table_size; i++, value++) {
 		if (*value > index)
 			*value -= 1;
 		else if (*value == index)
 			*value = nextField;
 	}
 
-	FieldHeader *other = fFields;
-	for (int32 i = 0; i < fHeader->fieldCount; i++, other++) {
-		if (other->nextField > index)
-			other->nextField--;
-		else if (other->nextField == index)
-			other->nextField = nextField;
+	field_header *other = fFields;
+	for (int32 i = 0; i < fHeader->field_count; i++, other++) {
+		if (other->next_field > index)
+			other->next_field--;
+		else if (other->next_field == index)
+			other->next_field = nextField;
 	}
 
-	_ResizeData(field->offset, -(field->dataSize + field->nameLength));
+	_ResizeData(field->offset, -(field->data_size + field->name_length));
 
-	ssize_t size = fHeader->fieldsSize - (index + 1) * sizeof(FieldHeader);
+	ssize_t size = fHeader->fields_size - (index + 1) * sizeof(field_header);
 	memmove(fFields + index, fFields + index + 1, size);
-	fHeader->fieldsSize -= sizeof(FieldHeader);
-	fHeader->fieldCount--;
-	fHeader->fieldsAvailable++;
+	fHeader->fields_size -= sizeof(field_header);
+	fHeader->field_count--;
+	fHeader->fields_available++;
 
-	if (fHeader->fieldsAvailable > MAX_FIELD_PREALLOCATION) {
+	if (fHeader->fields_available > MAX_FIELD_PREALLOCATION) {
 		ssize_t available = MAX_FIELD_PREALLOCATION / 2;
-		fFields = (FieldHeader *)realloc(fFields, fHeader->fieldsSize
-			+ available * sizeof(FieldHeader));
+		fFields = (field_header *)realloc(fFields, fHeader->fields_size
+			+ available * sizeof(field_header));
 		if (!fFields)
 			return B_NO_MEMORY;
 
-		fHeader->fieldsAvailable = available;
+		fHeader->fields_available = available;
 	}
 
 	return B_OK;
@@ -1377,7 +1378,7 @@ BMessage::AddData(const char *name, type_code type, const void *data,
 	if (numBytes <= 0 || !data)
 		return B_BAD_VALUE;
 
-	FieldHeader *field = NULL;
+	field_header *field = NULL;
 	status_t result = _FindField(name, type, &field);
 	if (result == B_NAME_NOT_FOUND)
 		result = _AddField(name, type, isFixedSize, &field);
@@ -1385,23 +1386,23 @@ BMessage::AddData(const char *name, type_code type, const void *data,
 	if (result < B_OK || !field)
 		return result;
 
-	uint32 offset = field->offset + field->nameLength + field->dataSize;
+	uint32 offset = field->offset + field->name_length + field->data_size;
 	if (field->flags & FIELD_FLAG_FIXED_SIZE) {
 		if (field->count) {
-			ssize_t size = field->dataSize / field->count;
+			ssize_t size = field->data_size / field->count;
 			if (size != numBytes)
 				return B_BAD_VALUE;
 		}
 
 		_ResizeData(offset, numBytes);
 		memcpy(fData + offset, data, numBytes);
-		field->dataSize += numBytes;
+		field->data_size += numBytes;
 	} else {
 		int32 change = numBytes + sizeof(numBytes);
 		_ResizeData(offset, change);
 		memcpy(fData + offset, &numBytes, sizeof(numBytes));
 		memcpy(fData + offset + sizeof(numBytes), data, numBytes);
-		field->dataSize += change;
+		field->data_size += change;
 	}
 
 	field->count++;
@@ -1416,7 +1417,7 @@ BMessage::RemoveData(const char *name, int32 index)
 	if (index < 0)
 		return B_BAD_VALUE;
 
-	FieldHeader *field = NULL;
+	field_header *field = NULL;
 	status_t result = _FindField(name, B_ANY_TYPE, &field);
 
 	if (result < B_OK)
@@ -1431,11 +1432,11 @@ BMessage::RemoveData(const char *name, int32 index)
 	if (field->count == 1)
 		return _RemoveField(field);
 
-	uint32 offset = field->offset + field->nameLength;
+	uint32 offset = field->offset + field->name_length;
 	if (field->flags & FIELD_FLAG_FIXED_SIZE) {
-		ssize_t size = field->dataSize / field->count;
+		ssize_t size = field->data_size / field->count;
 		_ResizeData(offset + index * size, -size);
-		field->dataSize -= size;
+		field->data_size -= size;
 	} else {
 		uint8 *pointer = fData + offset;
 
@@ -1446,7 +1447,7 @@ BMessage::RemoveData(const char *name, int32 index)
 
 		ssize_t currentSize = *(ssize_t *)pointer + sizeof(ssize_t);
 		_ResizeData(offset, -currentSize);
-		field->dataSize -= currentSize;
+		field->data_size -= currentSize;
 	}
 
 	field->count--;
@@ -1458,7 +1459,7 @@ status_t
 BMessage::RemoveName(const char *name)
 {
 	DEBUG_FUNCTION_ENTER;
-	FieldHeader *field = NULL;
+	field_header *field = NULL;
 	status_t result = _FindField(name, B_ANY_TYPE, &field);
 
 	if (result < B_OK)
@@ -1481,17 +1482,17 @@ BMessage::MakeEmpty()
 	free(fData);
 	fData = NULL;
 
-	fHeader->fieldsSize = 0;
-	fHeader->dataSize = 0;
-	fHeader->fieldsAvailable = 0;
-	fHeader->dataAvailable = 0;
-	fHeader->currentSpecifier = -1;
-	fHeader->fieldCount = 0;
+	fHeader->fields_size = 0;
+	fHeader->data_size = 0;
+	fHeader->fields_available = 0;
+	fHeader->data_available = 0;
+	fHeader->current_specifier = -1;
+	fHeader->field_count = 0;
 
 	fHeader->flags &= ~MESSAGE_FLAG_HAS_SPECIFIERS;
 
 	// initializing the hash table to -1 because 0 is a valid index
-	memset(&fHeader->hashTable, 255, sizeof(fHeader->hashTable));
+	memset(&fHeader->hash_table, 255, sizeof(fHeader->hash_table));
 	return B_OK;
 }
 
@@ -1505,7 +1506,7 @@ BMessage::FindData(const char *name, type_code type, int32 index,
 		return B_BAD_VALUE;
 
 	*data = NULL;
-	FieldHeader *field = NULL;
+	field_header *field = NULL;
 	status_t result = _FindField(name, type, &field);
 
 	if (result < B_OK)
@@ -1518,10 +1519,10 @@ BMessage::FindData(const char *name, type_code type, int32 index,
 		return B_BAD_INDEX;
 
 	if (field->flags & FIELD_FLAG_FIXED_SIZE) {
-		*numBytes = field->dataSize / field->count;
-		*data = fData + field->offset + field->nameLength + index * *numBytes;
+		*numBytes = field->data_size / field->count;
+		*data = fData + field->offset + field->name_length + index * *numBytes;
 	} else {
-		uint8 *pointer = fData + field->offset + field->nameLength;
+		uint8 *pointer = fData + field->offset + field->name_length;
 
 		for (int32 i = 0; i < index; i++)
 			pointer += *(ssize_t *)pointer + sizeof(ssize_t);
@@ -1542,7 +1543,7 @@ BMessage::ReplaceData(const char *name, type_code type, int32 index,
 	if (numBytes <= 0 || !data)
 		return B_BAD_VALUE;
 
-	FieldHeader *field = NULL;
+	field_header *field = NULL;
 	status_t result = _FindField(name, type, &field);
 
 	if (result < B_OK)
@@ -1555,14 +1556,14 @@ BMessage::ReplaceData(const char *name, type_code type, int32 index,
 		return B_BAD_INDEX;
 
 	if (field->flags & FIELD_FLAG_FIXED_SIZE) {
-		ssize_t size = field->dataSize / field->count;
+		ssize_t size = field->data_size / field->count;
 		if (size != numBytes)
 			return B_BAD_VALUE;
 
-		memcpy(fData + field->offset + field->nameLength + index * size, data,
+		memcpy(fData + field->offset + field->name_length + index * size, data,
 			size);
 	} else {
-		uint32 offset = field->offset + field->nameLength;
+		uint32 offset = field->offset + field->name_length;
 		uint8 *pointer = fData + offset;
 
 		for (int32 i = 0; i < index; i++) {
@@ -1575,7 +1576,7 @@ BMessage::ReplaceData(const char *name, type_code type, int32 index,
 		_ResizeData(offset, change);
 		memcpy(fData + offset, &numBytes, sizeof(numBytes));
 		memcpy(fData + offset + sizeof(numBytes), data, numBytes);
-		field->dataSize += change;
+		field->data_size += change;
 	}
 
 	return B_OK;
@@ -1586,7 +1587,7 @@ bool
 BMessage::HasData(const char *name, type_code type, int32 index) const
 {
 	DEBUG_FUNCTION_ENTER;
-	FieldHeader *field = NULL;
+	field_header *field = NULL;
 	status_t result = _FindField(name, type, &field);
 
 	if (result < B_OK)
@@ -1669,13 +1670,13 @@ BMessage::_SendMessage(port_id port, int32 token, bigtime_t timeout,
 	DEBUG_FUNCTION_ENTER;
 	uint32 oldFlags = fHeader->flags;
 	int32 oldTarget = fHeader->target;
-	port_id oldReplyPort = fHeader->replyPort;
-	int32 oldReplyTarget = fHeader->replyTarget;
-	team_id oldReplyTeam = fHeader->replyTeam;
+	port_id oldReplyPort = fHeader->reply_port;
+	int32 oldReplyTarget = fHeader->reply_target;
+	team_id oldReplyTeam = fHeader->reply_team;
 
 	if (!replyTo.IsValid()) {
-		BMessenger::Private(replyTo).SetTo(fHeader->replyTeam,
-			fHeader->replyPort, fHeader->replyTarget);
+		BMessenger::Private(replyTo).SetTo(fHeader->reply_team,
+			fHeader->reply_port, fHeader->reply_target);
 
 		if (!replyTo.IsValid())
 			replyTo = be_app_messenger;
@@ -1689,19 +1690,19 @@ BMessage::_SendMessage(port_id port, int32 token, bigtime_t timeout,
 		fHeader->flags &= ~MESSAGE_FLAG_REPLY_REQUIRED;
 
 	fHeader->target = token;
-	fHeader->replyTeam = replyToPrivate.Team();
-	fHeader->replyPort = replyToPrivate.Port();
-	fHeader->replyTarget = replyToPrivate.Token();
+	fHeader->reply_team = replyToPrivate.Team();
+	fHeader->reply_port = replyToPrivate.Port();
+	fHeader->reply_target = replyToPrivate.Token();
 	fHeader->flags |= MESSAGE_FLAG_WAS_DELIVERED;
 
 	/* ToDo: we can use _kern_writev_port to send the three parts directly:
 		iovec vectors[3];
 		vectors[0].iov_base = fHeader;
-		vectors[0].iov_len = sizeof(MessageHeader);
+		vectors[0].iov_len = sizeof(message_header);
 		vectors[1].iov_base = fFields;
-		vectors[1].iov_len = fHeader->fieldsSize;
+		vectors[1].iov_len = fHeader->fields_size;
 		vectors[2].iov_base = fData;
-		vectors[2].iov_len = fHeader->dataSize;
+		vectors[2].iov_len = fHeader->data_size;
 		status_t result;
 
 		do {
@@ -1724,9 +1725,9 @@ BMessage::_SendMessage(port_id port, int32 token, bigtime_t timeout,
 error:
 	fHeader->flags = oldFlags;
 	fHeader->target = oldTarget;
-	fHeader->replyPort = oldReplyPort;
-	fHeader->replyTarget = oldReplyTarget;
-	fHeader->replyTeam = oldReplyTeam;
+	fHeader->reply_port = oldReplyPort;
+	fHeader->reply_target = oldReplyTarget;
+	fHeader->reply_team = oldReplyTeam;
 	delete[] buffer;
 	return result;
 }
@@ -1810,7 +1811,7 @@ BMessage::_SendFlattenedMessage(void *data, int32 size, port_id port,
 	uint32 magic = *(uint32*)data;
 
 	if (magic == kMessageMagic4 || magic == kMessageMagic4Swapped) {
-		MessageHeader *header = (MessageHeader *)data;
+		message_header *header = (message_header *)data;
 		header->target = token;
 	} else if (magic == kMessageMagicR5) {
 		uint8 *header = (uint8 *)data;
diff --git a/src/kits/app/dano_message.cpp b/src/kits/app/dano_message.cpp
index 50392a78c6..c86eee13a1 100644
--- a/src/kits/app/dano_message.cpp
+++ b/src/kits/app/dano_message.cpp
@@ -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;
 
diff --git a/src/kits/app/dano_message.h b/src/kits/app/dano_message.h
index 2d0ed7a321..ea915c73ba 100644
--- a/src/kits/app/dano_message.h
+++ b/src/kits/app/dano_message.h
@@ -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
diff --git a/src/kits/app/r5_message.cpp b/src/kits/app/r5_message.cpp
index 711a11f5cf..5ab3a9ebac 100644
--- a/src/kits/app/r5_message.cpp
+++ b/src/kits/app/r5_message.cpp
@@ -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)
diff --git a/src/kits/app/r5_message.h b/src/kits/app/r5_message.h
index a6d28e7ed1..8382c1002e 100644
--- a/src/kits/app/r5_message.h
+++ b/src/kits/app/r5_message.h
@@ -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_