Completely rewriting all NetPacket stuff to use ASN.1. Finally this big chunk of work is completed. Compiles and links fine, but still partly non-functional.

PLEASE NOTE: This is NOT COMPATIBLE to 0.7.x, because it is a new network protocol.

pokerth_server.pro

@@ -31,6 +31,7 @@ INCLUDEPATH += . \
 		src/engine/network_engine \
 		src/config \
 		src/third_party/tinyxml \
+		src/third_party/asn1 \
 		src/core \
 
 DEPENDPATH += . \

src/core/avatarmanager.h

@@ -27,6 +27,8 @@
 #include <map>
 #include <list>
 
+#include <playerdata.h>
+#include <core/crypthelper.h>
 #include <net/netpacket.h>
 
 #define MIN_AVATAR_FILE_SIZE	32

src/core/common/avatarmanager.cpp

@@ -194,28 +194,34 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
 	boost::shared_ptr<AvatarFileState> tmpState = OpenAvatarFileForChunkRead(fileName, fileSize, fileType);
 	if (tmpState.get() && fileSize && fileType != AVATAR_FILE_TYPE_UNKNOWN)
 	{
-		boost::shared_ptr<NetPacket> avatarHeader(new NetPacketAvatarHeader);
+		boost::shared_ptr<NetPacket> avatarHeader(new NetPacket(NetPacket::Alloc));
-		NetPacketAvatarHeader::Data avatarHeaderData;
+		avatarHeader->GetMsg()->present = PokerTHMessage_PR_avatarReplyMessage;
-		avatarHeaderData.requestId = requestId;
+		AvatarReplyMessage_t *netHeader = &avatarHeader->GetMsg()->choice.avatarReplyMessage;
-		avatarHeaderData.avatarFileSize = fileSize;
+		netHeader->requestId = requestId;
-		avatarHeaderData.avatarFileType = fileType;
+		netHeader->avatarResult.present = avatarResult_PR_avatarHeader;
-		static_cast<NetPacketAvatarHeader *>(avatarHeader.get())->SetData(avatarHeaderData);
+		netHeader->avatarResult.choice.avatarHeader.avatarType = fileType;
+		netHeader->avatarResult.choice.avatarHeader.avatarSize = fileSize;
 		packets.push_back(avatarHeader);
 
 		unsigned numBytes = 0;
 		unsigned totalBytesRead = 0;
+		vector<unsigned char> tmpData(MAX_FILE_DATA_SIZE);
 		do
 		{
-			boost::shared_ptr<NetPacketAvatarFile> avatarFile(new NetPacketAvatarFile);
+			numBytes = ChunkReadAvatarFile(tmpState, &tmpData[0], MAX_FILE_DATA_SIZE);
-			NetPacketAvatarFile::Data avatarFileData;
-			avatarFileData.fileData.resize(MAX_FILE_DATA_SIZE);
-			numBytes = ChunkReadAvatarFile(tmpState, &avatarFileData.fileData[0], MAX_FILE_DATA_SIZE);
 			if (numBytes)
 			{
-				avatarFileData.fileData.resize(numBytes);
-				avatarFileData.requestId = requestId;
 				totalBytesRead += numBytes;
-				static_cast<NetPacketAvatarFile *>(avatarFile.get())->SetData(avatarFileData);
+
+				boost::shared_ptr<NetPacket> avatarFile(new NetPacket(NetPacket::Alloc));
+				avatarFile->GetMsg()->present = PokerTHMessage_PR_avatarReplyMessage;
+				AvatarReplyMessage_t *netFile = &avatarFile->GetMsg()->choice.avatarReplyMessage;
+				netFile->requestId = requestId;
+				netFile->avatarResult.present = avatarResult_PR_avatarData;
+				OCTET_STRING_fromBuf(
+					&netFile->avatarResult.choice.avatarData.avatarBlock,
+					(const char *)&tmpData[0],
+					numBytes);
 				packets.push_back(avatarFile);
 			}
 		} while (numBytes);
@@ -224,10 +230,11 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
 			retVal = ERR_NET_WRONG_AVATAR_SIZE;
 		else
 		{
-			boost::shared_ptr<NetPacket> avatarEnd(new NetPacketAvatarEnd);
+			boost::shared_ptr<NetPacket> avatarEnd(new NetPacket(NetPacket::Alloc));
-			NetPacketAvatarEnd::Data avatarEndData;
+			avatarEnd->GetMsg()->present = PokerTHMessage_PR_avatarReplyMessage;
-			avatarEndData.requestId = requestId;
+			AvatarReplyMessage_t *netEnd = &avatarEnd->GetMsg()->choice.avatarReplyMessage;
-			static_cast<NetPacketAvatarEnd *>(avatarEnd.get())->SetData(avatarEndData);
+			netEnd->requestId = requestId;
+			netEnd->avatarResult.present = avatarResult_PR_avatarEnd;
 			packets.push_back(avatarEnd);
 			retVal = 0;
 		}

src/game_defs.h

@@ -75,8 +75,7 @@ enum DenyKickPlayerReason
 	KICK_DENIED_TOO_FEW_PLAYERS,
 	KICK_DENIED_TEMPORARY,
 	KICK_DENIED_OTHER_IN_PROGRESS,
-	KICK_DENIED_INVALID_PLAYER_ID,
+	KICK_DENIED_INVALID_PLAYER_ID
-	KICK_DENIED_OTHER_REASON
 };
 
 enum KickVote
@@ -88,9 +87,7 @@ enum KickVote
 enum DenyVoteReason
 {
 	VOTE_DENIED_INVALID_PETITION = 0,
-	VOTE_DENIED_ALREADY_VOTED,
+	VOTE_DENIED_ALREADY_VOTED
-	VOTE_DENIED_IMPOSSIBLE,
-	VOTE_DENIED_OTHER_REASON
 };
 
 enum EndPetitionReason

src/net/clientthread.h

@@ -98,7 +98,7 @@ protected:
 	typedef std::map<unsigned, GameInfo> GameInfoMap;
 	typedef std::list<boost::shared_ptr<NetPacket> > NetPacketList;
 	typedef std::map<unsigned, PlayerInfo> PlayerInfoMap;
-	typedef std::map<unsigned, boost::shared_ptr<AvatarData> > AvatarDataMap;
+	typedef std::map<unsigned, boost::shared_ptr<AvatarFile> > AvatarFileMap;
 	typedef std::map<unsigned, ServerInfo> ServerInfoMap;
 
 	// Main function of the thread.
@@ -117,10 +117,10 @@ protected:
 	void SetNewGameAdmin(unsigned id);
 	void RetrieveAvatarIfNeeded(unsigned id, const PlayerInfo &info);
 
-	void AddTempAvatarData(unsigned playerId, unsigned avatarSize, AvatarFileType type);
+	void AddTempAvatarFile(unsigned playerId, unsigned avatarSize, AvatarFileType type);
-	void StoreInTempAvatarData(unsigned playerId, const std::vector<unsigned char> &data);
+	void StoreInTempAvatarFile(unsigned playerId, const std::vector<unsigned char> &data);
-	void CompleteTempAvatarData(unsigned playerId);
+	void CompleteTempAvatarFile(unsigned playerId);
-	void PassAvatarDataToManager(unsigned playerId, boost::shared_ptr<AvatarData> avatarData);
+	void PassAvatarFileToManager(unsigned playerId, boost::shared_ptr<AvatarFile> AvatarFile);
 	void SetUnknownAvatar(unsigned playerId);
 
 	void TimerCheckAvatarDownloads(const boost::system::error_code& ec);
@@ -234,7 +234,7 @@ private:
 	unsigned m_curPetitionId;
 	mutable boost::mutex m_curPetitionIdMutex;
 
-	AvatarDataMap m_tempAvatarMap;
+	AvatarFileMap m_tempAvatarMap;
 
 	unsigned m_curGameNum;
 	unsigned m_guiPlayerId;

src/net/common/clientcontext.cpp

@@ -17,6 +17,7 @@
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 
+#include <boost/asio.hpp>
 #include <net/clientcontext.h>
 
 

src/net/common/clientstate.cpp

@@ -667,21 +667,32 @@ ClientStateStartSession::Enter(boost::shared_ptr<ClientThread> client)
 {
 	ClientContext &context = client->GetContext();
 
-	NetPacketInit::Data initData;
+	boost::shared_ptr<NetPacket> init(new NetPacket(NetPacket::Alloc));
-	initData.password = context.GetPassword();
+	init->GetMsg()->present = PokerTHMessage_PR_initMessage;
-	initData.playerName = context.GetPlayerName();
+	InitMessage_t *netInit = &init->GetMsg()->choice.initMessage;
+	netInit->requestedVersion.major = NET_VERSION_MAJOR;
+	netInit->requestedVersion.minor = NET_VERSION_MINOR;
+	netInit->login.present = login_PR_anonymousLogin;
+	AnonymousLogin_t *anonLogin = &netInit->login.choice.anonymousLogin;
+	OCTET_STRING_fromBuf(&anonLogin->playerName,
+						 context.GetPlayerName().c_str(),
+						 context.GetPlayerName().length());
+	//context.GetPassword();
 	string avatarFile = client->GetQtToolsInterface().stringFromUtf8(context.GetAvatarFile());
-	initData.showAvatar = false;
 	if (!avatarFile.empty())
 	{
-		if (client->GetAvatarManager().GetHashForAvatar(avatarFile, initData.avatar))
+		MD5Buf tmpMD5;
-			initData.showAvatar = true;
+		if (client->GetAvatarManager().GetHashForAvatar(avatarFile, tmpMD5))
+		{
+			// TODO: use sha1.
+			anonLogin->avatar =
+					OCTET_STRING_new_fromBuf(
+						&asn_DEF_OCTET_STRING,
+						(const char *)tmpMD5.data,
+						MD5_DATA_SIZE);
 		}
-
+	}
-	boost::shared_ptr<NetPacket> packet(new NetPacketInit);
+	client->GetSender().Send(context.GetSessionData(), init);
-	((NetPacketInit *)packet.get())->SetData(initData);
-
-	client->GetSender().Send(context.GetSessionData(), packet);
 
 	client->SetState(ClientStateWaitSession::Instance());
 }
@@ -704,194 +715,234 @@ AbstractClientStateReceiving::~AbstractClientStateReceiving()
 void
 AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
 {
-	if (tmpPacket->ToNetPacketPlayerInfo())
+	if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_playerInfoReplyMessage)
 	{
-		NetPacketPlayerInfo::Data infoData;
+		unsigned playerId = tmpPacket->GetMsg()->choice.playerInfoReplyMessage.playerId;
-		tmpPacket->ToNetPacketPlayerInfo()->GetData(infoData);
+		if (tmpPacket->GetMsg()->choice.playerInfoReplyMessage.playerInfoResult.present == playerInfoResult_PR_playerInfoData)
-		client->SetPlayerInfo(infoData.playerId, infoData.playerInfo);
+		{
+			PlayerInfo tmpInfo;
+			PlayerInfoData_t *netInfo = &tmpPacket->GetMsg()->choice.playerInfoReplyMessage.playerInfoResult.choice.playerInfoData;
+			tmpInfo.playerName = STL_STRING_FROM_OCTET_STRING(netInfo->playerName);
+			if (netInfo->isHuman)
+				tmpInfo.playerName = PLAYER_TYPE_HUMAN;
+			else
+				tmpInfo.ptype = PLAYER_TYPE_COMPUTER;
+			if (netInfo->avatarData != NULL)
+			{
+				tmpInfo.hasAvatar = true;
+				// TODO: use sha1.
+				memcpy(tmpInfo.avatar.data, netInfo->avatarData->avatar.buf, MD5_DATA_SIZE);
+				tmpInfo.avatarType = (AvatarFileType)netInfo->avatarData->avatarType;
 			}
-	else if (tmpPacket->ToNetPacketUnknownPlayerId())
+			client->SetPlayerInfo(
-	{
+				playerId,
-		NetPacketUnknownPlayerId::Data unknownIdData;
+				tmpInfo);
-		tmpPacket->ToNetPacketUnknownPlayerId()->GetData(unknownIdData);
-		client->SetUnknownPlayer(unknownIdData.playerId);
 		}
-	else if (tmpPacket->ToNetPacketRemovedFromGame())
+		else
 		{
-		NetPacketRemovedFromGame::Data removedData;
+			client->SetUnknownPlayer(playerId);
-		tmpPacket->ToNetPacketRemovedFromGame()->GetData(removedData);
+		}
+	}
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_gamePlayerMessage)
+	{
+		GamePlayerMessage_t *netGamePlayer = &tmpPacket->GetMsg()->choice.gamePlayerMessage;
+//		unsigned gameId = netGamePlayer->gameId;
+		if (netGamePlayer->gamePlayerNotification.present == gamePlayerNotification_PR_removedFromGame)
+		{
+			RemovedFromGame_t *netRemoved = &netGamePlayer->gamePlayerNotification.choice.removedFromGame;
+
 			client->ClearPlayerDataList();
 			// Resubscribe Lobby messages.
 			client->ResubscribeLobbyMsg();
 			// Show Lobby.
 			client->GetCallback().SignalNetClientWaitDialog();
-		client->GetCallback().SignalNetClientRemovedFromGame(removedData.removeReason);
+			client->GetCallback().SignalNetClientRemovedFromGame(netRemoved->removedFromGameReason);
 			client->SetState(ClientStateWaitJoin::Instance());
 		}
-	else if (tmpPacket->ToNetPacketTimeoutWarning())
+		else if (netGamePlayer->gamePlayerNotification.present == gamePlayerNotification_PR_gamePlayerLeft)
 		{
-		NetPacketTimeoutWarning::Data warningData;
+			// A player left the game.
-		tmpPacket->ToNetPacketTimeoutWarning()->GetData(warningData);
+			GamePlayerLeft_t *netLeft = &netGamePlayer->gamePlayerNotification.choice.gamePlayerLeft;
-		client->GetCallback().SignalNetClientShowTimeoutDialog(warningData.timeoutReason, warningData.remainingSeconds);
+
+			// Signal to GUI and remove from data list.
+			client->RemovePlayerData(netLeft->playerId, netLeft->gamePlayerLeftReason);
 		}
-	else if (tmpPacket->ToNetPacketChatText())
+		else if (netGamePlayer->gamePlayerNotification.present == gamePlayerNotification_PR_gameAdminChanged)
+		{
+			// New admin for the game.
+			GameAdminChanged_t *netChanged = &netGamePlayer->gamePlayerNotification.choice.gameAdminChanged;
+
+			// Set new game admin and signal to GUI.
+			client->SetNewGameAdmin(netChanged->newAdminPlayerId);
+		}
+	}
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_timeoutWarningMessage)
+	{
+		TimeoutWarningMessage_t *tmpTimeout = &tmpPacket->GetMsg()->choice.timeoutWarningMessage;
+		client->GetCallback().SignalNetClientShowTimeoutDialog((NetTimeoutReason)tmpTimeout->timeoutReason, tmpTimeout->remainingSeconds);
+	}
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_chatMessage)
 	{
 		// Chat message - display it in the GUI.
-		NetPacketChatText::Data chatData;
+		ChatMessage_t *netMessage = &tmpPacket->GetMsg()->choice.chatMessage;
-		tmpPacket->ToNetPacketChatText()->GetData(chatData);
 
 		string playerName;
-		if (chatData.playerId == 0)
+		if (netMessage->playerId == 0)
 		{
 			playerName = "(global notice)";
 		}
 		else
 		{
-			boost::shared_ptr<PlayerData> tmpPlayer = client->GetPlayerDataByUniqueId(chatData.playerId);
+			boost::shared_ptr<PlayerData> tmpPlayer = client->GetPlayerDataByUniqueId(netMessage->playerId);
 			if (tmpPlayer.get())
 				playerName = tmpPlayer->GetName();
 		}
 		if (!playerName.empty())
-			client->GetCallback().SignalNetClientChatMsg(playerName, chatData.text);
+			client->GetCallback().SignalNetClientChatMsg(playerName, STL_STRING_FROM_OCTET_STRING(netMessage->chatText));
 	}
-	else if (tmpPacket->ToNetPacketMsgBoxText())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_dialogMessage)
 	{
 		// Message box - display it in the GUI.
-		NetPacketMsgBoxText::Data msgData;
+		DialogMessage_t *netDialog = &tmpPacket->GetMsg()->choice.dialogMessage;
-		tmpPacket->ToNetPacketMsgBoxText()->GetData(msgData);
+		client->GetCallback().SignalNetClientMsgBox(STL_STRING_FROM_OCTET_STRING(netDialog->notificationText));
-		client->GetCallback().SignalNetClientMsgBox(msgData.text);
 	}
-	else if (tmpPacket->ToNetPacketPlayerLeft())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_gameListMessage)
 	{
-		// A player left the game.
+		GameListMessage_t *netGameList = &tmpPacket->GetMsg()->choice.gameListMessage;
-		NetPacketPlayerLeft::Data playerLeftData;
+		unsigned gameId = netGameList->gameId;
-		tmpPacket->ToNetPacketPlayerLeft()->GetData(playerLeftData);
 
-		// Signal to GUI and remove from data list.
+		if (netGameList->gameListNotification.present == gameListNotification_PR_gameListNew)
-		client->RemovePlayerData(playerLeftData.playerId, playerLeftData.removeReason);
-	}
-	else if (tmpPacket->ToNetPacketGameAdminChanged())
-	{
-		// New admin for the game.
-		NetPacketGameAdminChanged::Data adminChangedData;
-		tmpPacket->ToNetPacketGameAdminChanged()->GetData(adminChangedData);
-
-		// Set new game admin and signal to GUI.
-		client->SetNewGameAdmin(adminChangedData.playerId);
-	}
-	else if (tmpPacket->ToNetPacketGameListNew())
 		{
 			// A new game was created on the server.
-		NetPacketGameListNew::Data gameListNewData;
+			GameListNew_t *netListNew = &netGameList->gameListNotification.choice.gameListNew;
-		tmpPacket->ToNetPacketGameListNew()->GetData(gameListNewData);
 
+			NonZeroId_t **playerIds = netListNew->playerIds.list.array;
+			unsigned numPlayers = netListNew->playerIds.list.count;
 			// Request player info for players if needed.
-		PlayerIdList::const_iterator i = gameListNewData.gameInfo.players.begin();
+			if (numPlayers && playerIds && *playerIds)
-		PlayerIdList::const_iterator end = gameListNewData.gameInfo.players.end();
+			{
-		while (i != end)
+				GameInfo tmpInfo;
+				for (unsigned i = 0; i < numPlayers; i++)
 				{
 					PlayerInfo info;
-			if (!client->GetCachedPlayerInfo(*i, info))
+					unsigned playerId = *playerIds[i];
+					if (!client->GetCachedPlayerInfo(playerId, info))
 					{
 						// Request player info.
-				client->RequestPlayerInfo(*i);
+						client->RequestPlayerInfo(playerId);
 					}
+					tmpInfo.players.push_back(playerId);
 					++i;
 				}
+				tmpInfo.adminPlayerId = netListNew->adminPlayerId;
+				tmpInfo.isPasswordProtected = netListNew->isPrivate ? true : false;
+				tmpInfo.mode = GAME_MODE_CREATED;
+				tmpInfo.name = STL_STRING_FROM_OCTET_STRING(netListNew->gameInfo.gameName);
+				NetPacket::GetGameData(&netListNew->gameInfo, tmpInfo.data);
 
-		client->AddGameInfo(gameListNewData.gameId, gameListNewData.gameInfo);
+				client->AddGameInfo(gameId, tmpInfo);
 			}
-	else if (tmpPacket->ToNetPacketGameListUpdate())
+		}
+		else if (netGameList->gameListNotification.present == gameListNotification_PR_gameListUpdate)
 		{
 			// An existing game was updated on the server.
-		NetPacketGameListUpdate::Data gameListUpdateData;
+			GameListUpdate_t *netListUpdate = &netGameList->gameListNotification.choice.gameListUpdate;
-		tmpPacket->ToNetPacketGameListUpdate()->GetData(gameListUpdateData);
+			if (netListUpdate->gameMode == NetGameMode_gameClosed)
-		if (gameListUpdateData.gameMode == GAME_MODE_CLOSED)
+				client->RemoveGameInfo(gameId);
-			client->RemoveGameInfo(gameListUpdateData.gameId);
 			else
-			client->UpdateGameInfoMode(gameListUpdateData.gameId, gameListUpdateData.gameMode);
+				client->UpdateGameInfoMode(gameId, static_cast<GameMode>(netListUpdate->gameMode));
 		}
-	else if (tmpPacket->ToNetPacketGameListPlayerJoined())
+		else if (netGameList->gameListNotification.present == gameListNotification_PR_gameListPlayerJoined)
 		{
-		NetPacketGameListPlayerJoined::Data playerJoinedData;
+			GameListPlayerJoined_t *netListJoined = &netGameList->gameListNotification.choice.gameListPlayerJoined;
-		tmpPacket->ToNetPacketGameListPlayerJoined()->GetData(playerJoinedData);
+
-		client->ModifyGameInfoAddPlayer(playerJoinedData.gameId, playerJoinedData.playerId);
+			client->ModifyGameInfoAddPlayer(gameId, netListJoined->playerId);
 			// Request player info if needed.
 			PlayerInfo info;
-		if (!client->GetCachedPlayerInfo(playerJoinedData.playerId, info))
+			if (!client->GetCachedPlayerInfo(netListJoined->playerId, info))
 			{
-			client->RequestPlayerInfo(playerJoinedData.playerId);
+				client->RequestPlayerInfo(netListJoined->playerId);
 			}
 		}
-	else if (tmpPacket->ToNetPacketGameListPlayerLeft())
+		else if (netGameList->gameListNotification.present == gameListNotification_PR_gameListPlayerLeft)
 		{
-		NetPacketGameListPlayerLeft::Data playerLeftData;
+			GameListPlayerLeft_t *netListLeft = &netGameList->gameListNotification.choice.gameListPlayerLeft;
-		tmpPacket->ToNetPacketGameListPlayerLeft()->GetData(playerLeftData);
+
-		client->ModifyGameInfoRemovePlayer(playerLeftData.gameId, playerLeftData.playerId);
+			client->ModifyGameInfoRemovePlayer(gameId, netListLeft->playerId);
 		}
-	else if (tmpPacket->ToNetPacketGameListAdminChanged())
+		else if (netGameList->gameListNotification.present == gameListNotification_PR_gameListAdminChanged)
 		{
-		NetPacketGameListAdminChanged::Data adminChangedData;
+			GameListAdminChanged_t *netListAdmin = &netGameList->gameListNotification.choice.gameListAdminChanged;
-		tmpPacket->ToNetPacketGameListAdminChanged()->GetData(adminChangedData);
+
-		client->UpdateGameInfoAdmin(adminChangedData.gameId, adminChangedData.newAdminplayerId);
+			client->UpdateGameInfoAdmin(gameId, netListAdmin->newAdminPlayerId);
 		}
-	else if (tmpPacket->ToNetPacketStartKickPlayerPetition())
+	}
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_startKickPetitionMessage)
 	{
-		NetPacketStartKickPlayerPetition::Data startPetitionData;
+		StartKickPetitionMessage_t *netStartPetition = &tmpPacket->GetMsg()->choice.startKickPetitionMessage;
-		tmpPacket->ToNetPacketStartKickPlayerPetition()->GetData(startPetitionData);
+		client->StartPetition(netStartPetition->petitionId, netStartPetition->proposingPlayerId,
-		client->StartPetition(startPetitionData.petitionId, startPetitionData.proposingPlayerId,
+			netStartPetition->kickPlayerId, netStartPetition->kickTimeoutSec, netStartPetition->numVotesNeededToKick);
-			startPetitionData.kickPlayerId, startPetitionData.kickTimeoutSec, startPetitionData.numVotesNeededToKick);
 	}
-	else if (tmpPacket->ToNetPacketKickPlayerPetitionUpdate())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_kickPetitionUpdateMessage)
 	{
-		NetPacketKickPlayerPetitionUpdate::Data updatePetitionData;
+		KickPetitionUpdateMessage_t *netPetitionUpdate = &tmpPacket->GetMsg()->choice.kickPetitionUpdateMessage;
-		tmpPacket->ToNetPacketKickPlayerPetitionUpdate()->GetData(updatePetitionData);
+		client->UpdatePetition(netPetitionUpdate->petitionId, netPetitionUpdate->numVotesAgainstKicking,
-		client->UpdatePetition(updatePetitionData.petitionId, updatePetitionData.numVotesAgainstKicking,
+			netPetitionUpdate->numVotesInFavourOfKicking, netPetitionUpdate->numVotesNeededToKick);
-			updatePetitionData.numVotesInFavourOfKicking, updatePetitionData.numVotesNeededToKick);
 	}
-	else if (tmpPacket->ToNetPacketEndKickPlayerPetition())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_endKickPetitionMessage)
 	{
-		NetPacketEndKickPlayerPetition::Data endPetitionData;
+		EndKickPetitionMessage_t *netEndPetition = &tmpPacket->GetMsg()->choice.endKickPetitionMessage;
-		tmpPacket->ToNetPacketEndKickPlayerPetition()->GetData(endPetitionData);
+		client->EndPetition(netEndPetition->petitionId);
-		client->EndPetition(endPetitionData.petitionId);
 	}
-	else if (tmpPacket->ToNetPacketAvatarHeader())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_avatarReplyMessage)
 	{
-		NetPacketAvatarHeader::Data headerData;
+		AvatarReplyMessage_t *netAvatarReply = &tmpPacket->GetMsg()->choice.avatarReplyMessage;
-		tmpPacket->ToNetPacketAvatarHeader()->GetData(headerData);
+		unsigned requestId = netAvatarReply->requestId;
-		client->AddTempAvatarData(headerData.requestId, headerData.avatarFileSize, headerData.avatarFileType);
+		if (netAvatarReply->avatarResult.present == avatarResult_PR_avatarHeader)
-	}
-	else if (tmpPacket->ToNetPacketAvatarFile())
 		{
-		NetPacketAvatarFile::Data fileData;
+			AvatarHeader_t *netAvatarHeader = &netAvatarReply->avatarResult.choice.avatarHeader;
-		tmpPacket->ToNetPacketAvatarFile()->GetData(fileData);
+			client->AddTempAvatarFile(requestId, netAvatarHeader->avatarSize, static_cast<AvatarFileType>(netAvatarHeader->avatarType));
-		client->StoreInTempAvatarData(fileData.requestId, fileData.fileData);
 		}
-	else if (tmpPacket->ToNetPacketAvatarEnd())
+		else if (netAvatarReply->avatarResult.present == avatarResult_PR_avatarData)
 		{
-		NetPacketAvatarEnd::Data endData;
+			AvatarData_t *netAvatarData = &netAvatarReply->avatarResult.choice.avatarData;
-		tmpPacket->ToNetPacketAvatarEnd()->GetData(endData);
+			vector<unsigned char> fileData(netAvatarData->avatarBlock.size);
-		client->CompleteTempAvatarData(endData.requestId);
+			memcpy(&fileData[0], netAvatarData->avatarBlock.buf, netAvatarData->avatarBlock.size);
+			client->StoreInTempAvatarFile(requestId, fileData);
 		}
-	else if (tmpPacket->ToNetPacketUnknownAvatar())
+		else if (netAvatarReply->avatarResult.present == avatarResult_PR_avatarEnd)
 		{
-		NetPacketUnknownAvatar::Data unknownAvatarData;
+			client->CompleteTempAvatarFile(requestId);
-		tmpPacket->ToNetPacketUnknownAvatar()->GetData(unknownAvatarData);
-		client->SetUnknownAvatar(unknownAvatarData.requestId);
 		}
-	else if (tmpPacket->ToNetPacketStatisticsChanged())
+		else if (netAvatarReply->avatarResult.present == avatarResult_PR_unknownAvatar)
 		{
-		NetPacketStatisticsChanged::Data statData;
+			client->SetUnknownAvatar(requestId);
-		tmpPacket->ToNetPacketStatisticsChanged()->GetData(statData);
-		client->UpdateStatData(statData.stats);
 		}
-	else if (tmpPacket->ToNetPacketError())
+	}
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_statisticsMessage)
+	{
+		StatisticsMessage_t *netStatistics = &tmpPacket->GetMsg()->choice.statisticsMessage;
+
+		StatisticsData **statData = netStatistics->statisticsData.list.array;
+		unsigned numStats = netStatistics->statisticsData.list.count;
+		// Request player info for players if needed.
+		if (numStats && statData && *statData)
+		{
+			ServerStats tmpStats;
+			for (unsigned i = 0; i < numStats; i++)
+			{
+				if (statData[i]->statisticsType == statisticsType_statNumberOfPlayers)
+					tmpStats.numberOfPlayersOnServer = statData[i]->statisticsValue;
+			}
+			client->UpdateStatData(tmpStats);
+		}
+	}
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_errorMessage)
 	{
 		// Server reported an error.
-		NetPacketError::Data errorData;
+		ErrorMessage_t *netError = &tmpPacket->GetMsg()->choice.errorMessage;
-		tmpPacket->ToNetPacketError()->GetData(errorData);
 		// Show the error.
-		throw ClientException(__FILE__, __LINE__, errorData.errorCode, 0);
+		throw ClientException(__FILE__, __LINE__, NetPacket::NetErrorToGameError(netError->errorReason), 0);
 	}
 	else
 		InternalHandlePacket(client, tmpPacket);
@@ -929,33 +980,37 @@ ClientStateWaitSession::Exit(boost::shared_ptr<ClientThread> /*client*/)
 void
 ClientStateWaitSession::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
 {
-	if (tmpPacket->ToNetPacketInitAck())
+	if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_initAckMessage)
 	{
 		// Everything is fine - we are in the lobby.
-		NetPacketInitAck::Data initAckData;
+		InitAckMessage_t *netInitAck = &tmpPacket->GetMsg()->choice.initAckMessage;
-		tmpPacket->ToNetPacketInitAck()->GetData(initAckData);
 		// Check current game version.
-		if (initAckData.latestGameVersion != POKERTH_VERSION)
+		if (netInitAck->latestGameVersion.major != POKERTH_VERSION_MAJOR
+			|| netInitAck->latestGameVersion.minor != POKERTH_VERSION_MINOR)
+		{
 			client->GetCallback().SignalNetClientNotification(NTF_NET_NEW_RELEASE_AVAILABLE);
-		else if (POKERTH_BETA_REVISION && initAckData.latestBetaRevision != POKERTH_BETA_REVISION)
+		}
+		else if (POKERTH_BETA_REVISION && netInitAck->latestBetaRevision != POKERTH_BETA_REVISION)
+		{
 			client->GetCallback().SignalNetClientNotification(NTF_NET_OUTDATED_BETA);
+		}
 
-		client->SetGuiPlayerId(initAckData.playerId);
+		client->SetGuiPlayerId(netInitAck->yourPlayerId);
 
 		client->SetSessionEstablished(true);
 		client->GetCallback().SignalNetClientConnect(MSG_SOCK_SESSION_DONE);
 		client->SetState(ClientStateWaitJoin::Instance());
 	}
-	else if (tmpPacket->ToNetPacketRetrieveAvatar())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_avatarRequestMessage)
 	{
 		// Before letting us join the lobby, the server requests our avatar.
-		NetPacketRetrieveAvatar::Data retrieveAvatarData;
+		AvatarRequestMessage_t *netAvatarRequest = &tmpPacket->GetMsg()->choice.avatarRequestMessage;
-		tmpPacket->ToNetPacketRetrieveAvatar()->GetData(retrieveAvatarData);
 
+		// TODO compare SHA1.
 		NetPacketList tmpList;
 		int avatarError = client->GetAvatarManager().AvatarFileToNetPackets(
 			client->GetQtToolsInterface().stringFromUtf8(client->GetContext().GetAvatarFile()),
-			retrieveAvatarData.requestId,
+			netAvatarRequest->requestId,
 			tmpList);
 
 		if (!avatarError)
@@ -997,17 +1052,23 @@ ClientStateWaitJoin::InternalHandlePacket(boost::shared_ptr<ClientThread> client
 {
 	ClientContext &context = client->GetContext();
 
-	if (tmpPacket->ToNetPacketJoinGameAck())
+	if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_joinGameReplyMessage)
+	{
+		JoinGameReplyMessage_t *netJoinReply = &tmpPacket->GetMsg()->choice.joinGameReplyMessage;
+		unsigned gameId = netJoinReply->gameId;
+		if (netJoinReply->joinGameResult.present == joinGameResult_PR_joinGameAck)
 		{
 			// Successfully joined a game.
-		NetPacketJoinGameAck::Data joinGameAckData;
+			JoinGameAck_t *netJoinAck = &netJoinReply->joinGameResult.choice.joinGameAck;
-		tmpPacket->ToNetPacketJoinGameAck()->GetData(joinGameAckData);
+			client->SetGameId(gameId);
-		client->SetGameId(joinGameAckData.gameId);
+			GameData tmpData;
-		client->SetGameData(joinGameAckData.gameData);
+			NetPacket::GetGameData(&netJoinAck->gameInfo, tmpData);
+			client->SetGameData(tmpData);
 
 			// Player number is 0 on init. Will be set when the game starts.
 			boost::shared_ptr<PlayerData> playerData(
-			new PlayerData(client->GetGuiPlayerId(), 0, PLAYER_TYPE_HUMAN, joinGameAckData.prights));
+				new PlayerData(client->GetGuiPlayerId(), 0, PLAYER_TYPE_HUMAN,
+					netJoinAck->areYouAdmin ? PLAYER_RIGHTS_ADMIN : PLAYER_RIGHTS_NORMAL));
 			playerData->SetName(context.GetPlayerName());
 			playerData->SetAvatarFile(context.GetAvatarFile());
 			client->AddPlayerData(playerData);
@@ -1015,12 +1076,33 @@ ClientStateWaitJoin::InternalHandlePacket(boost::shared_ptr<ClientThread> client
 			client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_JOIN);
 			client->SetState(ClientStateWaitGame::Instance());
 		}
-	else if (tmpPacket->ToNetPacketJoinGameFailed())
+		else if (netJoinReply->joinGameResult.present == joinGameResult_PR_joinGameFailed)
 		{
 			// Failed to join a game.
-		NetPacketJoinGameFailed::Data joinGameFailedData;
+			JoinGameFailed_t *netJoinFailed = &netJoinReply->joinGameResult.choice.joinGameFailed;
-		tmpPacket->ToNetPacketJoinGameFailed()->GetData(joinGameFailedData);
+
-		client->GetCallback().SignalNetClientNotification(joinGameFailedData.failureCode);
+			int failureCode;
+			switch (netJoinFailed->joinGameFailureReason)
+			{
+				case joinGameFailureReason_invalidGame :
+					failureCode = NTF_NET_JOIN_GAME_INVALID;
+					break;
+				case joinGameFailureReason_gameIsFull :
+					failureCode = NTF_NET_JOIN_GAME_FULL;
+					break;
+				case joinGameFailureReason_gameIsRunning :
+					failureCode = NTF_NET_JOIN_ALREADY_RUNNING;
+					break;
+				case joinGameFailureReason_invalidPassword :
+					failureCode = NTF_NET_JOIN_INVALID_PASSWORD;
+					break;
+				default :
+					failureCode = NTF_NET_INTERNAL;
+					break;
+			}
+
+			client->GetCallback().SignalNetClientNotification(failureCode);
+		}
 	}
 }
 
@@ -1054,22 +1136,25 @@ ClientStateWaitGame::Exit(boost::shared_ptr<ClientThread> /*client*/)
 void
 ClientStateWaitGame::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
 {
-	if (tmpPacket->ToNetPacketStartEvent())
+	if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_startEventMessage)
 	{
 		client->SetState(ClientStateSynchronizeStart::Instance());
 	}
-	else if (tmpPacket->ToNetPacketPlayerJoined())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_gamePlayerMessage)
+	{
+		GamePlayerMessage_t *netGamePlayer = &tmpPacket->GetMsg()->choice.gamePlayerMessage;
+//		unsigned gameId = netGamePlayer->gameId;
+		if (netGamePlayer->gamePlayerNotification.present == gamePlayerNotification_PR_gamePlayerJoined)
 		{
 			// Another player joined the network game.
-		NetPacketPlayerJoined::Data netPlayerData;
+			GamePlayerJoined_t *netPlayerJoined = &netGamePlayer->gamePlayerNotification.choice.gamePlayerJoined;
-		tmpPacket->ToNetPacketPlayerJoined()->GetData(netPlayerData);
 
 			boost::shared_ptr<PlayerData> playerData;
 			PlayerInfo info;
-		if (client->GetCachedPlayerInfo(netPlayerData.playerId, info))
+			if (client->GetCachedPlayerInfo(netPlayerJoined->playerId, info))
 			{
 				playerData.reset(
-				new PlayerData(netPlayerData.playerId, 0, info.ptype, netPlayerData.prights));
+					new PlayerData(netPlayerJoined->playerId, 0, info.ptype, netPlayerJoined->isAdmin ? PLAYER_RIGHTS_ADMIN : PLAYER_RIGHTS_NORMAL));
 				playerData->SetName(info.playerName);
 				if (info.hasAvatar)
 				{
@@ -1077,23 +1162,24 @@ ClientStateWaitGame::InternalHandlePacket(boost::shared_ptr<ClientThread> client
 					if (client->GetAvatarManager().GetAvatarFileName(info.avatar, avatarFile))
 						playerData->SetAvatarFile(client->GetQtToolsInterface().stringToUtf8(avatarFile));
 					else
-					client->RetrieveAvatarIfNeeded(netPlayerData.playerId, info);
+						client->RetrieveAvatarIfNeeded(netPlayerJoined->playerId, info);
 				}
 			}
 			else
 			{
 				ostringstream name;
-			name << "#" << netPlayerData.playerId;
+				name << "#" << netPlayerJoined->playerId;
 
 				// Request player info.
-			client->RequestPlayerInfo(netPlayerData.playerId, true);
+				client->RequestPlayerInfo(netPlayerJoined->playerId, true);
 				// Use temporary data until the PlayerInfo request is completed.
 				playerData.reset(
-				new PlayerData(netPlayerData.playerId, 0, PLAYER_TYPE_HUMAN, netPlayerData.prights));
+					new PlayerData(netPlayerJoined->playerId, 0, PLAYER_TYPE_HUMAN, netPlayerJoined->isAdmin ? PLAYER_RIGHTS_ADMIN : PLAYER_RIGHTS_NORMAL));
 				playerData->SetName(name.str());
 			}
 			client->AddPlayerData(playerData);
 		}
+	}
 }
 
 //-----------------------------------------------------------------------------
@@ -1137,7 +1223,11 @@ ClientStateSynchronizeStart::TimerLoop(const boost::system::error_code& ec, boos
 		if (client->IsSynchronized())
 		{
 			// Acknowledge start.
-			boost::shared_ptr<NetPacket> startAck(new NetPacketStartEventAck);
+			boost::shared_ptr<NetPacket> startAck(new NetPacket(NetPacket::Alloc));
+			startAck->GetMsg()->present = PokerTHMessage_PR_startEventAckMessage;
+			StartEventAckMessage_t *netStartAck = &startAck->GetMsg()->choice.startEventAckMessage;
+			netStartAck->gameId = client->GetGameId();
+
 			client->GetSender().Send(client->GetContext().GetSessionData(), startAck);
 			// Unsubscribe lobby messages.
 			client->UnsubscribeLobbyMsg();
@@ -1158,7 +1248,7 @@ ClientStateSynchronizeStart::TimerLoop(const boost::system::error_code& ec, boos
 void
 ClientStateSynchronizeStart::InternalHandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> tmpPacket)
 {
-	if (tmpPacket->ToNetPacketGameStart())
+	if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_gameStartMessage)
 		throw ClientException(__FILE__, __LINE__, ERR_NET_START_TIMEOUT, 0);
 }
 
@@ -1192,30 +1282,35 @@ ClientStateWaitStart::Exit(boost::shared_ptr<ClientThread> /*client*/)
 void
 ClientStateWaitStart::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
 {
-	if (tmpPacket->ToNetPacketGameStart())
+	if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_gameStartMessage)
 	{
 		// Start the network game as client.
-		NetPacketGameStart::Data gameStartData;
+		GameStartMessage_t *netGameStart = &tmpPacket->GetMsg()->choice.gameStartMessage;
-		tmpPacket->ToNetPacketGameStart()->GetData(gameStartData);
 
-		client->SetStartData(gameStartData.startData);
+		StartData startData;
+		startData.numberOfPlayers = netGameStart->playerSeats.list.count;
+		startData.startDealerPlayerId = netGameStart->startDealerPlayerId;
+		client->SetStartData(startData);
 
 		// Set player numbers using the game start data slots.
-		NetPacketGameStart::PlayerSlotList::const_iterator slot_i = gameStartData.playerSlots.begin();
+		NonZeroId_t **playerIds = netGameStart->playerSeats.list.array;
-		NetPacketGameStart::PlayerSlotList::const_iterator slot_end = gameStartData.playerSlots.end();
+		unsigned numPlayers = netGameStart->playerSeats.list.count;
-		int num = 0;
+		// Request player info for players if needed.
-
+		if (numPlayers && playerIds && *playerIds)
-		while (slot_i != slot_end)
 		{
-			unsigned playerId = (*slot_i).playerId;
+			for (unsigned i = 0; i < numPlayers; i++)
+			{
+				unsigned playerId = *playerIds[i];
 				boost::shared_ptr<PlayerData> tmpPlayer = client->GetPlayerDataByUniqueId(playerId);
 				if (!tmpPlayer.get())
 					throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
-			tmpPlayer->SetNumber(num);
+				tmpPlayer->SetNumber(i);
 
-			++num;
+				++i;
-			++slot_i;
 			}
+		}
+		else
+			throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_PLAYER_COUNT, 0);
 
 		client->InitGame();
 		client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_START);
@@ -1253,21 +1348,21 @@ ClientStateWaitHand::Exit(boost::shared_ptr<ClientThread> /*client*/)
 void
 ClientStateWaitHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
 {
-	if (tmpPacket->ToNetPacketHandStart())
+	if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_handStartMessage)
 	{
 		// Remove all players which left the server.
 		client->RemoveDisconnectedPlayers();
+
 		// Hand was started.
 		// These are the cards. Good luck.
-		NetPacketHandStart::Data tmpData;
+		HandStartMessage_t *netHandStart = &tmpPacket->GetMsg()->choice.handStartMessage;
-		tmpPacket->ToNetPacketHandStart()->GetData(tmpData);
 		int myCards[2];
-		myCards[0] = (int)tmpData.yourCards[0];
+		myCards[0] = (int)netHandStart->yourCard1;
-		myCards[1] = (int)tmpData.yourCards[1];
+		myCards[1] = (int)netHandStart->yourCard2;
 		client->GetGame()->getSeatsList()->front()->setMyCards(myCards);
 		client->GetGame()->initHand();
-		client->GetGame()->getCurrentHand()->setSmallBlind(tmpData.smallBlind);
+		client->GetGame()->getCurrentHand()->setSmallBlind(netHandStart->smallBlind);
-		client->GetGame()->getCurrentHand()->getCurrentBeRo()->setMinimumRaise(2 * tmpData.smallBlind);
+		client->GetGame()->getCurrentHand()->getCurrentBeRo()->setMinimumRaise(2 * netHandStart->smallBlind);
 		client->GetGame()->startHand();
 		client->GetGui().dealHoleCards();
 		client->GetGui().refreshGameLabels(GAME_STATE_PREFLOP);
@@ -1277,14 +1372,14 @@ ClientStateWaitHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client
 		client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_HAND_START);
 		client->SetState(ClientStateRunHand::Instance());
 	}
-	else if (tmpPacket->ToNetPacketEndOfGame())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_endOfGameMessage)
 	{
 		boost::shared_ptr<Game> curGame = client->GetGame();
 		if (curGame.get())
 		{
-			NetPacketEndOfGame::Data endData;
+			EndOfGameMessage_t *netEndOfGame = &tmpPacket->GetMsg()->choice.endOfGameMessage;
-			tmpPacket->ToNetPacketEndOfGame()->GetData(endData);
+
-			boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(endData.winnerPlayerId);
+			boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(netEndOfGame->winnerPlayerId);
 			if (!tmpPlayer)
 				throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
 			client->GetGui().logPlayerWinGame(tmpPlayer->getMyName(), curGame->getMyGameID());
@@ -1329,22 +1424,22 @@ void
 ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
 {
 	boost::shared_ptr<Game> curGame = client->GetGame();
-	if (tmpPacket->ToNetPacketPlayersActionDone())
+	if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_playersActionDoneMessage)
 	{
-		NetPacketPlayersActionDone::Data actionDoneData;
+		PlayersActionDoneMessage_t *netActionDone = &tmpPacket->GetMsg()->choice.playersActionDoneMessage;
-		tmpPacket->ToNetPacketPlayersActionDone()->GetData(actionDoneData);
+
-		boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(actionDoneData.playerId);
+		boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(netActionDone->playerId);
 		if (!tmpPlayer)
 			throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
 
 		bool isBigBlind = false;
 
-		if (actionDoneData.gameState == GAME_STATE_PREFLOP_SMALL_BLIND)
+		if (netActionDone->gameState == NetGameState_statePreflopSmallBlind)
 		{
 			curGame->getCurrentHand()->getCurrentBeRo()->setSmallBlindPositionId(tmpPlayer->getMyUniqueID());
 			tmpPlayer->setMyButton(BUTTON_SMALL_BLIND);
 		}
-		else if (actionDoneData.gameState == GAME_STATE_PREFLOP_BIG_BLIND)
+		else if (netActionDone->gameState == NetGameState_statePreflopBigBlind)
 		{
 			curGame->getCurrentHand()->getCurrentBeRo()->setBigBlindPositionId(tmpPlayer->getMyUniqueID());
 			tmpPlayer->setMyButton(BUTTON_BIG_BLIND);
@@ -1352,29 +1447,33 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 		}
 		else // no blind -> log
 		{
-			if (actionDoneData.playerAction)
+			if (netActionDone->playerAction)
 			{
-				assert(actionDoneData.totalPlayerBet >= (unsigned)tmpPlayer->getMySet());
+				assert(netActionDone->totalPlayerBet >= (long)tmpPlayer->getMySet());
 				client->GetGui().logPlayerActionMsg(
 					tmpPlayer->getMyName(),
-					actionDoneData.playerAction,
+					netActionDone->playerAction,
-					actionDoneData.totalPlayerBet - tmpPlayer->getMySet());
+					netActionDone->totalPlayerBet - tmpPlayer->getMySet());
 			}
 			// Update last players turn only after the blinds.
 			curGame->getCurrentHand()->setLastPlayersTurn(tmpPlayer->getMyID());
 		}
 
-		tmpPlayer->setMyAction(actionDoneData.playerAction);
+		tmpPlayer->setMyAction(netActionDone->playerAction);
-		tmpPlayer->setMySetAbsolute(actionDoneData.totalPlayerBet);
+		tmpPlayer->setMySetAbsolute(netActionDone->totalPlayerBet);
-		tmpPlayer->setMyCash(actionDoneData.playerMoney);
+		tmpPlayer->setMyCash(netActionDone->playerMoney);
-		curGame->getCurrentHand()->getCurrentBeRo()->setHighestSet(actionDoneData.highestSet);
+		curGame->getCurrentHand()->getCurrentBeRo()->setHighestSet(netActionDone->highestSet);
-		curGame->getCurrentHand()->getCurrentBeRo()->setMinimumRaise(actionDoneData.minimumRaise);
+		curGame->getCurrentHand()->getCurrentBeRo()->setMinimumRaise(netActionDone->minimumRaise);
 		curGame->getCurrentHand()->getBoard()->collectSets();
 		curGame->getCurrentHand()->switchRounds();
 
 		//log blinds sets after setting bigblind-button
 		if (isBigBlind) {
-			client->GetGui().logNewBlindsSetsMsg(curGame->getPlayerByUniqueId(curGame->getCurrentHand()->getCurrentBeRo()->getSmallBlindPositionId())->getMySet(), curGame->getPlayerByUniqueId(curGame->getCurrentHand()->getCurrentBeRo()->getBigBlindPositionId())->getMySet(), curGame->getPlayerByUniqueId(curGame->getCurrentHand()->getCurrentBeRo()->getSmallBlindPositionId())->getMyName(),  curGame->getPlayerByUniqueId(curGame->getCurrentHand()->getCurrentBeRo()->getBigBlindPositionId())->getMyName());
+			client->GetGui().logNewBlindsSetsMsg(
+				curGame->getPlayerByUniqueId(curGame->getCurrentHand()->getCurrentBeRo()->getSmallBlindPositionId())->getMySet(),
+				curGame->getPlayerByUniqueId(curGame->getCurrentHand()->getCurrentBeRo()->getBigBlindPositionId())->getMySet(),
+				curGame->getPlayerByUniqueId(curGame->getCurrentHand()->getCurrentBeRo()->getSmallBlindPositionId())->getMyName(),
+				curGame->getPlayerByUniqueId(curGame->getCurrentHand()->getCurrentBeRo()->getBigBlindPositionId())->getMyName());
 			client->GetGui().flushLogAtHand();
 		}
 
@@ -1394,19 +1493,19 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 		client->GetGui().refreshButton();
 		client->GetGui().updateMyButtonsState();
 	}
-	else if (tmpPacket->ToNetPacketPlayersTurn())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_playersTurnMessage)
 	{
-		NetPacketPlayersTurn::Data turnData;
+		PlayersTurnMessage_t *netPlayersTurn = &tmpPacket->GetMsg()->choice.playersTurnMessage;
-		tmpPacket->ToNetPacketPlayersTurn()->GetData(turnData);
+
-		boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(turnData.playerId);
+		boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(netPlayersTurn->playerId);
 		if (!tmpPlayer)
 			throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
 
 		// Set round.
-		if (curGame->getCurrentHand()->getCurrentRound() != turnData.gameState)
+		if (curGame->getCurrentHand()->getCurrentRound() != netPlayersTurn->gameState)
 		{
 			ResetPlayerActions(*curGame);
-			curGame->getCurrentHand()->setCurrentRound(turnData.gameState);
+			curGame->getCurrentHand()->setCurrentRound(netPlayersTurn->gameState);
 			// Refresh actions.
 			client->GetGui().refreshSet();
 			client->GetGui().refreshAction();
@@ -1431,13 +1530,14 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 		if (tmpPlayer->getMyID() == 0) // Is this the GUI player?
 			client->GetGui().meInAction();
 	}
-	else if (tmpPacket->ToNetPacketDealFlopCards())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_dealFlopCardsMessage)
 	{
-		NetPacketDealFlopCards::Data cardsData;
+		DealFlopCardsMessage_t *netDealFlop = &tmpPacket->GetMsg()->choice.dealFlopCardsMessage;
-		tmpPacket->ToNetPacketDealFlopCards()->GetData(cardsData);
+
 		int tmpCards[5];
-		for (int num = 0; num < 3; num++)
+		tmpCards[0] = static_cast<int>(netDealFlop->flopCard1);
-			tmpCards[num] = static_cast<int>(cardsData.flopCards[num]);
+		tmpCards[1] = static_cast<int>(netDealFlop->flopCard2);
+		tmpCards[2] = static_cast<int>(netDealFlop->flopCard3);
 		tmpCards[3] = tmpCards[4] = 0;
 		curGame->getCurrentHand()->getBoard()->setMyCards(tmpCards);
 		curGame->getCurrentHand()->getBoard()->collectPot();
@@ -1449,13 +1549,13 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 		client->GetGui().refreshSet();
 		client->GetGui().dealBeRoCards(1);
 	}
-	else if (tmpPacket->ToNetPacketDealTurnCard())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_dealTurnCardMessage)
 	{
-		NetPacketDealTurnCard::Data cardsData;
+		DealTurnCardMessage_t *netDealTurn = &tmpPacket->GetMsg()->choice.dealTurnCardMessage;
-		tmpPacket->ToNetPacketDealTurnCard()->GetData(cardsData);
+
 		int tmpCards[5];
 		curGame->getCurrentHand()->getBoard()->getMyCards(tmpCards);
-		tmpCards[3] = static_cast<int>(cardsData.turnCard);
+		tmpCards[3] = static_cast<int>(netDealTurn->turnCard);
 		curGame->getCurrentHand()->getBoard()->setMyCards(tmpCards);
 		curGame->getCurrentHand()->getBoard()->collectPot();
 		curGame->getCurrentHand()->setLastPlayersTurn(-1);
@@ -1466,13 +1566,13 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 		client->GetGui().refreshSet();
 		client->GetGui().dealBeRoCards(2);
 	}
-	else if (tmpPacket->ToNetPacketDealRiverCard())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_dealRiverCardMessage)
 	{
-		NetPacketDealRiverCard::Data cardsData;
+		DealRiverCardMessage_t *netDealRiver = &tmpPacket->GetMsg()->choice.dealRiverCardMessage;
-		tmpPacket->ToNetPacketDealRiverCard()->GetData(cardsData);
+
 		int tmpCards[5];
 		curGame->getCurrentHand()->getBoard()->getMyCards(tmpCards);
-		tmpCards[4] = static_cast<int>(cardsData.riverCard);
+		tmpCards[4] = static_cast<int>(netDealRiver->riverCard);
 		curGame->getCurrentHand()->getBoard()->setMyCards(tmpCards);
 		curGame->getCurrentHand()->getBoard()->collectPot();
 		curGame->getCurrentHand()->setLastPlayersTurn(-1);
@@ -1483,34 +1583,42 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 		client->GetGui().refreshSet();
 		client->GetGui().dealBeRoCards(3);
 	}
-	else if (tmpPacket->ToNetPacketAllInShowCards())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_allInShowCardsMessage)
 	{
+		AllInShowCardsMessage_t *netAllInShow = &tmpPacket->GetMsg()->choice.allInShowCardsMessage;
+
 		curGame->getCurrentHand()->setAllInCondition(true);
 
-		NetPacketAllInShowCards::Data allInData;
+		// Set player numbers using the game start data slots.
-		tmpPacket->ToNetPacketAllInShowCards()->GetData(allInData);
+		PlayerAllIn_t **allInPlayers = netAllInShow->playersAllIn.list.array;
-
+		unsigned numPlayers = netAllInShow->playersAllIn.list.count;
-		NetPacketAllInShowCards::PlayerCardsList::const_iterator i
+		// Request player info for players if needed.
-			= allInData.playerCards.begin();
+		if (numPlayers && allInPlayers && *allInPlayers)
-		NetPacketAllInShowCards::PlayerCardsList::const_iterator end
-			= allInData.playerCards.end();
-
-		while (i != end)
 		{
-			boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId((*i).playerId);
+			for (unsigned i = 0; i < numPlayers; i++)
+			{
+				PlayerAllIn_t *p = allInPlayers[i];
+
+				boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(p->playerId);
 				if (!tmpPlayer)
 					throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
 
 				int tmpCards[2];
-			tmpCards[0] = static_cast<int>((*i).cards[0]);
+				tmpCards[0] = static_cast<int>(p->allInCard1);
-			tmpCards[1] = static_cast<int>((*i).cards[1]);
+				tmpCards[1] = static_cast<int>(p->allInCard2);
 				tmpPlayer->setMyCards(tmpCards);
 				++i;
 			}
+		}
 		client->GetGui().flipHolecardsAllIn();
 	}
-	else if (tmpPacket->ToNetPacketEndOfHandHideCards())
+	else if (tmpPacket->GetMsg()->present == PokerTHMessage_PR_endOfHandMessage)
 	{
+		EndOfHandMessage_t *netEndHand = &tmpPacket->GetMsg()->choice.endOfHandMessage;
+
+		if (netEndHand->endOfHandType.present == endOfHandType_PR_endOfHandHideCards)
+		{
+			EndOfHandHideCards_t *hideCards = &netEndHand->endOfHandType.choice.endOfHandHideCards;
 			curGame->getCurrentHand()->getBoard()->collectPot();
 			// Reset player sets
 			ResetPlayerSets(*curGame);
@@ -1520,15 +1628,12 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 			client->GetGui().waitForGuiUpdateDone();
 
 			// End of Hand, but keep cards hidden.
-		NetPacketEndOfHandHideCards::Data endHandData;
+			boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(hideCards->playerId);
-		tmpPacket->ToNetPacketEndOfHandHideCards()->GetData(endHandData);
-
-		boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(endHandData.playerId);
 			if (!tmpPlayer)
 				throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
 
-		tmpPlayer->setMyCash(endHandData.playerMoney);
+			tmpPlayer->setMyCash(hideCards->playerMoney);
-		tmpPlayer->setLastMoneyWon(endHandData.moneyWon);
+			tmpPlayer->setLastMoneyWon(hideCards->moneyWon);
 			list<unsigned> winnerList;
 			winnerList.push_back(tmpPlayer->getMyUniqueID());
 
@@ -1541,8 +1646,10 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 			client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_SERVER_HAND_END);
 			client->SetState(ClientStateWaitHand::Instance());
 		}
-	else if (tmpPacket->ToNetPacketEndOfHandShowCards())
+		else if (netEndHand->endOfHandType.present == endOfHandType_PR_endOfHandShowCards)
 		{
+			EndOfHandShowCards_t *showCards = &netEndHand->endOfHandType.choice.endOfHandShowCards;
+
 			curGame->getCurrentHand()->getBoard()->collectPot();
 			// Reset player sets
 			ResetPlayerSets(*curGame);
@@ -1552,40 +1659,39 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 			client->GetGui().waitForGuiUpdateDone();
 
 			// End of Hand, show cards.
-		NetPacketEndOfHandShowCards::Data endHandData;
-		tmpPacket->ToNetPacketEndOfHandShowCards()->GetData(endHandData);
-
-		NetPacketEndOfHandShowCards::PlayerResultList::const_iterator i
-			= endHandData.playerResults.begin();
-		NetPacketEndOfHandShowCards::PlayerResultList::const_iterator end
-			= endHandData.playerResults.end();
-
 			list<unsigned> winnerList;
 			int highestValueOfCards = 0;
-		while (i != end)
+			PlayerResult_t **playerResults = showCards->playerResults.list.array;
+			unsigned numResults = showCards->playerResults.list.count;
+			// Request player info for players if needed.
+			if (numResults && playerResults && *playerResults)
 			{
-			boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId((*i).playerId);
+				for (unsigned i = 0; i < numResults; i++)
+				{
+					PlayerResult_t *r = playerResults[i];
+
+					boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(r->playerId);
 					if (!tmpPlayer)
 						throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
 
 					int tmpCards[2];
 					int bestHandPos[5];
-			tmpCards[0] = static_cast<int>((*i).cards[0]);
+					tmpCards[0] = static_cast<int>(r->resultCard1);
-			tmpCards[1] = static_cast<int>((*i).cards[1]);
+					tmpCards[1] = static_cast<int>(r->resultCard2);
 					tmpPlayer->setMyCards(tmpCards);
 					for (int num = 0; num < 5; num++)
-				bestHandPos[num] = (*i).bestHandPos[num];
+						bestHandPos[num] = *r->bestHandPosition.list.array[num];
-			tmpPlayer->setMyCardsValueInt((*i).valueOfCards);
+					tmpPlayer->setMyCardsValueInt(r->cardsValue);
 					tmpPlayer->setMyBestHandPosition(bestHandPos);
 					if (tmpPlayer->getMyCardsValueInt() > highestValueOfCards)
 						highestValueOfCards = tmpPlayer->getMyCardsValueInt();
-			tmpPlayer->setMyCash((*i).playerMoney);
+					tmpPlayer->setMyCash(r->playerMoney);
-			tmpPlayer->setLastMoneyWon((*i).moneyWon);
+					tmpPlayer->setLastMoneyWon(r->moneyWon);
-			if ((*i).moneyWon)
+					if (r->moneyWon)
-				winnerList.push_back((*i).playerId);
+						winnerList.push_back(r->playerId);
-
-			++i;
 				}
+			}
+	
 			curGame->getCurrentHand()->getCurrentBeRo()->setHighestCardsValue(highestValueOfCards);
 			curGame->getCurrentHand()->getBoard()->setPot(0);
 			curGame->getCurrentHand()->getBoard()->setWinners(winnerList);
@@ -1596,7 +1702,7 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
 			client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_HAND_END);
 			client->SetState(ClientStateWaitHand::Instance());
 		}
-
+	}
 	// Synchronize with GUI.
 	client->GetGui().waitForGuiUpdateDone();
 }

src/net/common/clientthread.cpp

@@ -119,18 +119,20 @@ ClientThread::SignalTermination()
 void
 ClientThread::SendKickPlayer(unsigned playerId)
 {
-	boost::shared_ptr<NetPacket> request(new NetPacketKickPlayer);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketKickPlayer::Data requestData;
+	packet->GetMsg()->present = PokerTHMessage_PR_kickPlayerRequestMessage;
-	requestData.playerId = playerId;
+	KickPlayerRequestMessage_t *netKick = &packet->GetMsg()->choice.kickPlayerRequestMessage;
-	static_cast<NetPacketKickPlayer *>(request.get())->SetData(requestData);
+	netKick->gameId = GetGameId();
-	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), request));
+	netKick->playerId = playerId;
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
 }
 
 void
 ClientThread::SendLeaveCurrentGame()
 {
-	boost::shared_ptr<NetPacket> request(new NetPacketLeaveCurrentGame);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), request));
+	packet->GetMsg()->present = PokerTHMessage_PR_leaveGameRequestMessage;
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
 }
 
 void
@@ -138,17 +140,12 @@ ClientThread::SendStartEvent(bool fillUpWithCpuPlayers)
 {
 	// Warning: This function is called in the context of the GUI thread.
 	// Create a network packet for the server start event.
-	boost::shared_ptr<NetPacket> start(new NetPacketStartEvent);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketStartEvent::Data startData;
+	packet->GetMsg()->present = PokerTHMessage_PR_startEventMessage;
-	startData.fillUpWithCpuPlayers = fillUpWithCpuPlayers;
+	StartEventMessage_t *netStartEvent = &packet->GetMsg()->choice.startEventMessage;
-	try
+	netStartEvent->gameId = GetGameId();
-	{
+	netStartEvent->fillWithComputerPlayers = fillUpWithCpuPlayers;
-		static_cast<NetPacketStartEvent *>(start.get())->SetData(startData);
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
-		m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), start));
-	} catch (const NetException &e)
-	{
-		LOG_ERROR("ClientThread::SendStartEvent: " << e.what());
-	}
 }
 
 void
@@ -156,25 +153,20 @@ ClientThread::SendPlayerAction()
 {
 	// Warning: This function is called in the context of the GUI thread.
 	// Create a network packet containing the current player action.
-	boost::shared_ptr<NetPacket> action(new NetPacketPlayersAction);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketPlayersAction::Data actionData;
+	packet->GetMsg()->present = PokerTHMessage_PR_myActionRequestMessage;
+	MyActionRequestMessage_t *netMyAction = &packet->GetMsg()->choice.myActionRequestMessage;
+	netMyAction->gameId = GetGameId();
 	boost::shared_ptr<PlayerInterface> myPlayer = GetGame()->getSeatsList()->front();
-	actionData.gameState = static_cast<GameState>(GetGame()->getCurrentHand()->getCurrentRound());
+	netMyAction->gameState = GetGame()->getCurrentHand()->getCurrentRound();
-	actionData.playerAction = static_cast<PlayerAction>(myPlayer->getMyAction());
+	netMyAction->myAction = myPlayer->getMyAction();
 	// Only send last bet if not fold/checked.
-	if (actionData.playerAction != PLAYER_ACTION_FOLD && actionData.playerAction != PLAYER_ACTION_CHECK)
+	if (myPlayer->getMyAction() != PLAYER_ACTION_FOLD && myPlayer->getMyAction() != PLAYER_ACTION_CHECK)
-		actionData.playerBet = myPlayer->getMyLastRelativeSet();
+		netMyAction->myRelativeBet = myPlayer->getMyLastRelativeSet();
 	else
-		actionData.playerBet = 0;
+		netMyAction->myRelativeBet = 0;
-	try
-	{
-		static_cast<NetPacketPlayersAction *>(action.get())->SetData(actionData);
 	// Just dump the packet.
-		m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), action));
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
-	} catch (const NetException &e)
-	{
-		LOG_ERROR("ClientThread::SendPlayerAction: " << e.what());
-	}
 }
 
 void
@@ -182,18 +174,16 @@ ClientThread::SendChatMessage(const std::string &msg)
 {
 	// Warning: This function is called in the context of the GUI thread.
 	// Create a network packet containing the chat message.
-	boost::shared_ptr<NetPacket> chat(new NetPacketSendChatText);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketSendChatText::Data chatData;
+	packet->GetMsg()->present = PokerTHMessage_PR_chatRequestMessage;
-	chatData.text = msg;
+	ChatRequestMessage_t *netChat = &packet->GetMsg()->choice.chatRequestMessage;
-	try
+	netChat->gameId = GetGameId();
-	{
+	OCTET_STRING_fromBuf(&netChat->chatText,
-		static_cast<NetPacketSendChatText *>(chat.get())->SetData(chatData);
+						 msg.c_str(),
+						 msg.length());
+
 	// Just dump the packet.
-		m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), chat));
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
-	} catch (const NetException &e)
-	{
-		LOG_ERROR("ClientThread::SendChatMessage: " << e.what());
-	}
 }
 
 void
@@ -201,18 +191,21 @@ ClientThread::SendJoinFirstGame(const std::string &password)
 {
 	// Warning: This function is called in the context of the GUI thread.
 	// Create a network packet to request joining a game.
-	boost::shared_ptr<NetPacket> join(new NetPacketJoinGame);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketJoinGame::Data joinData;
+	packet->GetMsg()->present = PokerTHMessage_PR_joinGameRequestMessage;
-	joinData.gameId = 1;
+	JoinGameRequestMessage_t *netJoinGame = &packet->GetMsg()->choice.joinGameRequestMessage;
-	joinData.password = password;
+	if (!password.empty())
-	try
 	{
-		static_cast<NetPacketJoinGame *>(join.get())->SetData(joinData);
+		netJoinGame->password = OCTET_STRING_new_fromBuf(
-		m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), join));
+			&asn_DEF_UTF8String,
-	} catch (const NetException &e)
+			password.c_str(),
-	{
+			password.length());
-		LOG_ERROR("ClientThread::SendJoinFirstGame: " << e.what());
 	}
+	netJoinGame->joinGameAction.present = joinGameAction_PR_joinExistingGame;
+
+	JoinExistingGame_t *joinExisting = &netJoinGame->joinGameAction.choice.joinExistingGame;
+	joinExisting->gameId = 1;
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
 }
 
 void
@@ -220,18 +213,21 @@ ClientThread::SendJoinGame(unsigned gameId, const std::string &password)
 {
 	// Warning: This function is called in the context of the GUI thread.
 	// Create a network packet to request joining a game.
-	boost::shared_ptr<NetPacket> join(new NetPacketJoinGame);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketJoinGame::Data joinData;
+	packet->GetMsg()->present = PokerTHMessage_PR_joinGameRequestMessage;
-	joinData.password = password;
+	JoinGameRequestMessage_t *netJoinGame = &packet->GetMsg()->choice.joinGameRequestMessage;
-	joinData.gameId = gameId;
+	if (!password.empty())
-	try
 	{
-		static_cast<NetPacketJoinGame *>(join.get())->SetData(joinData);
+		netJoinGame->password = OCTET_STRING_new_fromBuf(
-		m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), join));
+			&asn_DEF_UTF8String,
-	} catch (const NetException &e)
+			password.c_str(),
-	{
+			password.length());
-		LOG_ERROR("ClientThread::SendJoinGame: " << e.what());
 	}
+	netJoinGame->joinGameAction.present = joinGameAction_PR_joinExistingGame;
+
+	JoinExistingGame_t *joinExisting = &netJoinGame->joinGameAction.choice.joinExistingGame;
+	joinExisting->gameId = gameId;
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
 }
 
 void
@@ -239,50 +235,56 @@ ClientThread::SendCreateGame(const GameData &gameData, const std::string &name,
 {
 	// Warning: This function is called in the context of the GUI thread.
 	// Create a network packet to request creating a new game.
-	boost::shared_ptr<NetPacket> create(new NetPacketCreateGame);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketCreateGame::Data createData;
+	packet->GetMsg()->present = PokerTHMessage_PR_joinGameRequestMessage;
-	createData.gameData = gameData;
+	JoinGameRequestMessage_t *netJoinGame = &packet->GetMsg()->choice.joinGameRequestMessage;
-	createData.gameName = name;
+	if (!password.empty())
-	createData.password = password;
-	try
 	{
-		static_cast<NetPacketCreateGame *>(create.get())->SetData(createData);
+		netJoinGame->password = OCTET_STRING_new_fromBuf(
-		m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), create));
+			&asn_DEF_UTF8String,
-	} catch (const NetException &e)
+			password.c_str(),
-	{
+			password.length());
-		LOG_ERROR("ClientThread::SendCreateGame: " << e.what());
 	}
+	netJoinGame->joinGameAction.present = joinGameAction_PR_joinNewGame;
+
+	JoinNewGame_t *joinNew = &netJoinGame->joinGameAction.choice.joinNewGame;
+	NetPacket::SetGameData(gameData, &joinNew->gameInfo);
+	OCTET_STRING_fromBuf(&joinNew->gameInfo.gameName,
+						 name.c_str(),
+						 name.length());
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
 }
 
 void
 ClientThread::SendResetTimeout()
 {
-	boost::shared_ptr<NetPacket> reset(new NetPacketResetTimeout);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), reset));
+	packet->GetMsg()->present = PokerTHMessage_PR_resetTimeoutMessage;
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
 }
 
 void
 ClientThread::SendAskKickPlayer(unsigned playerId)
 {
-	boost::shared_ptr<NetPacket> ask(new NetPacketAskKickPlayer);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketAskKickPlayer::Data askData;
+	packet->GetMsg()->present = PokerTHMessage_PR_askKickPlayerMessage;
-	askData.playerId = playerId;
+	AskKickPlayerMessage_t *netAsk = &packet->GetMsg()->choice.askKickPlayerMessage;
-	static_cast<NetPacketAskKickPlayer *>(ask.get())->SetData(askData);
+	netAsk->playerId = playerId;
-	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), ask));
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
 }
 
 void
 ClientThread::SendVoteKick(bool doKick)
 {
-	boost::shared_ptr<NetPacket> vote(new NetPacketVoteKickPlayer);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketVoteKickPlayer::Data voteData;
+	packet->GetMsg()->present = PokerTHMessage_PR_voteKickRequestMessage;
+	VoteKickRequestMessage_t *netVote = &packet->GetMsg()->choice.voteKickRequestMessage;
 	{
 		boost::mutex::scoped_lock lock(m_curPetitionIdMutex);
-		voteData.petitionId = m_curPetitionId;
+		netVote->petitionId = m_curPetitionId;
 	}
-	voteData.vote = doKick ? KICK_VOTE_IN_FAVOUR : KICK_VOTE_AGAINST;
+	netVote->voteKick = doKick;
-	static_cast<NetPacketVoteKickPlayer *>(vote.get())->SetData(voteData);
+	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
-	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), vote));
 }
 
 void
@@ -523,11 +525,11 @@ ClientThread::RequestPlayerInfo(unsigned id, bool requestAvatar)
 {
 	if (find(m_playerInfoRequestList.begin(), m_playerInfoRequestList.end(), id) == m_playerInfoRequestList.end())
 	{
-		boost::shared_ptr<NetPacket> req(new NetPacketRetrievePlayerInfo);
+		boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-		NetPacketRetrievePlayerInfo::Data reqData;
+		packet->GetMsg()->present = PokerTHMessage_PR_playerInfoRequestMessage;
-		reqData.playerId = id;
+		PlayerInfoRequestMessage_t *netPlayerInfo = &packet->GetMsg()->choice.playerInfoRequestMessage;
-		static_cast<NetPacketRetrievePlayerInfo *>(req.get())->SetData(reqData);
+		netPlayerInfo->playerId = id;
-		GetSender().Send(GetContext().GetSessionData(), req);
+		GetSender().Send(GetContext().GetSessionData(), packet);
 
 		m_playerInfoRequestList.push_back(id);
 
@@ -637,21 +639,23 @@ ClientThread::RetrieveAvatarIfNeeded(unsigned id, const PlayerInfo &info)
 			}
 			else
 			{
-				boost::shared_ptr<NetPacket> retrieveAvatar(new NetPacketRetrieveAvatar);
+				boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-				NetPacketRetrieveAvatar::Data retrieveAvatarData;
+				packet->GetMsg()->present = PokerTHMessage_PR_avatarRequestMessage;
-				retrieveAvatarData.requestId = id;
+				AvatarRequestMessage_t *netAvatar = &packet->GetMsg()->choice.avatarRequestMessage;
-				retrieveAvatarData.avatar = info.avatar;
+				netAvatar->requestId = id;
-				static_cast<NetPacketRetrieveAvatar *>(retrieveAvatar.get())->SetData(retrieveAvatarData);
+				OCTET_STRING_fromBuf(&netAvatar->avatar,
-				GetSender().Send(GetContext().GetSessionData(), retrieveAvatar);
+									 (const char *)info.avatar.data,
+									 MD5_DATA_SIZE);
+				GetSender().Send(GetContext().GetSessionData(), packet);
 			}
 		}
 	}
 }
 
 void
-ClientThread::AddTempAvatarData(unsigned playerId, unsigned avatarSize, AvatarFileType type)
+ClientThread::AddTempAvatarFile(unsigned playerId, unsigned avatarSize, AvatarFileType type)
 {
-	boost::shared_ptr<AvatarData> tmpAvatar(new AvatarData);
+	boost::shared_ptr<AvatarFile> tmpAvatar(new AvatarFile);
 	tmpAvatar->fileData.reserve(avatarSize);
 	tmpAvatar->fileType = type;
 	tmpAvatar->reportedSize = avatarSize;
@@ -660,9 +664,9 @@ ClientThread::AddTempAvatarData(unsigned playerId, unsigned avatarSize, AvatarFi
 }
 
 void
-ClientThread::StoreInTempAvatarData(unsigned playerId, const vector<unsigned char> &data)
+ClientThread::StoreInTempAvatarFile(unsigned playerId, const vector<unsigned char> &data)
 {
-	AvatarDataMap::iterator pos = m_tempAvatarMap.find(playerId);
+	AvatarFileMap::iterator pos = m_tempAvatarMap.find(playerId);
 	if (pos == m_tempAvatarMap.end())
 		throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_REQUEST_ID, 0);
 	// We trust the server (concerning size of the data).
@@ -670,33 +674,33 @@ ClientThread::StoreInTempAvatarData(unsigned playerId, const vector<unsigned cha
 }
 
 void
-ClientThread::CompleteTempAvatarData(unsigned playerId)
+ClientThread::CompleteTempAvatarFile(unsigned playerId)
 {
-	AvatarDataMap::iterator pos = m_tempAvatarMap.find(playerId);
+	AvatarFileMap::iterator pos = m_tempAvatarMap.find(playerId);
 	if (pos == m_tempAvatarMap.end())
 		throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_REQUEST_ID, 0);
-	boost::shared_ptr<AvatarData> tmpAvatar = pos->second;
+	boost::shared_ptr<AvatarFile> tmpAvatar = pos->second;
 	unsigned avatarSize = (unsigned)tmpAvatar->fileData.size();
 	if (avatarSize != tmpAvatar->reportedSize)
 		LOG_ERROR("Client received invalid avatar file size!");
 	else
-		PassAvatarDataToManager(playerId, tmpAvatar);
+		PassAvatarFileToManager(playerId, tmpAvatar);
 
 	// Free memory.
 	m_tempAvatarMap.erase(pos);
 }
 
 void
-ClientThread::PassAvatarDataToManager(unsigned playerId, boost::shared_ptr<AvatarData> avatarData)
+ClientThread::PassAvatarFileToManager(unsigned playerId, boost::shared_ptr<AvatarFile> AvatarFile)
 {
 	PlayerInfo tmpPlayerInfo;
 	if (!GetCachedPlayerInfo(playerId, tmpPlayerInfo))
 		LOG_ERROR("Client received invalid player id!");
 	else
 	{
-		if (avatarData->fileType == AVATAR_FILE_TYPE_UNKNOWN)
+		if (AvatarFile->fileType == AVATAR_FILE_TYPE_UNKNOWN)
-			avatarData->fileType = tmpPlayerInfo.avatarType;
+			AvatarFile->fileType = tmpPlayerInfo.avatarType;
-		if (!GetAvatarManager().StoreAvatarInCache(tmpPlayerInfo.avatar, avatarData->fileType, &avatarData->fileData[0], avatarData->reportedSize, false))
+		if (!GetAvatarManager().StoreAvatarInCache(tmpPlayerInfo.avatar, AvatarFile->fileType, &AvatarFile->fileData[0], AvatarFile->reportedSize, false))
 			LOG_ERROR("Failed to store avatar in cache directory.");
 
 		// Update player info, but never re-request avatar.
@@ -726,10 +730,10 @@ ClientThread::TimerCheckAvatarDownloads(const boost::system::error_code& ec)
 		if (m_avatarDownloader && m_avatarDownloader->HasDownloadResult())
 		{
 			unsigned playerId;
-			boost::shared_ptr<AvatarData> tmpAvatar(new AvatarData);
+			boost::shared_ptr<AvatarFile> tmpAvatar(new AvatarFile);
 			m_avatarDownloader->GetDownloadResult(playerId, tmpAvatar->fileData);
 			tmpAvatar->reportedSize = tmpAvatar->fileData.size();
-			PassAvatarDataToManager(playerId, tmpAvatar);
+			PassAvatarFileToManager(playerId, tmpAvatar);
 		}
 		m_avatarTimer.expires_from_now(
 			boost::posix_time::milliseconds(CLIENT_AVATAR_LOOP_MSEC));
@@ -745,8 +749,11 @@ ClientThread::UnsubscribeLobbyMsg()
 	if (GetContext().GetSubscribeLobbyMsg())
 	{
 		// Send unsubscribe request.
-		boost::shared_ptr<NetPacket> unsubscr(new NetPacketUnsubscribeGameList);
+		boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-		GetSender().Send(GetContext().GetSessionData(), unsubscr);
+		packet->GetMsg()->present = PokerTHMessage_PR_subscriptionRequestMessage;
+		SubscriptionRequestMessage_t *netRequest = &packet->GetMsg()->choice.subscriptionRequestMessage;
+		netRequest->subscriptionAction = subscriptionAction_unsubscribeGameList;
+		GetSender().Send(GetContext().GetSessionData(), packet);
 		GetContext().SetSubscribeLobbyMsg(false);
 	}
 }
@@ -759,8 +766,10 @@ ClientThread::ResubscribeLobbyMsg()
 		// Clear game info map as it is outdated.
 		ClearGameInfoMap();
 		// Send resubscribe request.
-		boost::shared_ptr<NetPacket> resubscr(new NetPacketResubscribeGameList);
+		boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-		GetSender().Send(GetContext().GetSessionData(), resubscr);
+		packet->GetMsg()->present = PokerTHMessage_PR_subscriptionRequestMessage;
+		SubscriptionRequestMessage_t *netRequest = &packet->GetMsg()->choice.subscriptionRequestMessage;
+		netRequest->subscriptionAction = subscriptionAction_resubscribeGameList;
 		GetContext().SetSubscribeLobbyMsg(true);
 	}
 }

src/net/common/receiverhelper.cpp

@@ -47,7 +47,7 @@ ReceiverHelper::ScanPackets(ReceiveBuffer &buf)
 		// This is necessary, because we use TCP.
 		// Packets may be received in multiple chunks or
 		// several packets may be received at once.
-		if (buf.recvBufUsed >= MIN_PACKET_SIZE)
+		if (buf.recvBufUsed)
 		{
 			try
 			{

src/net/common/senderhelper.cpp

@@ -17,8 +17,9 @@
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 
+#include <boost/asio.hpp>
 #include <boost/bind.hpp>
-#include <boost/enable_shared_from_this.hpp>\
+#include <boost/enable_shared_from_this.hpp>
 
 #include <net/senderhelper.h>
 #include <net/sendercallback.h>
@@ -37,8 +38,37 @@ using boost::asio::ip::tcp;
 #define SEND_QUEUE_SIZE						10000000
 #define SEND_LOG_INTERVAL_SEC				60
 
+class EncodedPacket
+{
+public:
+	EncodedPacket(const unsigned char *data, unsigned size)
+		: m_size(size)
+	{
+		m_data = new unsigned char[size];
+		memcpy(m_data, data, size);
+	}
 
-typedef std::list<boost::shared_ptr<NetPacket> > SendDataList;
+	~EncodedPacket()
+	{
+		delete[] m_data;
+	}
+
+	unsigned GetSize() const
+	{
+		return m_size;
+	}
+
+	const unsigned char *GetData() const
+	{
+		return m_data;
+	}
+
+private:
+	unsigned m_size;
+	unsigned char *m_data;
+};
+
+typedef std::list<boost::shared_ptr<EncodedPacket> > SendDataList;
 
 class SendDataManager : public boost::enable_shared_from_this<SendDataManager>
 {
@@ -87,7 +117,7 @@ SendDataManager::AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::soc
 		SendDataList::iterator end = list.end();
 		while (i != end)
 		{
-			bufSize += (*i)->GetLen();
+			bufSize += (*i)->GetSize();
 			++i;
 		}
 		if (bufSize)
@@ -97,8 +127,8 @@ SendDataManager::AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::soc
 			end = list.end();
 			while (i != end)
 			{
-				memcpy(sendBuf + bufPos, (*i)->GetRawData(), (*i)->GetLen());
+				memcpy(sendBuf + bufPos, (*i)->GetData(), (*i)->GetSize());
-				bufPos += (*i)->GetLen();
+				bufPos += (*i)->GetSize();
 				++i;
 			}
 			list.clear();
@@ -144,7 +174,7 @@ SenderHelper::Send(boost::shared_ptr<SessionData> session, boost::shared_ptr<Net
 			boost::mutex::scoped_lock lock(tmpManager->dataMutex);
 			if (tmpManager->list.size() < SEND_QUEUE_SIZE)
 			{
-				tmpManager->list.push_back(packet);
+				InternalStorePacket(*tmpManager, packet);
 			}
 		}
 		{
@@ -178,7 +208,7 @@ SenderHelper::Send(boost::shared_ptr<SessionData> session, const NetPacketList &
 				while (i != end)
 				{
 					if (*i)
-						tmpManager->list.push_back(*i);
+						InternalStorePacket(*tmpManager, *i);
 					++i;
 				}
 			}
@@ -200,3 +230,15 @@ SenderHelper::SignalSessionTerminated(unsigned sessionId)
 		m_sendQueueMap.erase(pos);
 }
 
+void
+SenderHelper::InternalStorePacket(SendDataManager &tmpManager, boost::shared_ptr<NetPacket> packet)
+{
+	unsigned char buf[MAX_PACKET_SIZE];
+	asn_enc_rval_t e;
+	e = der_encode_to_buffer(&asn_DEF_PokerTHMessage, packet->GetMsg(), buf, MAX_PACKET_SIZE);
+	if (e.encoded == -1)
+		LOG_ERROR("Failed to encode NetPacket: " << packet->GetMsg()->present);
+	else
+		tmpManager.list.push_back(boost::shared_ptr<EncodedPacket>(new EncodedPacket(buf, e.encoded)));
+}
+

src/net/common/servergame.cpp

@@ -17,6 +17,9 @@
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+
 #include <net/servergame.h>
 #include <net/servergamestate.h>
 #include <net/serverlobbythread.h>
@@ -29,8 +32,6 @@
 #include <localenginefactory.h>
 #include <tools.h>
 
-#include <boost/bind.hpp>
-
 
 #define SERVER_CHECK_VOTE_KICK_INTERVAL_MSEC	500
 #define SERVER_KICK_TIMEOUT_ADD_DELAY_SEC		2
@@ -181,16 +182,15 @@ ServerGame::TimerVoteKick(const boost::system::error_code &ec)
 			}
 			if (abortPetition)
 			{
-				boost::shared_ptr<NetPacket> endPetition(new NetPacketEndKickPlayerPetition);
+				boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-				NetPacketEndKickPlayerPetition::Data endPetitionData;
+				packet->GetMsg()->present = PokerTHMessage_PR_endKickPetitionMessage;
-				endPetitionData.petitionId = m_voteKickData->petitionId;
+				EndKickPetitionMessage_t *netEndPetition = &packet->GetMsg()->choice.endKickPetitionMessage;
-				endPetitionData.numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
+				netEndPetition->petitionId = m_voteKickData->petitionId;
-				endPetitionData.numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
+				netEndPetition->numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
-				endPetitionData.playerKicked = doKick;
+				netEndPetition->numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
-				endPetitionData.endReason = reason;
+				netEndPetition->resultPlayerKicked = doKick;
-
+				netEndPetition->petitionEndReason = reason;
-				static_cast<NetPacketEndKickPlayerPetition *>(endPetition.get())->SetData(endPetitionData);
+				SendToAllPlayers(packet, SessionData::Game);
-				SendToAllPlayers(endPetition, SessionData::Game);
 
 				// Perform kick.
 				if (doKick)
@@ -300,16 +300,15 @@ ServerGame::InternalAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, uns
 					m_voteKickData->numVotesInFavourOfKicking = 1;
 					m_voteKickData->votedPlayerIds.push_back(playerIdByWhom);
 
-					boost::shared_ptr<NetPacket> startPetition(new NetPacketStartKickPlayerPetition);
+					boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-					NetPacketStartKickPlayerPetition::Data startPetitionData;
+					packet->GetMsg()->present = PokerTHMessage_PR_startKickPetitionMessage;
-					startPetitionData.petitionId = m_voteKickData->petitionId;
+					StartKickPetitionMessage_t *netStartPetition = &packet->GetMsg()->choice.startKickPetitionMessage;
-					startPetitionData.proposingPlayerId = playerIdByWhom;
+					netStartPetition->petitionId = m_voteKickData->petitionId;
-					startPetitionData.kickPlayerId = m_voteKickData->kickPlayerId;
+					netStartPetition->proposingPlayerId = playerIdByWhom;
-					startPetitionData.kickTimeoutSec = timeoutSec;
+					netStartPetition->kickPlayerId = m_voteKickData->kickPlayerId;
-					startPetitionData.numVotesNeededToKick = m_voteKickData->numVotesToKick;
+					netStartPetition->kickTimeoutSec = timeoutSec;
-
+					netStartPetition->numVotesNeededToKick = m_voteKickData->numVotesToKick;
-					static_cast<NetPacketStartKickPlayerPetition *>(startPetition.get())->SetData(startPetitionData);
+					SendToAllPlayers(packet, SessionData::Game);
-					SendToAllPlayers(startPetition, SessionData::Game);
 				}
 				else
 					InternalDenyAskVoteKick(byWhom, playerIdWho, KICK_DENIED_OTHER_IN_PROGRESS);
@@ -327,12 +326,12 @@ ServerGame::InternalAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, uns
 void
 ServerGame::InternalDenyAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, DenyKickPlayerReason reason)
 {
-	boost::shared_ptr<NetPacket> denyPetition(new NetPacketAskKickPlayerDenied);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketAskKickPlayerDenied::Data denyPetitionData;
+	packet->GetMsg()->present = PokerTHMessage_PR_askKickDeniedMessage;
-	denyPetitionData.playerId = playerIdWho;
+	AskKickDeniedMessage_t *netKickDenied = &packet->GetMsg()->choice.askKickDeniedMessage;
-	denyPetitionData.denyReason = reason;
+	netKickDenied->playerId = playerIdWho;
-	static_cast<NetPacketAskKickPlayerDenied *>(denyPetition.get())->SetData(denyPetitionData);
+	netKickDenied->kickDeniedReason = reason;
-	GetLobbyThread().GetSender().Send(byWhom.sessionData, denyPetition);
+	GetLobbyThread().GetSender().Send(byWhom.sessionData, packet);
 }
 
 void
@@ -353,15 +352,14 @@ ServerGame::InternalVoteKick(SessionWrapper byWhom, unsigned petitionId, KickVot
 				else
 					m_voteKickData->numVotesAgainstKicking++;
 				// Send update notification.
-				boost::shared_ptr<NetPacket> updatePetition(new NetPacketKickPlayerPetitionUpdate);
+				boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-				NetPacketKickPlayerPetitionUpdate::Data updatePetitionData;
+				packet->GetMsg()->present = PokerTHMessage_PR_kickPetitionUpdateMessage;
-				updatePetitionData.petitionId = m_voteKickData->petitionId;
+				KickPetitionUpdateMessage_t *netKickUpdate = &packet->GetMsg()->choice.kickPetitionUpdateMessage;
-				updatePetitionData.numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
+				netKickUpdate->petitionId = m_voteKickData->petitionId;
-				updatePetitionData.numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
+				netKickUpdate->numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
-				updatePetitionData.numVotesNeededToKick = m_voteKickData->numVotesToKick;
+				netKickUpdate->numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
-
+				netKickUpdate->numVotesNeededToKick = m_voteKickData->numVotesToKick;
-				static_cast<NetPacketKickPlayerPetitionUpdate *>(updatePetition.get())->SetData(updatePetitionData);
+				SendToAllPlayers(packet, SessionData::Game);
-				SendToAllPlayers(updatePetition, SessionData::Game);
 			}
 			else
 				InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_ALREADY_VOTED);
@@ -370,18 +368,21 @@ ServerGame::InternalVoteKick(SessionWrapper byWhom, unsigned petitionId, KickVot
 			InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_INVALID_PETITION);
 	}
 	else
-		InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_IMPOSSIBLE);
+		InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_INVALID_PETITION);
 }
 
 void
 ServerGame::InternalDenyVoteKick(SessionWrapper byWhom, unsigned petitionId, DenyVoteReason reason)
 {
-	boost::shared_ptr<NetPacket> denyVote(new NetPacketVoteKickPlayerDenied);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketVoteKickPlayerDenied::Data denyVoteData;
+	packet->GetMsg()->present = PokerTHMessage_PR_voteKickReplyMessage;
-	denyVoteData.petitionId = petitionId;
+	VoteKickReplyMessage_t *netVoteReply = &packet->GetMsg()->choice.voteKickReplyMessage;
-	denyVoteData.denyReason = reason;
+	netVoteReply->petitionId = petitionId;
-	static_cast<NetPacketVoteKickPlayerDenied *>(denyVote.get())->SetData(denyVoteData);
+	netVoteReply->voteKickReplyType.present = voteKickReplyType_PR_voteKickDenied;
-	GetLobbyThread().GetSender().Send(byWhom.sessionData, denyVote);
+
+	VoteKickDenied_t *kickDenied = &netVoteReply->voteKickReplyType.choice.voteKickDenied;
+	kickDenied->voteKickDeniedReason = reason;
+	GetLobbyThread().GetSender().Send(byWhom.sessionData, packet);
 }
 
 PlayerDataList
@@ -557,10 +558,14 @@ ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason)
 			// Notify game state on admin change
 			GetState().NotifyGameAdminChanged(shared_from_this());
 			// Send "Game Admin Changed" to clients.
-			boost::shared_ptr<NetPacket> adminChanged(new NetPacketGameAdminChanged);
+			boost::shared_ptr<NetPacket> adminChanged(new NetPacket(NetPacket::Alloc));
-			NetPacketGameAdminChanged::Data adminChangedData;
+			adminChanged->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
-			adminChangedData.playerId = newAdmin->GetUniqueId(); // Choose next player as admin.
+			GamePlayerMessage_t *netGameAdmin = &adminChanged->GetMsg()->choice.gamePlayerMessage;
-			static_cast<NetPacketGameAdminChanged *>(adminChanged.get())->SetData(adminChangedData);
+			netGameAdmin->gameId = GetId();
+
+			netGameAdmin->gamePlayerNotification.present = gamePlayerNotification_PR_gameAdminChanged;
+			GameAdminChanged_t *gameAdmin = &netGameAdmin->gamePlayerNotification.choice.gameAdminChanged;
+			gameAdmin->newAdminPlayerId = newAdmin->GetUniqueId(); // Choose next player as admin.
 			GetSessionManager().SendToAllSessions(GetLobbyThread().GetSender(), adminChanged, SessionData::Game);
 
 			GetLobbyThread().NotifyGameAdminChanged(GetId(), newAdmin->GetUniqueId());
@@ -570,11 +575,26 @@ ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason)
 	player->SetRights(PLAYER_RIGHTS_NORMAL);
 
 	// Send "Player Left" to clients.
-	boost::shared_ptr<NetPacket> thisPlayerLeft(new NetPacketPlayerLeft);
+	boost::shared_ptr<NetPacket> thisPlayerLeft(new NetPacket(NetPacket::Alloc));
-	NetPacketPlayerLeft::Data thisPlayerLeftData;
+	thisPlayerLeft->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
-	thisPlayerLeftData.playerId = player->GetUniqueId();
+	GamePlayerMessage_t *netPlayerLeft = &thisPlayerLeft->GetMsg()->choice.gamePlayerMessage;
-	thisPlayerLeftData.removeReason = reason;
+	netPlayerLeft->gameId = GetId();
-	static_cast<NetPacketPlayerLeft *>(thisPlayerLeft.get())->SetData(thisPlayerLeftData);
+
+	netPlayerLeft->gamePlayerNotification.present = gamePlayerNotification_PR_gamePlayerLeft;
+	GamePlayerLeft_t *gamePlayer = &netPlayerLeft->gamePlayerNotification.choice.gamePlayerLeft;
+	gamePlayer->playerId = player->GetUniqueId();
+	switch (reason)
+	{
+		case NTF_NET_REMOVED_ON_REQUEST :
+			gamePlayer->gamePlayerLeftReason = gamePlayerLeftReason_leftOnRequest;
+			break;
+		case NTF_NET_REMOVED_KICKED :
+			gamePlayer->gamePlayerLeftReason = gamePlayerLeftReason_leftKicked;
+			break;
+		default :
+			gamePlayer->gamePlayerLeftReason = gamePlayerLeftReason_leftError;
+			break;
+	}
 	GetSessionManager().SendToAllSessions(GetLobbyThread().GetSender(), thisPlayerLeft, SessionData::Game);
 
 	GetLobbyThread().NotifyPlayerLeftGame(GetId(), player->GetUniqueId());

src/net/common/servergamestate.cpp

@@ -73,55 +73,58 @@ static void SendPlayerAction(ServerGame &server, boost::shared_ptr<PlayerInterfa
 {
 	if (!player.get())
 		throw ServerException(__FILE__, __LINE__, ERR_NET_NO_CURRENT_PLAYER, 0);
-	boost::shared_ptr<NetPacket> notifyActionDone(new NetPacketPlayersActionDone);
+
-	NetPacketPlayersActionDone::Data actionDoneData;
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	actionDoneData.gameState = server.GetCurRound();
+	packet->GetMsg()->present = PokerTHMessage_PR_playersActionDoneMessage;
-	actionDoneData.playerId = player->getMyUniqueID();
+	PlayersActionDoneMessage_t *netActionDone = &packet->GetMsg()->choice.playersActionDoneMessage;
-	actionDoneData.playerAction = static_cast<PlayerAction>(player->getMyAction());
+
-	actionDoneData.totalPlayerBet = player->getMySet();
+	netActionDone->gameId = server.GetId();
-	actionDoneData.playerMoney = player->getMyCash();
+	netActionDone->gameState = server.GetCurRound();
-	actionDoneData.highestSet = server.GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
+	netActionDone->highestSet = server.GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
-	actionDoneData.minimumRaise = server.GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
+	netActionDone->minimumRaise = server.GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
-	static_cast<NetPacketPlayersActionDone *>(notifyActionDone.get())->SetData(actionDoneData);
+	netActionDone->playerAction = static_cast<PlayerAction>(player->getMyAction());
-	server.SendToAllPlayers(notifyActionDone, SessionData::Game);
+	netActionDone->playerId = player->getMyUniqueID();
+	netActionDone->playerMoney = player->getMyCash();
+	netActionDone->totalPlayerBet = player->getMySet();
+	server.SendToAllPlayers(packet, SessionData::Game);
 }
 
 static void SendNewRoundCards(ServerGame &server, Game &curGame, int state)
 {
+	int cards[5];
+	curGame.getCurrentHand()->getBoard()->getMyCards(cards);
 	switch(state) {
 		case GAME_STATE_PREFLOP: {
 			// nothing to do
 		} break;
 		case GAME_STATE_FLOP: {
 			// deal flop cards
-			int cards[5];
+			boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-			curGame.getCurrentHand()->getBoard()->getMyCards(cards);
+			packet->GetMsg()->present = PokerTHMessage_PR_dealFlopCardsMessage;
-			boost::shared_ptr<NetPacket> notifyCards(new NetPacketDealFlopCards);
+			DealFlopCardsMessage_t *netDealFlop = &packet->GetMsg()->choice.dealFlopCardsMessage;
-			NetPacketDealFlopCards::Data notifyCardsData;
+			netDealFlop->gameId = server.GetId();
-			for (int num = 0; num < 3; num++)
+			netDealFlop->flopCard1 = cards[0];
-				notifyCardsData.flopCards[num] = static_cast<u_int16_t>(cards[num]);
+			netDealFlop->flopCard2 = cards[1];
-			static_cast<NetPacketDealFlopCards *>(notifyCards.get())->SetData(notifyCardsData);
+			netDealFlop->flopCard3 = cards[2];
-			server.SendToAllPlayers(notifyCards, SessionData::Game);
+			server.SendToAllPlayers(packet, SessionData::Game);
 		} break;
 		case GAME_STATE_TURN: {
 			// deal turn card
-			int cards[5];
+			boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-			curGame.getCurrentHand()->getBoard()->getMyCards(cards);
+			packet->GetMsg()->present = PokerTHMessage_PR_dealTurnCardMessage;
-			boost::shared_ptr<NetPacket> notifyCards(new NetPacketDealTurnCard);
+			DealTurnCardMessage_t *netDealTurn = &packet->GetMsg()->choice.dealTurnCardMessage;
-			NetPacketDealTurnCard::Data notifyCardsData;
+			netDealTurn->gameId = server.GetId();
-			notifyCardsData.turnCard = static_cast<u_int16_t>(cards[3]);
+			netDealTurn->turnCard = cards[3];
-			static_cast<NetPacketDealTurnCard *>(notifyCards.get())->SetData(notifyCardsData);
+			server.SendToAllPlayers(packet, SessionData::Game);
-			server.SendToAllPlayers(notifyCards, SessionData::Game);
 		} break;
 		case GAME_STATE_RIVER: {
 			// deal river card
-			int cards[5];
+			boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-			curGame.getCurrentHand()->getBoard()->getMyCards(cards);
+			packet->GetMsg()->present = PokerTHMessage_PR_dealRiverCardMessage;
-			boost::shared_ptr<NetPacket> notifyCards(new NetPacketDealRiverCard);
+			DealRiverCardMessage_t *netDealRiver = &packet->GetMsg()->choice.dealRiverCardMessage;
-			NetPacketDealRiverCard::Data notifyCardsData;
+			netDealRiver->gameId = server.GetId();
-			notifyCardsData.riverCard = static_cast<u_int16_t>(cards[4]);
+			netDealRiver->riverCard = cards[4];
-			static_cast<NetPacketDealRiverCard *>(notifyCards.get())->SetData(notifyCardsData);
+			server.SendToAllPlayers(packet, SessionData::Game);
-			server.SendToAllPlayers(notifyCards, SessionData::Game);
 		} break;
 		default: {
 			// 
@@ -186,82 +189,77 @@ AbstractServerGameStateReceiving::ProcessPacket(boost::shared_ptr<ServerGame> se
 {
 	if (packet->IsClientActivity())
 		session.sessionData->ResetActivityTimer();
-	if (packet->ToNetPacketRetrievePlayerInfo())
+	if (packet->GetMsg()->present == PokerTHMessage_PR_playerInfoRequestMessage)
 	{
 		// Delegate to Lobby.
-		server->GetLobbyThread().HandleGameRetrievePlayerInfo(session, *packet->ToNetPacketRetrievePlayerInfo());
+		server->GetLobbyThread().HandleGameRetrievePlayerInfo(session, packet->GetMsg()->choice.playerInfoRequestMessage);
 	}
-	else if (packet->ToNetPacketRetrieveAvatar())
+	else if (packet->GetMsg()->present == PokerTHMessage_PR_avatarRequestMessage)
 	{
 		// Delegate to Lobby.
-		server->GetLobbyThread().HandleGameRetrieveAvatar(session, *packet->ToNetPacketRetrieveAvatar());
+		server->GetLobbyThread().HandleGameRetrieveAvatar(session, packet->GetMsg()->choice.avatarRequestMessage);
 	}
-	else if (packet->ToNetPacketLeaveCurrentGame())
+	else if (packet->GetMsg()->present == PokerTHMessage_PR_leaveGameRequestMessage)
 	{
 		server->MoveSessionToLobby(session, NTF_NET_REMOVED_ON_REQUEST);
 	}
-	else if (packet->ToNetPacketKickPlayer())
+	else if (packet->GetMsg()->present == PokerTHMessage_PR_kickPlayerRequestMessage)
 	{
 		// Only admins are allowed to kick, and only in the lobby.
 		// After leaving the lobby, a vote needs to be initiated to kick.
-		if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN && !server->IsRunning())
+		KickPlayerRequestMessage_t *netKickRequest = &packet->GetMsg()->choice.kickPlayerRequestMessage;
+		if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN && !server->IsRunning() && netKickRequest->gameId == server->GetId())
 		{
-			NetPacketKickPlayer::Data kickPlayerData;
+			server->InternalKickPlayer(netKickRequest->playerId);
-			packet->ToNetPacketKickPlayer()->GetData(kickPlayerData);
-
-			server->InternalKickPlayer(kickPlayerData.playerId);
 		}
 	}
-	else if (packet->ToNetPacketAskKickPlayer())
+	else if (packet->GetMsg()->present == PokerTHMessage_PR_askKickPlayerMessage)
 	{
 		if (session.playerData)
 		{
-			NetPacketAskKickPlayer::Data askKickData;
+			AskKickPlayerMessage_t *netAskKick = &packet->GetMsg()->choice.askKickPlayerMessage;
-			packet->ToNetPacketAskKickPlayer()->GetData(askKickData);
+			server->InternalAskVoteKick(session, netAskKick->playerId, SERVER_VOTE_KICK_TIMEOUT_SEC);
-
-			server->InternalAskVoteKick(session, askKickData.playerId, SERVER_VOTE_KICK_TIMEOUT_SEC);
 		}
 	}
-	else if (packet->ToNetPacketVoteKickPlayer())
+	else if (packet->GetMsg()->present == PokerTHMessage_PR_voteKickRequestMessage)
 	{
 		if (session.playerData)
 		{
-			NetPacketVoteKickPlayer::Data voteData;
+			VoteKickRequestMessage_t *netVoteKick = &packet->GetMsg()->choice.voteKickRequestMessage;
-			packet->ToNetPacketVoteKickPlayer()->GetData(voteData);
+			server->InternalVoteKick(session, netVoteKick->petitionId, netVoteKick->voteKick ? KICK_VOTE_AGAINST : KICK_VOTE_IN_FAVOUR);
-
-			server->InternalVoteKick(session, voteData.petitionId, voteData.vote);
 		}
 	}
 	// Chat text is always allowed.
-	else if (packet->ToNetPacketSendChatText())
+	else if (packet->GetMsg()->present == PokerTHMessage_PR_chatRequestMessage)
 	{
 		if (session.playerData) // Only forward if this player is known.
 		{
 			// Forward chat text to all players.
 			// TODO: Some limitation needed.
-			NetPacketSendChatText::Data inChatData;
+			ChatRequestMessage_t *netChatRequest = &packet->GetMsg()->choice.chatRequestMessage;
-			packet->ToNetPacketSendChatText()->GetData(inChatData);
+			boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-
+			packet->GetMsg()->present = PokerTHMessage_PR_chatMessage;
-			boost::shared_ptr<NetPacket> outChat(new NetPacketChatText);
+			ChatMessage_t *netChat = &packet->GetMsg()->choice.chatMessage;
-			NetPacketChatText::Data outChatData;
+			netChat->gameId = server->GetId();
-			outChatData.playerId = session.playerData->GetUniqueId();
+			netChat->playerId = session.playerData->GetUniqueId();
-			outChatData.text = inChatData.text;
+			OCTET_STRING_fromBuf(
-			static_cast<NetPacketChatText *>(outChat.get())->SetData(outChatData);
+				&netChat->chatText,
-			server->SendToAllPlayers(outChat, SessionData::Game);
+				(char *)netChatRequest->chatText.buf,
+				netChatRequest->chatText.size);
+			server->SendToAllPlayers(packet, SessionData::Game);
 		}
 	}
-	else if (packet->ToNetPacketUnsubscribeGameList())
+	else if (packet->GetMsg()->present == PokerTHMessage_PR_subscriptionRequestMessage)
 	{
-		// We can do this directly in this thread.
+		SubscriptionRequestMessage_t *netSubscription = &packet->GetMsg()->choice.subscriptionRequestMessage;
-		session.sessionData->ResetWantsLobbyMsg();
+		if (netSubscription->subscriptionAction == subscriptionAction_resubscribeGameList)
-	}
-	else if (packet->ToNetPacketResubscribeGameList())
 		{
-		// This needs to be performed in the lobby thread,
-		// because a new game list needs to be sent.
 			if (!session.sessionData->WantsLobbyMsg())
 				server->GetLobbyThread().ResubscribeLobbyMsg(session);
 		}
+		else
+			session.sessionData->ResetWantsLobbyMsg();
+	}
 	else
 	{
 		// Packet processing in subclass.
@@ -332,13 +330,19 @@ ServerGameStateInit::HandleNewSession(boost::shared_ptr<ServerGame> server, Sess
 			}
 
 			// Send ack to client.
-			boost::shared_ptr<NetPacket> joinGameAck(new NetPacketJoinGameAck);
+			boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-			NetPacketJoinGameAck::Data joinGameAckData;
+			packet->GetMsg()->present = PokerTHMessage_PR_joinGameReplyMessage;
-			joinGameAckData.gameId = server->GetId();
+			JoinGameReplyMessage_t *netJoinReply = &packet->GetMsg()->choice.joinGameReplyMessage;
-			joinGameAckData.prights = session.playerData->GetRights();
+			netJoinReply->gameId = server->GetId();
-			joinGameAckData.gameData = server->GetGameData();
+			netJoinReply->joinGameResult.present = joinGameResult_PR_joinGameAck;
-			static_cast<NetPacketJoinGameAck *>(joinGameAck.get())->SetData(joinGameAckData);
+			JoinGameAck_t *joinAck = &netJoinReply->joinGameResult.choice.joinGameAck;
-			server->GetLobbyThread().GetSender().Send(session.sessionData, joinGameAck);
+			joinAck->areYouAdmin = session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN;
+			NetPacket::SetGameData(server->GetGameData(), &joinAck->gameInfo);
+			OCTET_STRING_fromBuf(
+				&joinAck->gameInfo.gameName,
+				session.playerData->GetName().c_str(),
+				session.playerData->GetName().length());
+			server->GetLobbyThread().GetSender().Send(session.sessionData, packet);
 
 			// Send notifications for connected players to client.
 			PlayerDataList tmpPlayerList = server->GetFullPlayerDataList();
@@ -346,12 +350,12 @@ ServerGameStateInit::HandleNewSession(boost::shared_ptr<ServerGame> server, Sess
 			PlayerDataList::iterator player_end = tmpPlayerList.end();
 			while (player_i != player_end)
 			{
-				server->GetLobbyThread().GetSender().Send(session.sessionData, CreateNetPacketPlayerJoined(*(*player_i)));
+				server->GetLobbyThread().GetSender().Send(session.sessionData, CreateNetPacketPlayerJoined(server->GetId(), *(*player_i)));
 				++player_i;
 			}
 
 			// Send "Player Joined" to other fully connected clients.
-			server->SendToAllPlayers(CreateNetPacketPlayerJoined(*session.playerData), SessionData::Game);
+			server->SendToAllPlayers(CreateNetPacketPlayerJoined(server->GetId(), *session.playerData), SessionData::Game);
 
 			// Accept session.
 			server->GetSessionManager().AddSession(session);
@@ -388,12 +392,12 @@ ServerGameStateInit::TimerAdminWarning(const boost::system::error_code &ec, boos
 		if (session.sessionData.get())
 		{
 			// Send him a warning.
-			boost::shared_ptr<NetPacket> warning(new NetPacketTimeoutWarning);
+			boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-			NetPacketTimeoutWarning::Data warningData;
+			packet->GetMsg()->present = PokerTHMessage_PR_timeoutWarningMessage;
-			warningData.timeoutReason = NETWORK_TIMEOUT_GAME_ADMIN_IDLE;
+			TimeoutWarningMessage_t *netWarning = &packet->GetMsg()->choice.timeoutWarningMessage;
-			warningData.remainingSeconds = SERVER_GAME_ADMIN_WARNING_REMAINING_SEC;
+			netWarning->timeoutReason = NETWORK_TIMEOUT_GAME_ADMIN_IDLE;
-			static_cast<NetPacketTimeoutWarning *>(warning.get())->SetData(warningData);
+			netWarning->remainingSeconds = SERVER_GAME_ADMIN_WARNING_REMAINING_SEC;
-			server->GetLobbyThread().GetSender().Send(session.sessionData, warning);
+			server->GetLobbyThread().GetSender().Send(session.sessionData, packet);
 		}
 		// Start timeout timer.
 		server->GetStateTimer().expires_from_now(
@@ -422,18 +426,16 @@ ServerGameStateInit::TimerAdminTimeout(const boost::system::error_code &ec, boos
 void
 ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
 {
-	if (packet->ToNetPacketStartEvent())
+	if (packet->GetMsg()->present == PokerTHMessage_PR_startEventMessage)
 	{
+		StartEventMessage_t *netStartEvent = &packet->GetMsg()->choice.startEventMessage;
 		// Only admins are allowed to start the game.
-		if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN)
+		if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN && netStartEvent->gameId == server->GetId())
 		{
-			NetPacketStartEvent::Data startData;
-			packet->ToNetPacketStartEvent()->GetData(startData);
-
 			// Fill up with computer players.
 			server->ResetComputerPlayerList();
 
-			if (startData.fillUpWithCpuPlayers)
+			if (netStartEvent->fillWithComputerPlayers)
 			{
 				int remainingSlots = server->GetGameData().maxNumberOfPlayers - server->GetCurNumberOfPlayers();
 				for (int i = 1; i <= remainingSlots; i++)
@@ -447,19 +449,19 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
 					server->AddComputerPlayer(tmpPlayerData);
 
 					// Send "Player Joined" to other fully connected clients.
-					server->SendToAllPlayers(CreateNetPacketPlayerJoined(*tmpPlayerData), SessionData::Game);
+					server->SendToAllPlayers(CreateNetPacketPlayerJoined(server->GetId(), *tmpPlayerData), SessionData::Game);
 
 					// Notify lobby.
 					server->GetLobbyThread().NotifyPlayerJoinedGame(server->GetId(), tmpPlayerData->GetUniqueId());
 				}
 			}
 			// Wait for all players to confirm start of game.
-			server->SendToAllPlayers(boost::shared_ptr<NetPacket>(packet->Clone()), SessionData::Game);
+			server->SendToAllPlayers(packet, SessionData::Game);
 
 			server->SetState(ServerGameStateStartGame::Instance());
 		}
 	}
-	else if (packet->ToNetPacketResetTimeout())
+	else if (packet->GetMsg()->present == PokerTHMessage_PR_resetTimeoutMessage)
 	{
 		if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN)
 		{
@@ -473,14 +475,17 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
 }
 
 boost::shared_ptr<NetPacket>
-ServerGameStateInit::CreateNetPacketPlayerJoined(const PlayerData &playerData)
+ServerGameStateInit::CreateNetPacketPlayerJoined(unsigned gameId, const PlayerData &playerData)
 {
-	boost::shared_ptr<NetPacket> thisPlayerJoined(new NetPacketPlayerJoined);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketPlayerJoined::Data thisPlayerJoinedData;
+	packet->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
-	thisPlayerJoinedData.playerId = playerData.GetUniqueId();
+	GamePlayerMessage_t *netGamePlayer = &packet->GetMsg()->choice.gamePlayerMessage;
-	thisPlayerJoinedData.prights = playerData.GetRights();
+	netGamePlayer->gameId = gameId;
-	static_cast<NetPacketPlayerJoined *>(thisPlayerJoined.get())->SetData(thisPlayerJoinedData);
+	netGamePlayer->gamePlayerNotification.present = gamePlayerNotification_PR_gamePlayerJoined;
-	return thisPlayerJoined;
+	GamePlayerJoined_t *playerJoined = &netGamePlayer->gamePlayerNotification.choice.gamePlayerJoined;
+	playerJoined->playerId = playerData.GetUniqueId();
+	playerJoined->isAdmin = playerData.GetRights() == PLAYER_RIGHTS_ADMIN;
+	return packet;
 }
 
 //-----------------------------------------------------------------------------
@@ -527,7 +532,7 @@ ServerGameStateStartGame::HandleNewSession(boost::shared_ptr<ServerGame> server,
 void
 ServerGameStateStartGame::InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
 {
-	if (packet->ToNetPacketStartEventAck())
+	if (packet->GetMsg()->present == PokerTHMessage_PR_startEventAckMessage)
 	{
 		session.sessionData->SetReadyFlag();
 		if (server->GetSessionManager().CountReadySessions() == server->GetSessionManager().GetRawSessionCount())
@@ -570,10 +575,11 @@ ServerGameStateStartGame::DoStart(boost::shared_ptr<ServerGame> server)
 	{
 		server->InternalStartGame();
 
-		boost::shared_ptr<NetPacket> answer(new NetPacketGameStart);
+		boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-
+		packet->GetMsg()->present = PokerTHMessage_PR_gameStartMessage;
-		NetPacketGameStart::Data gameStartData;
+		GameStartMessage_t *netGameStart = &packet->GetMsg()->choice.gameStartMessage;
-		gameStartData.startData = server->GetStartData();
+		netGameStart->gameId = server->GetId();
+		netGameStart->startDealerPlayerId = server->GetStartData().startDealerPlayerId;
 
 		// Send player order to clients.
 		// Assume player list is sorted by number.
@@ -581,15 +587,14 @@ ServerGameStateStartGame::DoStart(boost::shared_ptr<ServerGame> server)
 		PlayerDataList::iterator player_end = tmpPlayerList.end();
 		while (player_i != player_end)
 		{
-			NetPacketGameStart::PlayerSlot tmpPlayerSlot;
+			NonZeroId_t *playerSlot = (NonZeroId_t *)calloc(1, sizeof(NonZeroId_t));
-			tmpPlayerSlot.playerId = (*player_i)->GetUniqueId();
+			*playerSlot = (*player_i)->GetUniqueId();
-			gameStartData.playerSlots.push_back(tmpPlayerSlot);
+			ASN_SEQUENCE_ADD(&netGameStart->playerSeats.list, playerSlot);
 	
 			++player_i;
 		}
 
-		static_cast<NetPacketGameStart *>(answer.get())->SetData(gameStartData);
+		server->SendToAllPlayers(packet, SessionData::Game);
-		server->SendToAllPlayers(answer, SessionData::Game);
 
 		// Start the first hand.
 		ServerGameStateHand::StartNewHand(server);
@@ -688,26 +693,26 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
 			&& nonFoldPlayers.size() > 1)
 		{
 			// Send cards of all active players to all players (all in).
-			boost::shared_ptr<NetPacket> allIn(new NetPacketAllInShowCards);
+			boost::shared_ptr<NetPacket> allIn(new NetPacket(NetPacket::Alloc));
-			NetPacketAllInShowCards::Data allInData;
+			allIn->GetMsg()->present = PokerTHMessage_PR_allInShowCardsMessage;
+			AllInShowCardsMessage_t *netAllInShow = &allIn->GetMsg()->choice.allInShowCardsMessage;
+			netAllInShow->gameId = server->GetId();
 
 			PlayerListConstIterator i = nonFoldPlayers.begin();
 			PlayerListConstIterator end = nonFoldPlayers.end();
 
 			while (i != end)
 			{
-				NetPacketAllInShowCards::PlayerCards tmpPlayerCards;
+				PlayerAllIn_t *playerAllIn = (PlayerAllIn_t *)calloc(1, sizeof(PlayerAllIn_t));
-				tmpPlayerCards.playerId = (*i)->getMyUniqueID();
+				playerAllIn->playerId = (*i)->getMyUniqueID();
-
 				int tmpCards[2];
 				(*i)->getMyCards(tmpCards);
-				tmpPlayerCards.cards[0] = static_cast<u_int16_t>(tmpCards[0]);
+				playerAllIn->allInCard1 = tmpCards[0];
-				tmpPlayerCards.cards[1] = static_cast<u_int16_t>(tmpCards[1]);
+				playerAllIn->allInCard2 = tmpCards[1];
+				ASN_SEQUENCE_ADD(&netAllInShow->playersAllIn.list, playerAllIn);
 
-				allInData.playerCards.push_back(tmpPlayerCards);
 				++i;
 			}
-			static_cast<NetPacketAllInShowCards *>(allIn.get())->SetData(allInData);
 			server->SendToAllPlayers(allIn, SessionData::Game);
 			curGame.getCurrentHand()->setCardsShown(true);
 
@@ -742,12 +747,12 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
 			if (!curPlayer->getMyActiveStatus())
 				throw ServerException(__FILE__, __LINE__, ERR_NET_PLAYER_NOT_ACTIVE, 0);
 
-			boost::shared_ptr<NetPacket> notification(new NetPacketPlayersTurn);
+			boost::shared_ptr<NetPacket> notification(new NetPacket(NetPacket::Alloc));
-			NetPacketPlayersTurn::Data playersTurnData;
+			notification->GetMsg()->present = PokerTHMessage_PR_playersTurnMessage;
-			playersTurnData.gameState = (GameState)curGame.getCurrentHand()->getCurrentRound();
+			PlayersTurnMessage_t *netPlayersTurn = &notification->GetMsg()->choice.playersTurnMessage;
-			playersTurnData.playerId = curPlayer->getMyUniqueID();
+			netPlayersTurn->gameId = server->GetId();
-			static_cast<NetPacketPlayersTurn *>(notification.get())->SetData(playersTurnData);
+			netPlayersTurn->gameState = curGame.getCurrentHand()->getCurrentRound();
-
+			netPlayersTurn->playerId = curPlayer->getMyUniqueID();
 			server->SendToAllPlayers(notification, SessionData::Game);
 
 			// If the player is computer controlled, let the engine act.
@@ -788,48 +793,57 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
 			{
 				// End of Hand, but keep cards hidden.
 				boost::shared_ptr<PlayerInterface> player = nonFoldPlayers.front();
-				boost::shared_ptr<NetPacket> endHand(new NetPacketEndOfHandHideCards);
+				boost::shared_ptr<NetPacket> endHand(new NetPacket(NetPacket::Alloc));
-				NetPacketEndOfHandHideCards::Data endHandData;
+				endHand->GetMsg()->present = PokerTHMessage_PR_endOfHandMessage;
-				endHandData.playerId = player->getMyUniqueID();
+				EndOfHandMessage_t *netEndHand = &endHand->GetMsg()->choice.endOfHandMessage;
-				endHandData.moneyWon = player->getLastMoneyWon();
+				netEndHand->gameId = server->GetId();
-				endHandData.playerMoney = player->getMyCash();
-				static_cast<NetPacketEndOfHandHideCards *>(endHand.get())->SetData(endHandData);
 
+				netEndHand->endOfHandType.present = endOfHandType_PR_endOfHandHideCards;
+				EndOfHandHideCards_t *endHandHide = &netEndHand->endOfHandType.choice.endOfHandHideCards;
+				endHandHide->playerId = player->getMyUniqueID();
+				endHandHide->moneyWon = player->getLastMoneyWon();
+				endHandHide->playerMoney = player->getMyCash();
 				server->SendToAllPlayers(endHand, SessionData::Game);
 			}
 			else
 			{
 				// End of Hand - show cards of active players.
-				boost::shared_ptr<NetPacket> endHand(new NetPacketEndOfHandShowCards);
+				boost::shared_ptr<PlayerInterface> player = nonFoldPlayers.front();
-				NetPacketEndOfHandShowCards::Data endHandData;
+				boost::shared_ptr<NetPacket> endHand(new NetPacket(NetPacket::Alloc));
+				endHand->GetMsg()->present = PokerTHMessage_PR_endOfHandMessage;
+				EndOfHandMessage_t *netEndHand = &endHand->GetMsg()->choice.endOfHandMessage;
+				netEndHand->gameId = server->GetId();
+
+				netEndHand->endOfHandType.present = endOfHandType_PR_endOfHandShowCards;
+				EndOfHandShowCards_t *endHandShow = &netEndHand->endOfHandType.choice.endOfHandShowCards;
 
 				PlayerListConstIterator i = nonFoldPlayers.begin();
 				PlayerListConstIterator end = nonFoldPlayers.end();
 
 				while (i != end)
 				{
-					NetPacketEndOfHandShowCards::PlayerResult tmpPlayerResult;
+					PlayerResult_t *playerResult = (PlayerResult_t *)calloc(1, sizeof(PlayerResult_t));
-					tmpPlayerResult.playerId = (*i)->getMyUniqueID();
+					playerResult->playerId = (*i)->getMyUniqueID();
-
 					int tmpCards[2];
 					int bestHandPos[5];
 					(*i)->getMyCards(tmpCards);
-					tmpPlayerResult.cards[0] = static_cast<u_int16_t>(tmpCards[0]);
+					playerResult->resultCard1 = tmpCards[0];
-					tmpPlayerResult.cards[1] = static_cast<u_int16_t>(tmpCards[1]);
+					playerResult->resultCard2 = tmpCards[1];
-
 					(*i)->getMyBestHandPosition(bestHandPos);
 					for (int num = 0; num < 5; num++)
-						tmpPlayerResult.bestHandPos[num] = bestHandPos[num];
+					{
+						long *handPos = (long *)calloc(1, sizeof(long));
+						*handPos = bestHandPos[num];
+						ASN_SEQUENCE_ADD(&playerResult->bestHandPosition.list, handPos);
+					}
 
-					tmpPlayerResult.valueOfCards = (*i)->getMyCardsValueInt();
+					playerResult->cardsValue = (*i)->getMyCardsValueInt();
-					tmpPlayerResult.moneyWon = (*i)->getLastMoneyWon();
+					playerResult->moneyWon = (*i)->getLastMoneyWon();
-					tmpPlayerResult.playerMoney = (*i)->getMyCash();
+					playerResult->playerMoney = (*i)->getMyCash();
 
-					endHandData.playerResults.push_back(tmpPlayerResult);
+					ASN_SEQUENCE_ADD(&endHandShow->playerResults.list, playerResult);
 					++i;
 				}
-				static_cast<NetPacketEndOfHandShowCards *>(endHand.get())->SetData(endHandData);
-
 				server->SendToAllPlayers(endHand, SessionData::Game);
 			}
 
@@ -934,11 +948,11 @@ ServerGameStateHand::TimerNextGame(const boost::system::error_code &ec, boost::s
 
 		if (winnerPlayer)
 		{
-			boost::shared_ptr<NetPacket> endGame(new NetPacketEndOfGame);
+			boost::shared_ptr<NetPacket> endGame(new NetPacket(NetPacket::Alloc));
-			NetPacketEndOfGame::Data endGameData;
+			endGame->GetMsg()->present = PokerTHMessage_PR_endOfGameMessage;
-			endGameData.winnerPlayerId = winnerPlayer->getMyUniqueID();
+			EndOfGameMessage_t *netEndGame = &endGame->GetMsg()->choice.endOfGameMessage;
-			static_cast<NetPacketEndOfGame *>(endGame.get())->SetData(endGameData);
+			netEndGame->gameId = server->GetId();
-
+			netEndGame->winnerPlayerId = winnerPlayer->getMyUniqueID();
 			server->SendToAllPlayers(endGame, SessionData::Game);
 
 			// Wait for the start of a new game.
@@ -1002,13 +1016,14 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
 		{
 			int cards[2];
 			tmpPlayer->getMyCards(cards);
-			boost::shared_ptr<NetPacket> notifyCards(new NetPacketHandStart);
-			NetPacketHandStart::Data handStartData;
-			handStartData.yourCards[0] = static_cast<unsigned>(cards[0]);
-			handStartData.yourCards[1] = static_cast<unsigned>(cards[1]);
-			handStartData.smallBlind = curGame.getCurrentHand()->getSmallBlind();
-			static_cast<NetPacketHandStart *>(notifyCards.get())->SetData(handStartData);
 
+			boost::shared_ptr<NetPacket> notifyCards(new NetPacket(NetPacket::Alloc));
+			notifyCards->GetMsg()->present = PokerTHMessage_PR_handStartMessage;
+			HandStartMessage_t *netHandStart = &notifyCards->GetMsg()->choice.handStartMessage;
+			netHandStart->gameId = server->GetId();
+			netHandStart->yourCard1 = cards[0];
+			netHandStart->yourCard2 = cards[1];
+			netHandStart->smallBlind = curGame.getCurrentHand()->getSmallBlind();
 			server->GetLobbyThread().GetSender().Send(tmpPlayer->getNetSessionData(), notifyCards);
 		}
 		++i;
@@ -1026,16 +1041,17 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
 		boost::shared_ptr<PlayerInterface> tmpPlayer = *i;
 		if (tmpPlayer->getMyButton() == BUTTON_SMALL_BLIND)
 		{
-			boost::shared_ptr<NetPacket> notifySmallBlind(new NetPacketPlayersActionDone);
+			boost::shared_ptr<NetPacket> notifySmallBlind(new NetPacket(NetPacket::Alloc));
-			NetPacketPlayersActionDone::Data actionDoneData;
+			notifySmallBlind->GetMsg()->present = PokerTHMessage_PR_playersActionDoneMessage;
-			actionDoneData.gameState = GAME_STATE_PREFLOP_SMALL_BLIND;
+			PlayersActionDoneMessage_t *netSmallBlind = &notifySmallBlind->GetMsg()->choice.playersActionDoneMessage;
-			actionDoneData.playerId = tmpPlayer->getMyUniqueID();
+			netSmallBlind->gameId = server->GetId();
-			actionDoneData.playerAction = (PlayerAction)tmpPlayer->getMyAction();
+			netSmallBlind->gameState = NetGameState_statePreflopSmallBlind;
-			actionDoneData.totalPlayerBet = tmpPlayer->getMySet();
+			netSmallBlind->playerId = tmpPlayer->getMyUniqueID();
-			actionDoneData.playerMoney = tmpPlayer->getMyCash();
+			netSmallBlind->playerAction = tmpPlayer->getMyAction();
-			actionDoneData.highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
+			netSmallBlind->totalPlayerBet = tmpPlayer->getMySet();
-			actionDoneData.minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
+			netSmallBlind->playerMoney = tmpPlayer->getMyCash();
-			static_cast<NetPacketPlayersActionDone *>(notifySmallBlind.get())->SetData(actionDoneData);
+			netSmallBlind->highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
+			netSmallBlind->minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
 			server->SendToAllPlayers(notifySmallBlind, SessionData::Game);
 			break;
 		}
@@ -1049,16 +1065,17 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
 		boost::shared_ptr<PlayerInterface> tmpPlayer = *i;
 		if (tmpPlayer->getMyButton() == BUTTON_BIG_BLIND)
 		{
-			boost::shared_ptr<NetPacket> notifyBigBlind(new NetPacketPlayersActionDone);
+			boost::shared_ptr<NetPacket> notifyBigBlind(new NetPacket(NetPacket::Alloc));
-			NetPacketPlayersActionDone::Data actionDoneData;
+			notifyBigBlind->GetMsg()->present = PokerTHMessage_PR_playersActionDoneMessage;
-			actionDoneData.gameState = GAME_STATE_PREFLOP_BIG_BLIND;
+			PlayersActionDoneMessage_t *netBigBlind = &notifyBigBlind->GetMsg()->choice.playersActionDoneMessage;
-			actionDoneData.playerId = tmpPlayer->getMyUniqueID();
+			netBigBlind->gameId = server->GetId();
-			actionDoneData.playerAction = (PlayerAction)tmpPlayer->getMyAction();
+			netBigBlind->gameState = NetGameState_statePreflopBigBlind;
-			actionDoneData.totalPlayerBet = tmpPlayer->getMySet();
+			netBigBlind->playerId = tmpPlayer->getMyUniqueID();
-			actionDoneData.playerMoney = tmpPlayer->getMyCash();
+			netBigBlind->playerAction = tmpPlayer->getMyAction();
-			actionDoneData.highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
+			netBigBlind->totalPlayerBet = tmpPlayer->getMySet();
-			actionDoneData.minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
+			netBigBlind->playerMoney = tmpPlayer->getMyCash();
-			static_cast<NetPacketPlayersActionDone *>(notifyBigBlind.get())->SetData(actionDoneData);
+			netBigBlind->highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
+			netBigBlind->minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
 			server->SendToAllPlayers(notifyBigBlind, SessionData::Game);
 			break;
 		}
@@ -1116,11 +1133,11 @@ ServerGameStateWaitPlayerAction::HandleNewSession(boost::shared_ptr<ServerGame>
 void
 ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
 {
-	if (packet->ToNetPacketPlayersAction())
+	if (packet->GetMsg()->present == PokerTHMessage_PR_myActionRequestMessage)
 	{
-		NetPacketPlayersAction::Data actionData;
+		MyActionRequestMessage_t *netMyAction = &packet->GetMsg()->choice.myActionRequestMessage;
-		packet->ToNetPacketPlayersAction()->GetData(actionData);
 
+		// TODO consider game id.
 		Game &curGame = server->GetGame();
 		boost::shared_ptr<PlayerInterface> tmpPlayer = curGame.getPlayerByUniqueId(session.playerData->GetUniqueId());
 		if (!tmpPlayer.get())
@@ -1128,7 +1145,7 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
 
 		// Check whether this is the correct round.
 		PlayerActionCode code = ACTION_CODE_VALID;
-		if (curGame.getCurrentHand()->getCurrentRound() != actionData.gameState)
+		if (curGame.getCurrentHand()->getCurrentRound() != netMyAction->gameState)
 			code = ACTION_CODE_INVALID_STATE;
 
 		// Check whether this is the correct player.
@@ -1140,21 +1157,21 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
 		}
 
 		// If the client omitted some values, fill them in.
-		if (actionData.playerAction == PLAYER_ACTION_CALL && actionData.playerBet == 0)
+		if (netMyAction->myAction == PLAYER_ACTION_CALL && netMyAction->myRelativeBet == 0)
 		{
 			if (curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() >= tmpPlayer->getMySet() + tmpPlayer->getMyCash())
-				actionData.playerAction = PLAYER_ACTION_ALLIN;
+				netMyAction->myAction = PLAYER_ACTION_ALLIN;
 			else
-				actionData.playerBet = curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() - tmpPlayer->getMySet();
+				netMyAction->myRelativeBet = curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() - tmpPlayer->getMySet();
 		}
-		if (actionData.playerAction == PLAYER_ACTION_ALLIN && actionData.playerBet == 0)
+		if (netMyAction->myAction == PLAYER_ACTION_ALLIN && netMyAction->myRelativeBet == 0)
-			actionData.playerBet = tmpPlayer->getMyCash();
+			netMyAction->myRelativeBet = tmpPlayer->getMyCash();
 
 		// Check whether the action is valid.
 		if (code == ACTION_CODE_VALID
 			&& (tmpPlayer->checkMyAction(
-					actionData.playerAction,
+					netMyAction->myAction,
-					actionData.playerBet,
+					netMyAction->myRelativeBet,
 					curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet(),
 					curGame.getCurrentHand()->getCurrentBeRo()->getMinimumRaise(),
 					curGame.getCurrentHand()->getSmallBlind()) != 0))
@@ -1164,19 +1181,20 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
 
 		if (code == ACTION_CODE_VALID)
 		{
-			PerformPlayerAction(*server, tmpPlayer, actionData.playerAction, actionData.playerBet);
+			PerformPlayerAction(*server, tmpPlayer, static_cast<PlayerAction>(netMyAction->myAction), netMyAction->myRelativeBet);
 			server->SetState(ServerGameStateHand::Instance());
 		}
 		else
 		{
 			// Send reject message.
-			boost::shared_ptr<NetPacket> reject(new NetPacketPlayersActionRejected);
+			boost::shared_ptr<NetPacket> reject(new NetPacket(NetPacket::Alloc));
-			NetPacketPlayersActionRejected::Data rejectData;
+			reject->GetMsg()->present = PokerTHMessage_PR_yourActionRejectedMessage;
-			rejectData.gameState = actionData.gameState;
+			YourActionRejectedMessage_t *netActionRejected = &reject->GetMsg()->choice.yourActionRejectedMessage;
-			rejectData.playerAction = actionData.playerAction;
+			netActionRejected->gameId = server->GetId();
-			rejectData.playerBet = actionData.playerBet;
+			netActionRejected->gameState = netMyAction->gameState;
-			rejectData.rejectionReason = code;
+			netActionRejected->yourAction = netMyAction->myAction;
-			static_cast<NetPacketPlayersActionRejected *>(reject.get())->SetData(rejectData);
+			netActionRejected->yourRelativeBet = netMyAction->myRelativeBet;
+			netActionRejected->rejectionReason = code;
 			server->GetLobbyThread().GetSender().Send(session.sessionData, reject);
 		}
 	}

src/net/common/serverlobbythread.cpp

@@ -192,10 +192,33 @@ ServerLobbyThread::ReAddSession(SessionWrapper session, int reason)
 {
 	if (session.sessionData.get() && session.playerData.get())
 	{
-		boost::shared_ptr<NetPacket> packet(new NetPacketRemovedFromGame);
+		boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-		NetPacketRemovedFromGame::Data removedData;
+		packet->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
-		removedData.removeReason = reason;
+		GamePlayerMessage_t *netPlayerMsg = &packet->GetMsg()->choice.gamePlayerMessage;
-		static_cast<NetPacketRemovedFromGame *>(packet.get())->SetData(removedData);
+		netPlayerMsg->gamePlayerNotification.present = gamePlayerNotification_PR_removedFromGame;
+		RemovedFromGame_t *removed = &netPlayerMsg->gamePlayerNotification.choice.removedFromGame;
+
+		switch (reason)
+		{
+			case NTF_NET_REMOVED_GAME_FULL :
+				removed->removedFromGameReason = removedFromGameReason_gameIsFull;
+				break;
+			case NTF_NET_REMOVED_ALREADY_RUNNING :
+				removed->removedFromGameReason = removedFromGameReason_gameIsRunning;
+				break;
+			case NTF_NET_REMOVED_KICKED :
+				removed->removedFromGameReason = removedFromGameReason_kickedFromGame;
+				break;
+			case NTF_NET_REMOVED_TIMEOUT :
+				removed->removedFromGameReason = removedFromGameReason_gameTimeout;
+				break;
+			case NTF_NET_REMOVED_START_FAILED :
+				removed->removedFromGameReason = removedFromGameReason_removedStartFailed;
+				break;
+			default :
+				removed->removedFromGameReason = removedFromGameReason_removedOnRequest;
+				break;
+		}
 		GetSender().Send(session.sessionData, packet);
 
 		HandleReAddedSession(session);
@@ -251,11 +274,15 @@ void
 ServerLobbyThread::NotifyPlayerJoinedGame(unsigned gameId, unsigned playerId)
 {
 	// Send notification to players in lobby.
-	boost::shared_ptr<NetPacket> packet(new NetPacketGameListPlayerJoined);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketGameListPlayerJoined::Data packetData;
+	packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
-	packetData.gameId = gameId;
+	GameListMessage_t *netListMsg = &packet->GetMsg()->choice.gameListMessage;
-	packetData.playerId = playerId;
+	netListMsg->gameId = gameId;
-	static_cast<NetPacketGameListPlayerJoined *>(packet.get())->SetData(packetData);
+
+	netListMsg->gameListNotification.present = gameListNotification_PR_gameListPlayerJoined;
+	GameListPlayerJoined_t *playerJoined = &netListMsg->gameListNotification.choice.gameListPlayerJoined;
+	playerJoined->playerId = playerId;
+
 	m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
 	m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
 }
@@ -264,11 +291,15 @@ void
 ServerLobbyThread::NotifyPlayerLeftGame(unsigned gameId, unsigned playerId)
 {
 	// Send notification to players in lobby.
-	boost::shared_ptr<NetPacket> packet(new NetPacketGameListPlayerLeft);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketGameListPlayerLeft::Data packetData;
+	packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
-	packetData.gameId = gameId;
+	GameListMessage_t *netListMsg = &packet->GetMsg()->choice.gameListMessage;
-	packetData.playerId = playerId;
+	netListMsg->gameId = gameId;
-	static_cast<NetPacketGameListPlayerLeft *>(packet.get())->SetData(packetData);
+
+	netListMsg->gameListNotification.present = gameListNotification_PR_gameListPlayerLeft;
+	GameListPlayerLeft_t *playerLeft = &netListMsg->gameListNotification.choice.gameListPlayerLeft;
+	playerLeft->playerId = playerId;
+
 	m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
 	m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
 }
@@ -277,11 +308,15 @@ void
 ServerLobbyThread::NotifyGameAdminChanged(unsigned gameId, unsigned newAdminPlayerId)
 {
 	// Send notification to players in lobby.
-	boost::shared_ptr<NetPacket> packet(new NetPacketGameListAdminChanged);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketGameListAdminChanged::Data packetData;
+	packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
-	packetData.gameId = gameId;
+	GameListMessage_t *netListMsg = &packet->GetMsg()->choice.gameListMessage;
-	packetData.newAdminplayerId = newAdminPlayerId;
+	netListMsg->gameId = gameId;
-	static_cast<NetPacketGameListAdminChanged *>(packet.get())->SetData(packetData);
+
+	netListMsg->gameListNotification.present = gameListNotification_PR_gameListAdminChanged;
+	GameListAdminChanged_t *adminChanged = &netListMsg->gameListNotification.choice.gameListAdminChanged;
+	adminChanged->newAdminPlayerId = newAdminPlayerId;
+
 	m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
 	m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
 }
@@ -303,17 +338,17 @@ ServerLobbyThread::NotifyReopeningGame(unsigned gameId)
 }
 
 void
-ServerLobbyThread::HandleGameRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket)
+ServerLobbyThread::HandleGameRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest)
 {
 	// Someone within a game requested player info.
-	HandleNetPacketRetrievePlayerInfo(session, tmpPacket);
+	HandleNetPacketRetrievePlayerInfo(session, playerInfoRequest);
 }
 
 void
-ServerLobbyThread::HandleGameRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket)
+ServerLobbyThread::HandleGameRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar)
 {
 	// Someone within a game requested an avatar.
-	HandleNetPacketRetrieveAvatar(session, tmpPacket);
+	HandleNetPacketRetrieveAvatar(session, retrieveAvatar);
 }
 
 bool
@@ -357,22 +392,32 @@ ServerLobbyThread::RemovePlayer(unsigned playerId, unsigned errorCode)
 void
 ServerLobbyThread::SendGlobalChat(const string &message)
 {
-	boost::shared_ptr<NetPacket> outChat(new NetPacketChatText);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketChatText::Data outChatData;
+	packet->GetMsg()->present = PokerTHMessage_PR_chatMessage;
-	outChatData.playerId = 0;
+	ChatMessage_t *netChat = &packet->GetMsg()->choice.chatMessage;
-	outChatData.text = message;
+	// TODO proper game id handling.
-	static_cast<NetPacketChatText *>(outChat.get())->SetData(outChatData);
+	netChat->gameId = 0;
-	m_gameSessionManager.SendToAllSessions(GetSender(), outChat, SessionData::Game);
+	netChat->playerId = 0;
+	OCTET_STRING_fromBuf(
+		&netChat->chatText,
+		message.c_str(),
+		message.length());
+
+	m_gameSessionManager.SendToAllSessions(GetSender(), packet, SessionData::Game);
 }
 
 void
 ServerLobbyThread::SendGlobalMsgBox(const string &message)
 {
-	boost::shared_ptr<NetPacket> outMsg(new NetPacketMsgBoxText);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketMsgBoxText::Data outMsgData;
+	packet->GetMsg()->present = PokerTHMessage_PR_dialogMessage;
-	outMsgData.text = message;
+	DialogMessage_t *netDialog = &packet->GetMsg()->choice.dialogMessage;
-	static_cast<NetPacketMsgBoxText *>(outMsg.get())->SetData(outMsgData);
+
-	m_gameSessionManager.SendToAllSessions(GetSender(), outMsg, SessionData::Game);
+	OCTET_STRING_fromBuf(
+		&netDialog->notificationText,
+		message.c_str(),
+		message.length());
+	m_gameSessionManager.SendToAllSessions(GetSender(), packet, SessionData::Game);
 }
 
 void
@@ -626,40 +671,63 @@ ServerLobbyThread::HandlePacket(SessionWrapper session, boost::shared_ptr<NetPac
 
 		if (session.sessionData->GetState() == SessionData::Init)
 		{
-			if (packet->ToNetPacketInit())
+			if (packet->GetMsg()->present == PokerTHMessage_PR_initMessage)
-				HandleNetPacketInit(session, *packet->ToNetPacketInit());
+				HandleNetPacketInit(session, packet->GetMsg()->choice.initMessage);
-			else if (packet->ToNetPacketAvatarHeader())
+			else if (packet->GetMsg()->present == PokerTHMessage_PR_avatarReplyMessage)
-				HandleNetPacketAvatarHeader(session, *packet->ToNetPacketAvatarHeader());
+			{
-			else if (packet->ToNetPacketUnknownAvatar())
+				AvatarReplyMessage_t *avatarReply = &packet->GetMsg()->choice.avatarReplyMessage;
-				HandleNetPacketUnknownAvatar(session, *packet->ToNetPacketUnknownAvatar());
+				if (avatarReply->avatarResult.present == avatarResult_PR_avatarHeader)
+					HandleNetPacketAvatarHeader(session, avatarReply->requestId, avatarReply->avatarResult.choice.avatarHeader);
+				else if (avatarReply->avatarResult.present == avatarResult_PR_unknownAvatar)
+					HandleNetPacketUnknownAvatar(session, avatarReply->requestId, avatarReply->avatarResult.choice.unknownAvatar);
+				else
+					SessionError(session, ERR_SOCK_INVALID_STATE);
+			}
 			else
 				SessionError(session, ERR_SOCK_INVALID_STATE);
 		}
 		else if (session.sessionData->GetState() == SessionData::ReceivingAvatar)
 		{
-			if (packet->ToNetPacketAvatarFile())
+			if (packet->GetMsg()->present == PokerTHMessage_PR_avatarReplyMessage)
-				HandleNetPacketAvatarFile(session, *packet->ToNetPacketAvatarFile());
+			{
-			else if (packet->ToNetPacketAvatarEnd())
+				AvatarReplyMessage_t *avatarReply = &packet->GetMsg()->choice.avatarReplyMessage;
-				HandleNetPacketAvatarEnd(session, *packet->ToNetPacketAvatarEnd());
+				if (avatarReply->avatarResult.present == avatarResult_PR_avatarData)
+					HandleNetPacketAvatarFile(session, avatarReply->requestId, avatarReply->avatarResult.choice.avatarData);
+				else if (avatarReply->avatarResult.present == avatarResult_PR_avatarEnd)
+					HandleNetPacketAvatarEnd(session, avatarReply->requestId, avatarReply->avatarResult.choice.avatarEnd);
+				else
+					SessionError(session, ERR_SOCK_INVALID_STATE);
+			}
 			else
 				SessionError(session, ERR_SOCK_INVALID_STATE);
 		}
 		else
 		{
-			if (packet->ToNetPacketRetrievePlayerInfo())
+			if (packet->GetMsg()->present == PokerTHMessage_PR_playerInfoRequestMessage)
-				HandleNetPacketRetrievePlayerInfo(session, *packet->ToNetPacketRetrievePlayerInfo());
+				HandleNetPacketRetrievePlayerInfo(session, packet->GetMsg()->choice.playerInfoRequestMessage);
-			else if (packet->ToNetPacketRetrieveAvatar())
+			else if (packet->GetMsg()->present == PokerTHMessage_PR_avatarRequestMessage)
-				HandleNetPacketRetrieveAvatar(session, *packet->ToNetPacketRetrieveAvatar());
+				HandleNetPacketRetrieveAvatar(session, packet->GetMsg()->choice.avatarRequestMessage);
-			else if (packet->ToNetPacketResetTimeout())
+			else if (packet->GetMsg()->present == PokerTHMessage_PR_resetTimeoutMessage)
 			{}
-			else if (packet->ToNetPacketUnsubscribeGameList())
+			else if (packet->GetMsg()->present == PokerTHMessage_PR_subscriptionRequestMessage)
-				session.sessionData->ResetWantsLobbyMsg();
+			{
-			else if (packet->ToNetPacketResubscribeGameList())
+				SubscriptionRequestMessage_t *subscriptionRequest = &packet->GetMsg()->choice.subscriptionRequestMessage;
+				if (subscriptionRequest->subscriptionAction == subscriptionAction_resubscribeGameList)
 					InternalResubscribeMsg(session);
-			else if (packet->ToNetPacketCreateGame())
+				else
-				HandleNetPacketCreateGame(session, *packet->ToNetPacketCreateGame());
+					session.sessionData->ResetWantsLobbyMsg();
-			else if (packet->ToNetPacketJoinGame())
+			}
-				HandleNetPacketJoinGame(session, *packet->ToNetPacketJoinGame());
+			else if (packet->GetMsg()->present == PokerTHMessage_PR_joinGameRequestMessage)
+			{
+				JoinGameRequestMessage_t *joinRequest = &packet->GetMsg()->choice.joinGameRequestMessage;
+				string password;
+				if (joinRequest->password)
+					password = string((char *)joinRequest->password->buf, joinRequest->password->size);
+				if (joinRequest->joinGameAction.present == joinGameAction_PR_joinNewGame)
+					HandleNetPacketCreateGame(session, password, joinRequest->joinGameAction.choice.joinNewGame);
+				else if (joinRequest->joinGameAction.present == joinGameAction_PR_joinExistingGame)
+					HandleNetPacketJoinGame(session, password, joinRequest->joinGameAction.choice.joinExistingGame);
+			}
 			else
 				SessionError(session, ERR_SOCK_INVALID_STATE);
 		}
@@ -667,52 +735,61 @@ ServerLobbyThread::HandlePacket(SessionWrapper session, boost::shared_ptr<NetPac
 }
 
 void
-ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const NetPacketInit &tmpPacket)
+ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const InitMessage_t &initMessage)
 {
 	LOG_VERBOSE("Received init for session #" << session.sessionData->GetId() << ".");
 
-	NetPacketInit::Data initData;
-	tmpPacket.GetData(initData);
-
 	// Check the protocol version.
-	if (initData.versionMajor != NET_VERSION_MAJOR)
+	if (initMessage.requestedVersion.major != NET_VERSION_MAJOR)
 	{
 		SessionError(session, ERR_NET_VERSION_NOT_SUPPORTED);
 		return;
 	}
-	if (initData.versionMajor == 5 && (initData.versionMinor == 0 || initData.versionMinor == 1))
+	if (initMessage.requestedVersion.major == 5 && (initMessage.requestedVersion.minor == 0 || initMessage.requestedVersion.minor == 1))
 		session.sessionData->SetMaxNumPlayers(7);
 	else
 		session.sessionData->SetMaxNumPlayers(MAX_NUMBER_OF_PLAYERS);
 
+	string playerName;
+	MD5Buf avatarMD5;
+	if (initMessage.login.present == login_PR_anonymousLogin)
+	{
+		const AnonymousLogin_t *anonLogin = &initMessage.login.choice.anonymousLogin;
+		playerName = string((const char *)anonLogin->playerName.buf, anonLogin->playerName.size);
+		if (anonLogin->avatar)
+			memcpy(avatarMD5.data, anonLogin->avatar->buf, MD5_DATA_SIZE);
+	}
+	else
+		SessionError(session, ERR_NET_INVALID_PASSWORD); // TODO not yet supported
+
 	// Check the server password.
-	if (!CheckPassword(initData.password))
+/*	if (!CheckPassword(initData.password))
 	{
 		SessionError(session, ERR_NET_INVALID_PASSWORD);
 		return;
-	}
+	}*/
 
 	// Check whether the player name is correct.
 	// Partly, this is also done in netpacket.
 	// However, some disallowed names are checked only here.
-	if (initData.playerName.empty() || initData.playerName.size() > MAX_NAME_SIZE
+	if (playerName.empty()
-		|| initData.playerName[0] == '#'
+		|| playerName[0] == '#'
-		|| initData.playerName[0] == ' '
+		|| playerName[0] == ' '
-		|| initData.playerName.substr(0, sizeof(SERVER_COMPUTER_PLAYER_NAME) - 1) == SERVER_COMPUTER_PLAYER_NAME)
+		|| playerName.substr(0, sizeof(SERVER_COMPUTER_PLAYER_NAME) - 1) == SERVER_COMPUTER_PLAYER_NAME)
 	{
 		SessionError(session, ERR_NET_INVALID_PLAYER_NAME);
 		return;
 	}
 
 	// Check whether this player is already connected.
-	if (IsPlayerConnected(initData.playerName))
+	if (IsPlayerConnected(playerName))
 	{
 		SessionError(session, ERR_NET_PLAYER_NAME_IN_USE);
 		return;
 	}
 
 	// Check whether the player name is banned.
-	if (GetBanManager().IsPlayerBanned(initData.playerName))
+	if (GetBanManager().IsPlayerBanned(playerName))
 	{
 		SessionError(session, ERR_NET_PLAYER_BANNED);
 		return;
@@ -727,19 +804,17 @@ ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const NetPacketIn
 	// Create player data object.
 	boost::shared_ptr<PlayerData> tmpPlayerData(
 		new PlayerData(GetNextUniquePlayerId(), 0, PLAYER_TYPE_HUMAN, PLAYER_RIGHTS_NORMAL));
-	tmpPlayerData->SetName(initData.playerName);
+	tmpPlayerData->SetName(playerName);
 	tmpPlayerData->SetNetSessionData(session.sessionData);
-	if (initData.showAvatar)
+	tmpPlayerData->SetAvatarMD5(avatarMD5);
-		tmpPlayerData->SetAvatarMD5(initData.avatar);
 
 	// Set player data for session.
 	m_sessionManager.SetSessionPlayerData(session.sessionData->GetId(), tmpPlayerData);
 	session.playerData = tmpPlayerData;
 
 	string avatarFileName;
-	if (initData.showAvatar
+	if (!avatarMD5.IsZero()
-		&& !initData.avatar.IsZero()
+		&& !GetAvatarManager().GetAvatarFileName(avatarMD5, avatarFileName))
-		&& !GetAvatarManager().GetAvatarFileName(initData.avatar, avatarFileName))
 	{
 		bool avatarRecentlyRequested = false;
 		{
@@ -761,22 +836,19 @@ ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const NetPacketIn
 }
 
 void
-ServerLobbyThread::HandleNetPacketAvatarHeader(SessionWrapper session, const NetPacketAvatarHeader &tmpPacket)
+ServerLobbyThread::HandleNetPacketAvatarHeader(SessionWrapper session, unsigned /*requestId*/, const AvatarHeader_t &avatarHeader)
 {
 	if (session.playerData.get())
 	{
-		NetPacketAvatarHeader::Data headerData;
+		if (avatarHeader.avatarSize >= MIN_AVATAR_FILE_SIZE && avatarHeader.avatarSize <= MAX_AVATAR_FILE_SIZE)
-		tmpPacket.GetData(headerData);
-
-		if (headerData.avatarFileSize >= MIN_AVATAR_FILE_SIZE && headerData.avatarFileSize <= MAX_AVATAR_FILE_SIZE)
 		{
-			boost::shared_ptr<AvatarData> tmpAvatarData(new AvatarData);
+			boost::shared_ptr<AvatarFile> tmpAvatarFile(new AvatarFile);
-			tmpAvatarData->fileData.reserve(headerData.avatarFileSize);
+			tmpAvatarFile->fileData.reserve(avatarHeader.avatarSize);
-			tmpAvatarData->fileType = headerData.avatarFileType;
+			tmpAvatarFile->fileType = static_cast<AvatarFileType>(avatarHeader.avatarType);
-			tmpAvatarData->reportedSize = headerData.avatarFileSize;
+			tmpAvatarFile->reportedSize = avatarHeader.avatarSize;
 			// Ignore request id for now.
 
-			session.playerData->SetNetAvatarData(tmpAvatarData);
+			session.playerData->SetNetAvatarFile(tmpAvatarFile);
 
 			// Session is now receiving an avatar.
 			session.sessionData->SetState(SessionData::ReceivingAvatar);
@@ -787,12 +859,12 @@ ServerLobbyThread::HandleNetPacketAvatarHeader(SessionWrapper session, const Net
 }
 
 void
-ServerLobbyThread::HandleNetPacketUnknownAvatar(SessionWrapper session, const NetPacketUnknownAvatar &/*tmpPacket*/)
+ServerLobbyThread::HandleNetPacketUnknownAvatar(SessionWrapper session, unsigned /*requestId*/, const UnknownAvatar_t &/*unknownAvatar*/)
 {
 	if (session.playerData.get())
 	{
 		// Free memory (just in case).
-		session.playerData->SetNetAvatarData(boost::shared_ptr<AvatarData>());
+		session.playerData->SetNetAvatarFile(boost::shared_ptr<AvatarFile>());
 		session.playerData->SetAvatarMD5(MD5Buf());
 		// Start session.
 		EstablishSession(session);
@@ -800,27 +872,24 @@ ServerLobbyThread::HandleNetPacketUnknownAvatar(SessionWrapper session, const Ne
 }
 
 void
-ServerLobbyThread::HandleNetPacketAvatarFile(SessionWrapper session, const NetPacketAvatarFile &tmpPacket)
+ServerLobbyThread::HandleNetPacketAvatarFile(SessionWrapper session, unsigned /*requestId*/, const AvatarData_t &avatarData)
 {
 	if (session.playerData.get())
 	{
-		NetPacketAvatarFile::Data data;
+		boost::shared_ptr<AvatarFile> tmpAvatar = session.playerData->GetNetAvatarFile();
-		tmpPacket.GetData(data);
+		if (tmpAvatar.get() && tmpAvatar->fileData.size() + avatarData.avatarBlock.size <= tmpAvatar->reportedSize)
-
-		boost::shared_ptr<AvatarData> tmpAvatar = session.playerData->GetNetAvatarData();
-		if (tmpAvatar.get() && tmpAvatar->fileData.size() + data.fileData.size() <= tmpAvatar->reportedSize)
 		{
-			std::copy(data.fileData.begin(), data.fileData.end(), back_inserter(tmpAvatar->fileData));
+			std::copy(&avatarData.avatarBlock.buf[0], &avatarData.avatarBlock.buf[avatarData.avatarBlock.size], back_inserter(tmpAvatar->fileData));
 		}
 	}
 }
 
 void
-ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, const NetPacketAvatarEnd &/*tmpPacket*/)
+ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, unsigned /*requestId*/, const AvatarEnd_t &/*avatarEnd*/)
 {
 	if (session.playerData.get())
 	{
-		boost::shared_ptr<AvatarData> tmpAvatar = session.playerData->GetNetAvatarData();
+		boost::shared_ptr<AvatarFile> tmpAvatar = session.playerData->GetNetAvatarFile();
 		MD5Buf avatarMD5 = session.playerData->GetAvatarMD5();
 		if (!avatarMD5.IsZero() && tmpAvatar.get())
 		{
@@ -834,7 +903,7 @@ ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, const NetPac
 				}
 
 				// Free memory.
-				session.playerData->SetNetAvatarData(boost::shared_ptr<AvatarData>());
+				session.playerData->SetNetAvatarFile(boost::shared_ptr<AvatarFile>());
 				// Set avatar file name.
 				string avatarFileName;
 				if (GetAvatarManager().GetAvatarFileName(avatarMD5, avatarFileName))
@@ -851,63 +920,66 @@ ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, const NetPac
 }
 
 void
-ServerLobbyThread::HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket)
+ServerLobbyThread::HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest)
 {
-	NetPacketRetrievePlayerInfo::Data request;
-	tmpPacket.GetData(request);
-
 	// Find player in lobby or in a game.
-	boost::shared_ptr<PlayerData> tmpPlayer = m_sessionManager.GetSessionByUniquePlayerId(request.playerId).playerData;
+	boost::shared_ptr<PlayerData> tmpPlayer = m_sessionManager.GetSessionByUniquePlayerId(playerInfoRequest.playerId).playerData;
 	if (!tmpPlayer.get())
-		tmpPlayer = m_gameSessionManager.GetSessionByUniquePlayerId(request.playerId).playerData;
+		tmpPlayer = m_gameSessionManager.GetSessionByUniquePlayerId(playerInfoRequest.playerId).playerData;
 	if (!tmpPlayer.get())
 	{
 		boost::mutex::scoped_lock lock(m_computerPlayersMutex);
-		PlayerDataMap::const_iterator pos = m_computerPlayers.find(request.playerId);
+		PlayerDataMap::const_iterator pos = m_computerPlayers.find(playerInfoRequest.playerId);
 		if (pos != m_computerPlayers.end())
 			tmpPlayer = pos->second;
 	}
 
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
+	packet->GetMsg()->present = PokerTHMessage_PR_playerInfoReplyMessage;
+	PlayerInfoReplyMessage_t *netPlayerInfoReply = &packet->GetMsg()->choice.playerInfoReplyMessage;
+	netPlayerInfoReply->playerId = tmpPlayer->GetUniqueId();
+
 	if (tmpPlayer.get())
 	{
 		// Send player info to client.
-		boost::shared_ptr<NetPacket> info(new NetPacketPlayerInfo);
+		netPlayerInfoReply->playerInfoResult.present = playerInfoResult_PR_playerInfoData;
-		NetPacketPlayerInfo::Data infoData;
+		PlayerInfoData *data = &netPlayerInfoReply->playerInfoResult.choice.playerInfoData;
-		infoData.playerId = tmpPlayer->GetUniqueId();
+
-		infoData.playerInfo.ptype = tmpPlayer->GetType();
+		data->isHuman = tmpPlayer->GetType() == PLAYER_TYPE_HUMAN;
-		infoData.playerInfo.playerName = tmpPlayer->GetName();
+		OCTET_STRING_fromBuf(
-		infoData.playerInfo.hasAvatar = !tmpPlayer->GetAvatarMD5().IsZero();
+			&data->playerName,
-		if (infoData.playerInfo.hasAvatar)
+			tmpPlayer->GetName().c_str(),
+			tmpPlayer->GetName().length());
+		if (!tmpPlayer->GetAvatarMD5().IsZero())
 		{
-			infoData.playerInfo.avatar = tmpPlayer->GetAvatarMD5();
+			data->avatarData = (struct PlayerInfoData::avatarData *)calloc(1, sizeof(struct PlayerInfoData::avatarData));
-			infoData.playerInfo.avatarType = AvatarManager::GetAvatarFileType(tmpPlayer->GetAvatarFile());
+			data->avatarData->avatarType = static_cast<NetAvatarType_t>(AvatarManager::GetAvatarFileType(tmpPlayer->GetAvatarFile()));
+			OCTET_STRING_fromBuf(
+				&data->avatarData->avatar,
+				(char *)tmpPlayer->GetAvatarMD5().data,
+				MD5_DATA_SIZE);
 		}
-		static_cast<NetPacketPlayerInfo *>(info.get())->SetData(infoData);
-		GetSender().Send(session.sessionData, info);
 	}
 	else
 	{
 		// Unknown player id - notify client.
-		boost::shared_ptr<NetPacket> unknown(new NetPacketUnknownPlayerId);
+		netPlayerInfoReply->playerInfoResult.present = playerInfoResult_PR_unknownPlayerInfo;
-		NetPacketUnknownPlayerId::Data unknownData;
-		unknownData.playerId = request.playerId;
-		static_cast<NetPacketUnknownPlayerId *>(unknown.get())->SetData(unknownData);
-		GetSender().Send(session.sessionData, unknown);
 	}
+	GetSender().Send(session.sessionData, packet);
 }
 
 void
-ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket)
+ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar)
 {
 	bool avatarFound = false;
-	NetPacketRetrieveAvatar::Data request;
-	tmpPacket.GetData(request);
 
 	string tmpFile;
-	if (GetAvatarManager().GetAvatarFileName(request.avatar, tmpFile))
+	MD5Buf tmpMD5;
+	memcpy(tmpMD5.data, retrieveAvatar.avatar.buf, MD5_DATA_SIZE);
+	if (GetAvatarManager().GetAvatarFileName(tmpMD5, tmpFile))
 	{
 		NetPacketList tmpPackets;
-		if (GetAvatarManager().AvatarFileToNetPackets(tmpFile, request.requestId, tmpPackets) == 0)
+		if (GetAvatarManager().AvatarFileToNetPackets(tmpFile, retrieveAvatar.requestId, tmpPackets) == 0)
 		{
 			avatarFound = true;
 			GetSender().Send(session.sessionData, tmpPackets);
@@ -919,30 +991,31 @@ ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const N
 	if (!avatarFound)
 	{
 		// Notify client we didn't find the avatar.
-		boost::shared_ptr<NetPacket> unknown(new NetPacketUnknownAvatar);
+		boost::shared_ptr<NetPacket> unknownAvatar(new NetPacket(NetPacket::Alloc));
-		NetPacketUnknownAvatar::Data unknownData;
+		unknownAvatar->GetMsg()->present = PokerTHMessage_PR_avatarReplyMessage;
-		unknownData.requestId = request.requestId;
+		AvatarReplyMessage_t *netAvatarReply = &unknownAvatar->GetMsg()->choice.avatarReplyMessage;
-		static_cast<NetPacketUnknownAvatar *>(unknown.get())->SetData(unknownData);
+		netAvatarReply->requestId = retrieveAvatar.requestId;
-		GetSender().Send(session.sessionData, unknown);
+		netAvatarReply->avatarResult.present = avatarResult_PR_unknownAvatar;
+
+		GetSender().Send(session.sessionData, unknownAvatar);
 	}
 }
 
 void
-ServerLobbyThread::HandleNetPacketCreateGame(SessionWrapper session, const NetPacketCreateGame &tmpPacket)
+ServerLobbyThread::HandleNetPacketCreateGame(SessionWrapper session, const std::string &password, const JoinNewGame_t &newGame)
 {
 	LOG_VERBOSE("Creating new game, initiated by session #" << session.sessionData->GetId() << ".");
 
 	// Create a new game.
-	NetPacketCreateGame::Data createGameData;
+	GameData tmpData;
-	tmpPacket.GetData(createGameData);
+	NetPacket::GetGameData(&newGame.gameInfo, tmpData);
-
 	boost::shared_ptr<ServerGame> game(
 		new ServerGame(
 			shared_from_this(),
 			GetNextGameId(),
-			createGameData.gameName,
+			string((char *)newGame.gameInfo.gameName.buf, newGame.gameInfo.gameName.size),
-			createGameData.password,
+			password,
-			createGameData.gameData,
+			tmpData,
 			session.playerData->GetUniqueId(),
 			GetGui(),
 			m_playerConfig));
@@ -954,18 +1027,15 @@ ServerLobbyThread::HandleNetPacketCreateGame(SessionWrapper session, const NetPa
 }
 
 void
-ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const NetPacketJoinGame &tmpPacket)
+ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const std::string &password, const JoinExistingGame_t &joinGame)
 {
 	// Join an existing game.
-	NetPacketJoinGame::Data joinGameData;
+	GameMap::iterator pos = m_gameMap.find(joinGame.gameId);
-	tmpPacket.GetData(joinGameData);
-
-	GameMap::iterator pos = m_gameMap.find(joinGameData.gameId);
 
 	if (pos != m_gameMap.end())
 	{
 		ServerGame &game = *pos->second;
-		if (game.CheckPassword(joinGameData.password))
+		if (game.CheckPassword(password))
 		{
 			MoveSessionToGame(game, session);
 		}
@@ -976,6 +1046,7 @@ ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const NetPack
 	}
 	else
 	{
+		// TODO do not remove session
 		SessionError(session, ERR_NET_UNKNOWN_GAME);
 	}
 }
@@ -986,14 +1057,15 @@ ServerLobbyThread::EstablishSession(SessionWrapper session)
 	if (!session.playerData.get())
 		throw ServerException(__FILE__, __LINE__, ERR_NET_INVALID_SESSION, 0);
 	// Send ACK to client.
-	boost::shared_ptr<NetPacket> initAck(new NetPacketInitAck);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketInitAck::Data initAckData;
+	packet->GetMsg()->present = PokerTHMessage_PR_initAckMessage;
-	initAckData.latestGameVersion = POKERTH_VERSION;
+	InitAckMessage_t *netInitAck = &packet->GetMsg()->choice.initAckMessage;
-	initAckData.latestBetaRevision = POKERTH_BETA_REVISION;
+	netInitAck->latestGameVersion.major = POKERTH_VERSION_MAJOR;
-	initAckData.sessionId = session.sessionData->GetId(); // TODO: currently unused.
+	netInitAck->latestGameVersion.minor = POKERTH_VERSION_MINOR;
-	initAckData.playerId = session.playerData->GetUniqueId();
+	netInitAck->latestBetaRevision = POKERTH_BETA_REVISION;
-	static_cast<NetPacketInitAck *>(initAck.get())->SetData(initAckData);
+//	initAckData.sessionId = session.sessionData->GetId(); // TODO: currently unused.
-	GetSender().Send(session.sessionData, initAck);
+	netInitAck->yourPlayerId = session.playerData->GetUniqueId();
+	GetSender().Send(session.sessionData, packet);
 
 	// Send the game list to the client.
 	SendGameList(session.sessionData);
@@ -1020,12 +1092,15 @@ ServerLobbyThread::RequestPlayerAvatar(SessionWrapper session)
 		m_timerAvatarClientAddressMap[session.sessionData->GetClientAddr()] = boost::timers::portable::microsec_timer();
 	}
 	// Ask the client to send its avatar.
-	boost::shared_ptr<NetPacket> retrieveAvatar(new NetPacketRetrieveAvatar);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketRetrieveAvatar::Data retrieveAvatarData;
+	packet->GetMsg()->present = PokerTHMessage_PR_avatarRequestMessage;
-	retrieveAvatarData.requestId = session.playerData->GetUniqueId();
+	AvatarRequestMessage_t *netAvatarRequest = &packet->GetMsg()->choice.avatarRequestMessage;
-	retrieveAvatarData.avatar = session.playerData->GetAvatarMD5();
+	netAvatarRequest->requestId = session.playerData->GetUniqueId();
-	static_cast<NetPacketRetrieveAvatar *>(retrieveAvatar.get())->SetData(retrieveAvatarData);
+	OCTET_STRING_fromBuf(
-	GetSender().Send(session.sessionData, retrieveAvatar);
+		&netAvatarRequest->avatar,
+		(char *)session.playerData->GetAvatarMD5().data,
+		MD5_DATA_SIZE);
+	GetSender().Send(session.sessionData, packet);
 }
 
 void
@@ -1236,17 +1311,16 @@ ServerLobbyThread::InternalResubscribeMsg(SessionWrapper session)
 		session.sessionData->SetWantsLobbyMsg();
 		SendGameList(session.sessionData);
 		// Send new statistics information.
-		boost::shared_ptr<NetPacket> packet(new NetPacketStatisticsChanged);
+		boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-		NetPacketStatisticsChanged::Data statData;
+		packet->GetMsg()->present = PokerTHMessage_PR_statisticsMessage;
-		statData.stats.numberOfPlayersOnServer = m_sessionManager.GetRawSessionCount() + m_gameSessionManager.GetRawSessionCount();
+		StatisticsMessage_t *netStatistics = &packet->GetMsg()->choice.statisticsMessage;
-		try {
+
-			static_cast<NetPacketStatisticsChanged *>(packet.get())->SetData(statData);
+		StatisticsData_t *data = (StatisticsData_t *)calloc(1, sizeof(struct StatisticsData));
+		data->statisticsType = statisticsType_statNumberOfPlayers;
+		data->statisticsValue = m_sessionManager.GetRawSessionCount() + m_gameSessionManager.GetRawSessionCount();
+		ASN_SEQUENCE_ADD(&netStatistics->statisticsData.list, data);
 
 		GetSender().Send(session.sessionData, packet);
-		} catch (const NetException &)
-		{
-			// Ignore errors for now.
-		}
 	}
 }
 
@@ -1286,11 +1360,12 @@ ServerLobbyThread::InternalCheckSessionTimeouts(SessionWrapper session)
 				&& !session.sessionData->HasActivityNoticeBeenSent())
 		{
 			session.sessionData->MarkActivityNotice();
-			boost::shared_ptr<NetPacket> packet(new NetPacketTimeoutWarning);
+
-			NetPacketTimeoutWarning::Data warningData;
+			boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-			warningData.timeoutReason = NETWORK_TIMEOUT_GENERIC;
+			packet->GetMsg()->present = PokerTHMessage_PR_timeoutWarningMessage;
-			warningData.remainingSeconds = SERVER_TIMEOUT_WARNING_REMAINING_SEC;
+			TimeoutWarningMessage_t *netWarning = &packet->GetMsg()->choice.timeoutWarningMessage;
-			static_cast<NetPacketTimeoutWarning *>(packet.get())->SetData(warningData);
+			netWarning->timeoutReason = timeoutReason_timeoutNoDataReceived;
+			netWarning->remainingSeconds = SERVER_TIMEOUT_WARNING_REMAINING_SEC;
 			GetSender().Send(session.sessionData, packet);
 		}
 		else if (session.sessionData->GetActivityTimerElapsedSec() >= SERVER_SESSION_ACTIVITY_TIMEOUT_SEC)
@@ -1324,20 +1399,39 @@ void
 ServerLobbyThread::SendError(boost::shared_ptr<SessionData> s, int errorCode)
 {
 	LOG_VERBOSE("Sending error code " << errorCode << " to session #" << s->GetId() << ".");
-	boost::shared_ptr<NetPacket> packet(new NetPacketError);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketError::Data errorData;
+	packet->GetMsg()->present = PokerTHMessage_PR_errorMessage;
-	errorData.errorCode = errorCode;
+	ErrorMessage_t *netError = &packet->GetMsg()->choice.errorMessage;
-	static_cast<NetPacketError *>(packet.get())->SetData(errorData);
+	netError->errorReason = NetPacket::GameErrorToNetError(errorCode);
 	GetSender().Send(s, packet);
 }
 
 void
 ServerLobbyThread::SendJoinGameFailed(boost::shared_ptr<SessionData> s, int reason)
 {
-	boost::shared_ptr<NetPacket> packet(new NetPacketJoinGameFailed);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketJoinGameFailed::Data failedData;
+	packet->GetMsg()->present = PokerTHMessage_PR_joinGameReplyMessage;
-	failedData.failureCode = reason;
+	JoinGameReplyMessage_t *netJoinReply = &packet->GetMsg()->choice.joinGameReplyMessage;
-	static_cast<NetPacketJoinGameFailed *>(packet.get())->SetData(failedData);
+	netJoinReply->gameId = s->GetGameId();
+
+	netJoinReply->joinGameResult.present = joinGameResult_PR_joinGameFailed;
+	JoinGameFailed_t *joinFailed = &netJoinReply->joinGameResult.choice.joinGameFailed;
+
+	switch (reason)
+	{
+		case NTF_NET_JOIN_GAME_FULL :
+			joinFailed->joinGameFailureReason = joinGameFailureReason_gameIsFull;
+			break;
+		case NTF_NET_JOIN_ALREADY_RUNNING :
+			joinFailed->joinGameFailureReason = joinGameFailureReason_gameIsRunning;
+			break;
+		case NTF_NET_JOIN_INVALID_PASSWORD :
+			joinFailed->joinGameFailureReason = joinGameFailureReason_invalidPassword;
+			break;
+		default :
+			joinFailed->joinGameFailureReason = joinGameFailureReason_invalidGame;
+			break;
+	}
 	GetSender().Send(s, packet);
 }
 
@@ -1377,19 +1471,17 @@ ServerLobbyThread::BroadcastStatisticsUpdate(const ServerStats &stats)
 {
 	if (stats.numberOfPlayersOnServer)
 	{
-		boost::shared_ptr<NetPacket> packet(new NetPacketStatisticsChanged);
+		boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-		NetPacketStatisticsChanged::Data statData;
+		packet->GetMsg()->present = PokerTHMessage_PR_statisticsMessage;
-		statData.stats = stats;
+		StatisticsMessage_t *netStatistics = &packet->GetMsg()->choice.statisticsMessage;
-		try {
+
-			static_cast<NetPacketStatisticsChanged *>(packet.get())->SetData(statData);
+		StatisticsData_t *data = (StatisticsData_t *)calloc(1, sizeof(struct StatisticsData));
+		data->statisticsType = statisticsType_statNumberOfPlayers;
+		data->statisticsValue = m_sessionManager.GetRawSessionCount() + m_gameSessionManager.GetRawSessionCount();
+		ASN_SEQUENCE_ADD(&netStatistics->statisticsData.list, data);
 
 		m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
 		m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
-		} catch (const NetException &)
-		{
-			// Ignore errors for now.
-			//LOG_ERROR("ServerLobbyThread::BroadcastStatisticsUpdate: " << e.what());
-		}
 	}
 }
 
@@ -1499,27 +1591,48 @@ ServerLobbyThread::IsPlayerConnected(const string &name) const
 boost::shared_ptr<NetPacket>
 ServerLobbyThread::CreateNetPacketGameListNew(const ServerGame &game)
 {
-	boost::shared_ptr<NetPacket> packet(new NetPacketGameListNew);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketGameListNew::Data packetData;
+	packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
-	packetData.gameId = game.GetId();
+	GameListMessage_t *netGameList = &packet->GetMsg()->choice.gameListMessage;
-	packetData.gameInfo.adminPlayerId = game.GetAdminPlayerId();
+	netGameList->gameId = game.GetId();
-	packetData.gameInfo.mode = game.IsRunning() ? GAME_MODE_STARTED : GAME_MODE_CREATED;
+
-	packetData.gameInfo.name = game.GetName();
+	netGameList->gameListNotification.present = gameListNotification_PR_gameListNew;
-	packetData.gameInfo.data = game.GetGameData();
+	GameListNew_t *gameNew = &netGameList->gameListNotification.choice.gameListNew;
-	packetData.gameInfo.players = game.GetPlayerIdList();
+	gameNew->adminPlayerId = game.GetAdminPlayerId();
-	packetData.gameInfo.isPasswordProtected = game.IsPasswordProtected();
+	gameNew->gameMode = game.IsRunning() ? NetGameMode_gameStarted : NetGameMode_gameCreated;
-	static_cast<NetPacketGameListNew *>(packet.get())->SetData(packetData);
+	NetPacket::SetGameData(game.GetGameData(), &gameNew->gameInfo);
+	OCTET_STRING_fromBuf(
+		&gameNew->gameInfo.gameName,
+		game.GetName().c_str(),
+		game.GetName().length());
+	gameNew->isPrivate = game.IsPasswordProtected();
+
+	PlayerIdList tmpList = game.GetPlayerIdList();
+	PlayerIdList::const_iterator i = tmpList.begin();
+	PlayerIdList::const_iterator end = tmpList.end();
+	while (i != end)
+	{
+		NonZeroId_t *playerId = (NonZeroId_t *)calloc(1, sizeof(NonZeroId_t));
+		*playerId = *i;
+		ASN_SEQUENCE_ADD(&gameNew->playerIds.list, playerId);
+		++i;
+	}
+
 	return packet;
 }
 
 boost::shared_ptr<NetPacket>
 ServerLobbyThread::CreateNetPacketGameListUpdate(unsigned gameId, GameMode mode)
 {
-	boost::shared_ptr<NetPacket> packet(new NetPacketGameListUpdate);
+	boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
-	NetPacketGameListUpdate::Data packetData;
+	packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
-	packetData.gameId = gameId;
+	GameListMessage_t *netGameList = &packet->GetMsg()->choice.gameListMessage;
-	packetData.gameMode = mode;
+	netGameList->gameId = gameId;
-	static_cast<NetPacketGameListUpdate *>(packet.get())->SetData(packetData);
+
+	netGameList->gameListNotification.present = gameListNotification_PR_gameListUpdate;
+	GameListUpdate_t *gameUpdate = &netGameList->gameListNotification.choice.gameListUpdate;
+
+	gameUpdate->gameMode = mode;
 	return packet;
 }
 

src/net/common/sessionmanager.cpp

@@ -307,7 +307,7 @@ SessionManager::SendToAllSessions(SenderHelper &sender, boost::shared_ptr<NetPac
 
 		// Send each client (with a certain state) a copy of the packet.
 		if (i->second.sessionData->GetState() == state)
-			sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone()));
+			sender.Send(i->second.sessionData, packet);
 		++i;
 	}
 }
@@ -327,7 +327,7 @@ SessionManager::SendLobbyMsgToAllSessions(SenderHelper &sender, boost::shared_pt
 
 		// Send each client (with a certain state) a copy of the packet.
 		if (i->second.sessionData->GetState() == state && i->second.sessionData->WantsLobbyMsg())
-			sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone()));
+			sender.Send(i->second.sessionData, packet);
 		++i;
 	}
 }
@@ -345,7 +345,7 @@ SessionManager::SendToAllButOneSessions(SenderHelper &sender, boost::shared_ptr<
 		// Send each fully connected client but one a copy of the packet.
 		if (i->second.sessionData->GetState() == state)
 			if (i->first != except)
-				sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone()));
+				sender.Send(i->second.sessionData, packet);
 		++i;
 	}
 }

src/net/senderhelper.h

@@ -39,6 +39,8 @@ public:
 	void SignalSessionTerminated(unsigned sessionId);
 
 protected:
+	void InternalStorePacket(SendDataManager &tmpManager, boost::shared_ptr<NetPacket> packet);
+
 	typedef std::map<SessionId, boost::shared_ptr<SendDataManager> > SendQueueMap;
 
 private:

src/net/servergamestate.h

@@ -92,7 +92,7 @@ protected:
 
 	virtual void InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
 
-	static boost::shared_ptr<NetPacket> CreateNetPacketPlayerJoined(const PlayerData &playerData);
+	static boost::shared_ptr<NetPacket> CreateNetPacketPlayerJoined(unsigned gameId, const PlayerData &playerData);
 
 private:
 	static ServerGameStateInit s_state;

src/net/serverlobbythread.h

@@ -67,8 +67,8 @@ public:
 	void NotifyStartingGame(unsigned gameId);
 	void NotifyReopeningGame(unsigned gameId);
 
-	void HandleGameRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket);
+	void HandleGameRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest);
-	void HandleGameRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket);
+	void HandleGameRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar);
 
 	bool KickPlayerByName(const std::string &playerName);
 	std::string GetPlayerIPAddress(const std::string &playerName) const;
@@ -111,15 +111,15 @@ protected:
 
 	void HandleRead(const boost::system::error_code &ec, SessionId sessionId, size_t bytesRead);
 	void HandlePacket(SessionWrapper session, boost::shared_ptr<NetPacket> packet);
-	void HandleNetPacketInit(SessionWrapper session, const NetPacketInit &tmpPacket);
+	void HandleNetPacketInit(SessionWrapper session, const InitMessage_t &initMessage);
-	void HandleNetPacketAvatarHeader(SessionWrapper session, const NetPacketAvatarHeader &tmpPacket);
+	void HandleNetPacketAvatarHeader(SessionWrapper session, unsigned requestId, const AvatarHeader_t &avatarHeader);
-	void HandleNetPacketUnknownAvatar(SessionWrapper session, const NetPacketUnknownAvatar &tmpPacket);
+	void HandleNetPacketUnknownAvatar(SessionWrapper session, unsigned requestId, const UnknownAvatar_t &unknownAvatar);
-	void HandleNetPacketAvatarFile(SessionWrapper session, const NetPacketAvatarFile &tmpPacket);
+	void HandleNetPacketAvatarFile(SessionWrapper session, unsigned requestId, const AvatarData_t &avatarData);
-	void HandleNetPacketAvatarEnd(SessionWrapper session, const NetPacketAvatarEnd &tmpPacket);
+	void HandleNetPacketAvatarEnd(SessionWrapper session, unsigned requestId, const AvatarEnd_t &avatarEnd);
-	void HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket);
+	void HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest);
-	void HandleNetPacketRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket);
+	void HandleNetPacketRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar);
-	void HandleNetPacketCreateGame(SessionWrapper session, const NetPacketCreateGame &tmpPacket);
+	void HandleNetPacketCreateGame(SessionWrapper session, const std::string &password, const JoinNewGame_t &newGame);
-	void HandleNetPacketJoinGame(SessionWrapper session, const NetPacketJoinGame &tmpPacket);
+	void HandleNetPacketJoinGame(SessionWrapper session, const std::string &password, const JoinExistingGame_t &joinGame);
 	void EstablishSession(SessionWrapper session);
 	void RequestPlayerAvatar(SessionWrapper session);
 	void TimerRemoveGame(const boost::system::error_code &ec);

src/net/socket_msg.h

@@ -104,9 +104,10 @@
 #define NTF_NET_REMOVED_START_FAILED	207
 
 // Notifications - join failed
-#define NTF_NET_JOIN_GAME_FULL			210
+#define NTF_NET_JOIN_GAME_INVALID		210
-#define NTF_NET_JOIN_ALREADY_RUNNING	211
+#define NTF_NET_JOIN_GAME_FULL			211
-#define NTF_NET_JOIN_INVALID_PASSWORD	212
+#define NTF_NET_JOIN_ALREADY_RUNNING	212
+#define NTF_NET_JOIN_INVALID_PASSWORD	213
 
 // Notifications - version
 #define NTF_NET_NEW_RELEASE_AVAILABLE	220

src/playerdata.cpp

@@ -92,16 +92,16 @@ PlayerData::SetNetSessionData(boost::shared_ptr<SessionData> session)
 	m_netSessionData = session;
 }
 
-boost::shared_ptr<AvatarData>
+boost::shared_ptr<AvatarFile>
-PlayerData::GetNetAvatarData() const
+PlayerData::GetNetAvatarFile() const
 {
-	return m_netAvatarData;
+	return m_netAvatarFile;
 }
 
 void
-PlayerData::SetNetAvatarData(boost::shared_ptr<AvatarData> avatarData)
+PlayerData::SetNetAvatarFile(boost::shared_ptr<AvatarFile> AvatarFile)
 {
-	m_netAvatarData = avatarData;
+	m_netAvatarFile = AvatarFile;
 }
 
 PlayerType

src/playerdata.h

@@ -51,9 +51,9 @@ enum AvatarFileType
 	AVATAR_FILE_TYPE_GIF
 };
 
-struct AvatarData
+struct AvatarFile
 {
-	AvatarData() : fileType(AVATAR_FILE_TYPE_UNKNOWN), reportedSize(0) {}
+	AvatarFile() : fileType(AVATAR_FILE_TYPE_UNKNOWN), reportedSize(0) {}
 	std::vector<unsigned char>	fileData;
 	AvatarFileType				fileType;
 	unsigned					reportedSize;
@@ -84,8 +84,8 @@ public:
 	void SetAvatarMD5(const MD5Buf &avatarMD5);
 	boost::shared_ptr<SessionData> GetNetSessionData() const;
 	void SetNetSessionData(boost::shared_ptr<SessionData> session);
-	boost::shared_ptr<AvatarData> GetNetAvatarData() const;
+	boost::shared_ptr<AvatarFile> GetNetAvatarFile() const;
-	void SetNetAvatarData(boost::shared_ptr<AvatarData> avatarData);
+	void SetNetAvatarFile(boost::shared_ptr<AvatarFile> AvatarFile);
 	PlayerType GetType() const;
 	void SetType(PlayerType type);
 	PlayerRights GetRights() const;
@@ -105,7 +105,7 @@ private:
 	PlayerType						m_type;
 	PlayerRights					m_rights;
 	boost::shared_ptr<SessionData>	m_netSessionData;
-	boost::shared_ptr<AvatarData>	m_netAvatarData;
+	boost::shared_ptr<AvatarFile>	m_netAvatarFile;
 
 	mutable boost::mutex			m_dataMutex;
 };

src/pokerth.cpp

@@ -18,12 +18,20 @@
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 
+#include <boost/asio.hpp>
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
 #include <qapplication.h>
+#include <QtGui>
+#include <QtCore>
 
 #ifdef __APPLE__
 	#include <QMacStyle>
 #endif
 
+#include <curl/curl.h>
+
 #include "session.h"
 #include "startwindowimpl.h"
 #include "configfile.h"
@@ -31,14 +39,6 @@
 #include "game_defs.h"
 #include <net/socket_startup.h>
 
-#include <curl/curl.h>
-#include <QtGui>
-#include <QtCore>
-
-#include <iostream>
-#include <cstdlib>
-#include <ctime>
-
 #ifdef _MSC_VER
 	#ifdef _DEBUG
 		#define _CRTDBG_MAP_ALLOC

src/session.cpp

@@ -17,6 +17,7 @@
  *   Free Software Foundation, Inc.,                                       *
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
+#include <boost/asio.hpp>
 #include <net/socket_helper.h>
 #include "session.h"
 #include "game.h"