- more byte order logic

- added new network packet debug

source/glest_game/main/main.cpp

@@ -3243,6 +3243,11 @@ int glestMain(int argc, char** argv) {
 			LuaScript::setDisableSandbox(true);
 		}
 
+		if(hasCommandArgument(argc, argv,GAME_ARGS[GAME_ARG_DEBUG_NETWORK_PACKETS]) == true) {
+			printf("*NOTE: debugging network packets.\n");
+			config.setBool("DebugNetworkPackets",true,true);
+		}
+
 		Socket::setBroadCastPort(config.getInt("BroadcastPort",intToStr(Socket::getBroadCastPort()).c_str()));
 
 		Socket::disableNagle = config.getBool("DisableNagle","false");

source/glest_game/network/network_message.cpp

@@ -53,6 +53,8 @@ bool NetworkMessage::receive(Socket* socket, void* data, int dataSize, bool tryR
 		}
 		else {
 			if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] dataSize = %d, dataReceived = %d\n",__FILE__,__FUNCTION__,__LINE__,dataSize,dataReceived);
+
+			dump_packet("\nINCOMING PACKET:\n",data, dataSize);
 			return true;
 		}
 	}
@@ -64,6 +66,7 @@ void NetworkMessage::send(Socket* socket, const void* data, int dataSize) {
 	if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] socket = %p, data = %p, dataSize = %d\n",__FILE__,__FUNCTION__,__LINE__,socket,data,dataSize);
 
 	if(socket != NULL) {
+		dump_packet("\nOUTGOING PACKET:\n",data, dataSize);
 		int sendResult = socket->send(data, dataSize);
 		if(sendResult != dataSize) {
 			if(socket != NULL && socket->getSocketId() > 0) {
@@ -78,6 +81,22 @@ void NetworkMessage::send(Socket* socket, const void* data, int dataSize) {
 	}
 }
 
+void NetworkMessage::dump_packet(string label, const void* data, int dataSize) {
+	Config &config = Config::getInstance();
+	if(config.getBool("DebugNetworkPackets","false") == true) {
+		printf("%s",label.c_str());
+
+		const char *buf = static_cast<const char *>(data);
+		for(unsigned int i = 0; i < dataSize; ++i) {
+			printf("%d[%X][%d] ",i,buf[i],buf[i]);
+			if(i % 10 == 0) {
+				printf("\n");
+			}
+		}
+		printf("\n== END ==\n");
+	}
+}
+
 // =====================================================
 //	class NetworkMessageIntro
 // =====================================================
@@ -126,6 +145,8 @@ void NetworkMessageIntro::send(Socket* socket) {
 }
 
 void NetworkMessageIntro::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.sessionId = Shared::PlatformByteOrder::toCommonEndian(data.sessionId);
 		data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
@@ -133,7 +154,10 @@ void NetworkMessageIntro::toEndian() {
 		data.externalIp = Shared::PlatformByteOrder::toCommonEndian(data.externalIp);
 		data.ftpPort = Shared::PlatformByteOrder::toCommonEndian(data.ftpPort);
 	}
+}
 void NetworkMessageIntro::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.sessionId = Shared::PlatformByteOrder::fromCommonEndian(data.sessionId);
 		data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
@@ -141,6 +165,7 @@ void NetworkMessageIntro::fromEndian() {
 		data.externalIp = Shared::PlatformByteOrder::fromCommonEndian(data.externalIp);
 		data.ftpPort = Shared::PlatformByteOrder::fromCommonEndian(data.ftpPort);
 	}
+}
 
 // =====================================================
 //	class NetworkMessagePing
@@ -173,15 +198,21 @@ void NetworkMessagePing::send(Socket* socket) {
 }
 
 void NetworkMessagePing::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.pingFrequency = Shared::PlatformByteOrder::toCommonEndian(data.pingFrequency);
 		data.pingTime = Shared::PlatformByteOrder::toCommonEndian(data.pingTime);
 	}
+}
 void NetworkMessagePing::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.pingFrequency = Shared::PlatformByteOrder::fromCommonEndian(data.pingFrequency);
 		data.pingTime = Shared::PlatformByteOrder::fromCommonEndian(data.pingTime);
 	}
+}
 
 // =====================================================
 //	class NetworkMessageReady
@@ -210,13 +241,19 @@ void NetworkMessageReady::send(Socket* socket) {
 }
 
 void NetworkMessageReady::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.checksum = Shared::PlatformByteOrder::toCommonEndian(data.checksum);
 	}
+}
 void NetworkMessageReady::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.checksum = Shared::PlatformByteOrder::fromCommonEndian(data.checksum);
 	}
+}
 
 // =====================================================
 //	class NetworkMessageLaunch
@@ -366,6 +403,7 @@ vector<pair<string,uint32> > NetworkMessageLaunch::getFactionCRCList() const {
 bool NetworkMessageLaunch::receive(Socket* socket) {
 	bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
 	fromEndian();
+
 	data.description.nullTerminate();
 	data.map.nullTerminate();
 	data.tileset.nullTerminate();
@@ -395,6 +433,8 @@ void NetworkMessageLaunch::send(Socket* socket) {
 }
 
 void NetworkMessageLaunch::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		for(int i= 0; i < GameConstants::maxPlayers; ++i){
 			data.networkPlayerStatuses[i] = Shared::PlatformByteOrder::toCommonEndian(data.networkPlayerStatuses[i]);
@@ -427,7 +467,11 @@ void NetworkMessageLaunch::toEndian() {
 		data.masterserver_admin = Shared::PlatformByteOrder::toCommonEndian(data.masterserver_admin);
 		data.masterserver_admin_factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.masterserver_admin_factionIndex);
 	}
+}
+
 void NetworkMessageLaunch::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		for(int i= 0; i < GameConstants::maxPlayers; ++i){
 			data.networkPlayerStatuses[i] = Shared::PlatformByteOrder::fromCommonEndian(data.networkPlayerStatuses[i]);
@@ -460,6 +504,7 @@ void NetworkMessageLaunch::fromEndian() {
 		data.masterserver_admin = Shared::PlatformByteOrder::fromCommonEndian(data.masterserver_admin);
 		data.masterserver_admin_factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.masterserver_admin_factionIndex);
 	}
+}
 
 // =====================================================
 //	class NetworkMessageLaunch
@@ -544,17 +589,25 @@ void NetworkMessageCommandList::send(Socket* socket) {
 }
 
 void NetworkMessageCommandList::toEndianHeader() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.header.messageType = Shared::PlatformByteOrder::toCommonEndian(data.header.messageType);
 		data.header.commandCount = Shared::PlatformByteOrder::toCommonEndian(data.header.commandCount);
 		data.header.frameCount = Shared::PlatformByteOrder::toCommonEndian(data.header.frameCount);
 	}
+}
 void NetworkMessageCommandList::fromEndianHeader() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.header.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.header.messageType);
 		data.header.commandCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.commandCount);
 		data.header.frameCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.frameCount);
 	}
+}
 
 void NetworkMessageCommandList::toEndianDetail(uint16 totalCommand) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		if(totalCommand > 0) {
 			for(int idx = 0 ; idx < totalCommand; ++idx) {
 				NetworkCommand &cmd = data.commands[idx];
@@ -562,7 +615,11 @@ void NetworkMessageCommandList::toEndianDetail(uint16 totalCommand) {
 			}
 		}
 	}
+}
+
 void NetworkMessageCommandList::fromEndianDetail() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		if(data.header.commandCount > 0) {
 			for(int idx = 0 ; idx < data.header.commandCount; ++idx) {
 				NetworkCommand &cmd = data.commands[idx];
@@ -570,6 +627,7 @@ void NetworkMessageCommandList::fromEndianDetail() {
 			}
 		}
 	}
+}
 
 // =====================================================
 //	class NetworkMessageText
@@ -612,15 +670,21 @@ void NetworkMessageText::send(Socket* socket) {
 }
 
 void NetworkMessageText::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.teamIndex = Shared::PlatformByteOrder::toCommonEndian(data.teamIndex);
 		data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
 	}
+}
 void NetworkMessageText::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.teamIndex = Shared::PlatformByteOrder::fromCommonEndian(data.teamIndex);
 		data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
 	}
+}
 
 // =====================================================
 //	class NetworkMessageQuit
@@ -645,11 +709,17 @@ void NetworkMessageQuit::send(Socket* socket) {
 }
 
 void NetworkMessageQuit::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 	}
+}
 void NetworkMessageQuit::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 	}
+}
 
 // =====================================================
 //	class NetworkMessageSynchNetworkGameData
@@ -851,30 +921,42 @@ void NetworkMessageSynchNetworkGameData::send(Socket* socket) {
 }
 
 void NetworkMessageSynchNetworkGameData::toEndianHeader() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.header.messageType = Shared::PlatformByteOrder::toCommonEndian(data.header.messageType);
 		data.header.mapCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.mapCRC);
 		data.header.tilesetCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.tilesetCRC);
 		data.header.techCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRC);
 		data.header.techCRCFileCount = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRCFileCount);
 	}
+}
 void NetworkMessageSynchNetworkGameData::fromEndianHeader() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.header.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.header.messageType);
 		data.header.mapCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.mapCRC);
 		data.header.tilesetCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.tilesetCRC);
 		data.header.techCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRC);
 		data.header.techCRCFileCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRCFileCount);
 	}
+}
 
 void NetworkMessageSynchNetworkGameData::toEndianDetail(uint32 totalFileCount) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(unsigned int i = 0; i < totalFileCount; ++i) {
 			data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.detail.techCRCFileCRCList[i]);
 		}
 	}
+}
 void NetworkMessageSynchNetworkGameData::fromEndianDetail() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(unsigned int i = 0; i < data.header.techCRCFileCount; ++i) {
 			data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.detail.techCRCFileCRCList[i]);
 		}
 	}
+}
 
 // =====================================================
 //	class NetworkMessageSynchNetworkGameDataStatus
@@ -1033,30 +1115,43 @@ void NetworkMessageSynchNetworkGameDataStatus::send(Socket* socket) {
 }
 
 void NetworkMessageSynchNetworkGameDataStatus::toEndianHeader() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.header.messageType = Shared::PlatformByteOrder::toCommonEndian(data.header.messageType);
 		data.header.mapCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.mapCRC);
 		data.header.tilesetCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.tilesetCRC);
 		data.header.techCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRC);
 		data.header.techCRCFileCount = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRCFileCount);
 	}
+}
+
 void NetworkMessageSynchNetworkGameDataStatus::fromEndianHeader() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.header.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.header.messageType);
 		data.header.mapCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.mapCRC);
 		data.header.tilesetCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.tilesetCRC);
 		data.header.techCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRC);
 		data.header.techCRCFileCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRCFileCount);
 	}
+}
 
 void NetworkMessageSynchNetworkGameDataStatus::toEndianDetail(uint32 totalFileCount) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(unsigned int i = 0; i < totalFileCount; ++i) {
 			data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.detail.techCRCFileCRCList[i]);
 		}
 	}
+}
 void NetworkMessageSynchNetworkGameDataStatus::fromEndianDetail() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(unsigned int i = 0; i < data.header.techCRCFileCount; ++i) {
 			data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.detail.techCRCFileCRCList[i]);
 		}
 	}
+}
 
 // =====================================================
 //	class NetworkMessageSynchNetworkGameDataFileCRCCheck
@@ -1089,18 +1184,24 @@ void NetworkMessageSynchNetworkGameDataFileCRCCheck::send(Socket* socket) {
 }
 
 void NetworkMessageSynchNetworkGameDataFileCRCCheck::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.totalFileCount = Shared::PlatformByteOrder::toCommonEndian(data.totalFileCount);
 		data.fileIndex = Shared::PlatformByteOrder::toCommonEndian(data.fileIndex);
 		data.fileCRC = Shared::PlatformByteOrder::toCommonEndian(data.fileCRC);
 	}
+}
 
 void NetworkMessageSynchNetworkGameDataFileCRCCheck::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.totalFileCount = Shared::PlatformByteOrder::fromCommonEndian(data.totalFileCount);
 		data.fileIndex = Shared::PlatformByteOrder::fromCommonEndian(data.fileIndex);
 		data.fileCRC = Shared::PlatformByteOrder::fromCommonEndian(data.fileCRC);
 	}
+}
 // =====================================================
 //	class NetworkMessageSynchNetworkGameDataFileGet
 // =====================================================
@@ -1127,11 +1228,17 @@ void NetworkMessageSynchNetworkGameDataFileGet::send(Socket* socket) {
 }
 
 void NetworkMessageSynchNetworkGameDataFileGet::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 	}
+}
 void NetworkMessageSynchNetworkGameDataFileGet::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 	}
+}
 
 
 // =====================================================
@@ -1186,6 +1293,8 @@ void SwitchSetupRequest::send(Socket* socket) {
 }
 
 void SwitchSetupRequest::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.currentFactionIndex = Shared::PlatformByteOrder::toCommonEndian(data.currentFactionIndex);
 		data.toFactionIndex = Shared::PlatformByteOrder::toCommonEndian(data.toFactionIndex);
@@ -1193,7 +1302,10 @@ void SwitchSetupRequest::toEndian() {
 		data.networkPlayerStatus = Shared::PlatformByteOrder::toCommonEndian(data.networkPlayerStatus);
 		data.switchFlags = Shared::PlatformByteOrder::toCommonEndian(data.switchFlags);
 	}
+}
 void SwitchSetupRequest::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.currentFactionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.currentFactionIndex);
 		data.toFactionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.toFactionIndex);
@@ -1201,6 +1313,7 @@ void SwitchSetupRequest::fromEndian() {
 		data.networkPlayerStatus = Shared::PlatformByteOrder::fromCommonEndian(data.networkPlayerStatus);
 		data.switchFlags = Shared::PlatformByteOrder::fromCommonEndian(data.switchFlags);
 	}
+}
 
 // =====================================================
 //	class PlayerIndexMessage
@@ -1223,13 +1336,19 @@ void PlayerIndexMessage::send(Socket* socket) {
 }
 
 void PlayerIndexMessage::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
 	}
+}
 void PlayerIndexMessage::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
 	}
+}
 
 // =====================================================
 //	class NetworkMessageLoadingStatus
@@ -1253,13 +1372,19 @@ void NetworkMessageLoadingStatus::send(Socket* socket) {
 }
 
 void NetworkMessageLoadingStatus::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.status = Shared::PlatformByteOrder::toCommonEndian(data.status);
 	}
+}
 void NetworkMessageLoadingStatus::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.status = Shared::PlatformByteOrder::fromCommonEndian(data.status);
 	}
+}
 
 // =====================================================
 //	class NetworkMessageMarkCell
@@ -1300,19 +1425,25 @@ void NetworkMessageMarkCell::send(Socket* socket) {
 }
 
 void NetworkMessageMarkCell::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.targetX = Shared::PlatformByteOrder::toCommonEndian(data.targetX);
 		data.targetY = Shared::PlatformByteOrder::toCommonEndian(data.targetY);
 		data.factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.factionIndex);
 		data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
 	}
+}
 void NetworkMessageMarkCell::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.targetX = Shared::PlatformByteOrder::fromCommonEndian(data.targetX);
 		data.targetY = Shared::PlatformByteOrder::fromCommonEndian(data.targetY);
 		data.factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.factionIndex);
 		data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
 	}
+}
 
 // =====================================================
 //	class NetworkMessageUnMarkCell
@@ -1346,17 +1477,23 @@ void NetworkMessageUnMarkCell::send(Socket* socket) {
 }
 
 void NetworkMessageUnMarkCell::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.targetX = Shared::PlatformByteOrder::toCommonEndian(data.targetX);
 		data.targetY = Shared::PlatformByteOrder::toCommonEndian(data.targetY);
 		data.factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.factionIndex);
 	}
+}
 void NetworkMessageUnMarkCell::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.targetX = Shared::PlatformByteOrder::fromCommonEndian(data.targetX);
 		data.targetY = Shared::PlatformByteOrder::fromCommonEndian(data.targetY);
 		data.factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.factionIndex);
 	}
+}
 
 // =====================================================
 //	class NetworkMessageHighlightCell
@@ -1385,16 +1522,22 @@ void NetworkMessageHighlightCell::send(Socket* socket) {
 }
 
 void NetworkMessageHighlightCell::toEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
 		data.targetX = Shared::PlatformByteOrder::toCommonEndian(data.targetX);
 		data.targetY = Shared::PlatformByteOrder::toCommonEndian(data.targetY);
 		data.factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.factionIndex);
 	}
+}
 void NetworkMessageHighlightCell::fromEndian() {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
 		data.targetX = Shared::PlatformByteOrder::fromCommonEndian(data.targetX);
 		data.targetY = Shared::PlatformByteOrder::fromCommonEndian(data.targetY);
 		data.factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.factionIndex);
 	}
+}
 
 }}//end namespace

source/glest_game/network/network_message.h

@@ -76,6 +76,8 @@ protected:
 	//bool peek(Socket* socket, void* data, int dataSize);
 	bool receive(Socket* socket, void* data, int dataSize,bool tryReceiveUntilDataSizeMet);
 	void send(Socket* socket, const void* data, int dataSize);
+
+	void dump_packet(string label, const void* data, int dataSize);
 };
 
 // =====================================================

source/shared_lib/include/graphics/vec.h

@@ -68,16 +68,22 @@ template<typename T> class Vec4;
 
 template<class T>
 void toEndianVecArray(T *vec, size_t size) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(size_t i = 0; i < size; ++i) {
 			vec[i].toEndian();
 		}
 	}
+}
 template<class T>
 void fromEndianVecArray(T *vec, size_t size) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(size_t i = 0; i < size; ++i) {
 			vec[i].fromEndian();
 		}
 	}
+}
 
 // =====================================================
 //	class Vec2
@@ -276,13 +282,19 @@ public:
 	}
 
 	void toEndian() {
+		static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+		if(bigEndianSystem == true) {
 			this->x = Shared::PlatformByteOrder::toCommonEndian(this->x);
 			this->y = Shared::PlatformByteOrder::toCommonEndian(this->y);
 		}
+	}
 	void fromEndian() {
+		static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+		if(bigEndianSystem == true) {
 			this->x = Shared::PlatformByteOrder::fromCommonEndian(this->x);
 			this->y = Shared::PlatformByteOrder::fromCommonEndian(this->y);
 		}
+	}
 
 };
 
@@ -524,15 +536,21 @@ public:
 	}
 
 	void toEndian() {
+		static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+		if(bigEndianSystem == true) {
 			this->x = Shared::PlatformByteOrder::toCommonEndian(this->x);
 			this->y = Shared::PlatformByteOrder::toCommonEndian(this->y);
 			this->z = Shared::PlatformByteOrder::toCommonEndian(this->z);
 		}
+	}
 	void fromEndian() {
+		static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+		if(bigEndianSystem == true) {
 			this->x = Shared::PlatformByteOrder::fromCommonEndian(this->x);
 			this->y = Shared::PlatformByteOrder::fromCommonEndian(this->y);
 			this->z = Shared::PlatformByteOrder::fromCommonEndian(this->z);
 		}
+	}
 
 };
 
@@ -750,17 +768,23 @@ public:
 	}
 
 	void toEndian() {
+		static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+		if(bigEndianSystem == true) {
 			this->x = Shared::PlatformByteOrder::toCommonEndian(this->x);
 			this->y = Shared::PlatformByteOrder::toCommonEndian(this->y);
 			this->z = Shared::PlatformByteOrder::toCommonEndian(this->z);
 			this->w = Shared::PlatformByteOrder::toCommonEndian(this->w);
 		}
+	}
 	void fromEndian() {
+		static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+		if(bigEndianSystem == true) {
 			this->x = Shared::PlatformByteOrder::fromCommonEndian(this->x);
 			this->y = Shared::PlatformByteOrder::fromCommonEndian(this->y);
 			this->z = Shared::PlatformByteOrder::fromCommonEndian(this->z);
 			this->w = Shared::PlatformByteOrder::fromCommonEndian(this->w);
 		}
+	}
 
 };
 

source/shared_lib/include/platform/sdl/platform_main.h

@@ -87,6 +87,7 @@ const char  *GAME_ARGS[] = {
 
 	"--disable-opengl-checks",
 	"--disable-streflop-checks",
+	"--debug-network-packets",
 
 	"--verbose"
 
@@ -160,6 +161,8 @@ enum GAME_ARG_TYPE {
 	GAME_ARG_DISABLE_OPENGL_CAPS_CHECK,
 	GAME_ARG_DISABLE_STREFLOP_CAPS_CHECK,
 
+	GAME_ARG_DEBUG_NETWORK_PACKETS,
+
 	GAME_ARG_VERBOSE_MODE,
 
 	GAME_ARG_END

source/shared_lib/sources/graphics/model.cpp

@@ -37,28 +37,42 @@ using namespace Util;
 
 // Utils methods for endianness conversion
 void toEndianFileHeader(FileHeader &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(unsigned int i = 0; i < 3; ++i) {
 			header.id[i] = Shared::PlatformByteOrder::toCommonEndian(header.id[i]);
 		}
 		header.version = Shared::PlatformByteOrder::toCommonEndian(header.version);
 	}
+}
 void fromEndianFileHeader(FileHeader &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(unsigned int i = 0; i < 3; ++i) {
 			header.id[i] = Shared::PlatformByteOrder::fromCommonEndian(header.id[i]);
 		}
 		header.version = Shared::PlatformByteOrder::fromCommonEndian(header.version);
 	}
+}
 
 void toEndianModelHeader(ModelHeader &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		header.type = Shared::PlatformByteOrder::toCommonEndian(header.type);
 		header.meshCount = Shared::PlatformByteOrder::toCommonEndian(header.meshCount);
 	}
+}
 void fromEndianModelHeader(ModelHeader &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		header.type = Shared::PlatformByteOrder::toCommonEndian(header.type);
 		header.meshCount = Shared::PlatformByteOrder::toCommonEndian(header.meshCount);
 	}
+}
 
 void toEndianMeshHeader(MeshHeader &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(unsigned int i = 0; i < meshNameSize; ++i) {
 			header.name[i] = Shared::PlatformByteOrder::toCommonEndian(header.name[i]);
 		}
@@ -74,8 +88,11 @@ void toEndianMeshHeader(MeshHeader &header) {
 		header.properties = Shared::PlatformByteOrder::toCommonEndian(header.properties);
 		header.textures = Shared::PlatformByteOrder::toCommonEndian(header.textures);
 	}
+}
 
 void fromEndianMeshHeader(MeshHeader &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		for(unsigned int i = 0; i < meshNameSize; ++i) {
 			header.name[i] = Shared::PlatformByteOrder::fromCommonEndian(header.name[i]);
 		}
@@ -91,15 +108,24 @@ void fromEndianMeshHeader(MeshHeader &header) {
 		header.properties = Shared::PlatformByteOrder::fromCommonEndian(header.properties);
 		header.textures = Shared::PlatformByteOrder::fromCommonEndian(header.textures);
 	}
+}
 
 void toEndianModelHeaderV3(ModelHeaderV3 &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		header.meshCount = Shared::PlatformByteOrder::toCommonEndian(header.meshCount);
 	}
+}
 void fromEndianModelHeaderV3(ModelHeaderV3 &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		header.meshCount = Shared::PlatformByteOrder::fromCommonEndian(header.meshCount);
 	}
+}
 
 void toEndianMeshHeaderV3(MeshHeaderV3 &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		header.vertexFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.vertexFrameCount);
 		header.normalFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.normalFrameCount);
 		header.texCoordFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.texCoordFrameCount);
@@ -111,8 +137,11 @@ void toEndianMeshHeaderV3(MeshHeaderV3 &header) {
 			header.texName[i] = Shared::PlatformByteOrder::toCommonEndian(header.texName[i]);
 		}
 	}
+}
 
 void fromEndianMeshHeaderV3(MeshHeaderV3 &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		header.vertexFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.vertexFrameCount);
 		header.normalFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.normalFrameCount);
 		header.texCoordFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.texCoordFrameCount);
@@ -124,8 +153,11 @@ void fromEndianMeshHeaderV3(MeshHeaderV3 &header) {
 			header.texName[i] = Shared::PlatformByteOrder::fromCommonEndian(header.texName[i]);
 		}
 	}
+}
 
 void toEndianMeshHeaderV2(MeshHeaderV2 &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		header.vertexFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.vertexFrameCount);
 		header.normalFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.normalFrameCount);
 		header.texCoordFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.texCoordFrameCount);
@@ -140,8 +172,11 @@ void toEndianMeshHeaderV2(MeshHeaderV2 &header) {
 			header.texName[i] = Shared::PlatformByteOrder::toCommonEndian(header.texName[i]);
 		}
 	}
+}
 
 void fromEndianMeshHeaderV2(MeshHeaderV2 &header) {
+	static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
+	if(bigEndianSystem == true) {
 		header.vertexFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.vertexFrameCount);
 		header.normalFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.normalFrameCount);
 		header.texCoordFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.texCoordFrameCount);
@@ -156,6 +191,7 @@ void fromEndianMeshHeaderV2(MeshHeaderV2 &header) {
 			header.texName[i] = Shared::PlatformByteOrder::fromCommonEndian(header.texName[i]);
 		}
 	}
+}
 
 // =====================================================
 //	class Mesh