276 lines
9.0 KiB
C++
276 lines
9.0 KiB
C++
/*****************************************************************************
|
|
* PokerTH - The open source texas holdem engine *
|
|
* Copyright (C) 2006-2011 Felix Hammer, Florian Thauer, Lothar May *
|
|
* *
|
|
* This program is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU Affero General Public License as *
|
|
* published by the Free Software Foundation, either version 3 of the *
|
|
* License, or (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Affero General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Affero General Public License *
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
|
|
*****************************************************************************/
|
|
|
|
#include <net/netpacket.h>
|
|
#include <net/socket_msg.h>
|
|
|
|
using namespace std;
|
|
|
|
NetPacket::NetPacket(MemAllocType alloc)
|
|
: m_msg(NULL)
|
|
{
|
|
if (alloc != NoAlloc)
|
|
m_msg = (PokerTHMessage_t *)calloc(1, sizeof(PokerTHMessage_t));
|
|
}
|
|
|
|
NetPacket::~NetPacket()
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_PokerTHMessage, m_msg);
|
|
}
|
|
|
|
boost::shared_ptr<NetPacket>
|
|
NetPacket::Create(char *data, size_t &dataSize)
|
|
{
|
|
boost::shared_ptr<NetPacket> tmpPacket;
|
|
|
|
// Check minimum requirements.
|
|
if (data && dataSize > 0) {
|
|
PokerTHMessage_t *msg = NULL;
|
|
asn_dec_rval_t retVal = ber_decode(0, &asn_DEF_PokerTHMessage, (void **)&msg, data, dataSize);
|
|
if(retVal.code == RC_OK) {
|
|
// ASN.1 BER decoding was successful.
|
|
tmpPacket.reset(new NetPacket(NoAlloc));
|
|
tmpPacket->m_msg = msg;
|
|
// Consume the bytes.
|
|
if (retVal.consumed < dataSize) {
|
|
dataSize -= retVal.consumed;
|
|
memmove(data, data + retVal.consumed, dataSize);
|
|
} else
|
|
dataSize = 0;
|
|
} else {
|
|
// Free the partially decoded message (if applicable).
|
|
ASN_STRUCT_FREE(asn_DEF_PokerTHMessage, msg);
|
|
}
|
|
}
|
|
return tmpPacket;
|
|
}
|
|
|
|
bool
|
|
NetPacket::IsClientActivity() const
|
|
{
|
|
bool retVal = false;
|
|
if (m_msg &&
|
|
(m_msg->present == PokerTHMessage_PR_initMessage
|
|
|| m_msg->present == PokerTHMessage_PR_joinGameRequestMessage
|
|
|| m_msg->present == PokerTHMessage_PR_kickPlayerRequestMessage
|
|
|| m_msg->present == PokerTHMessage_PR_leaveGameRequestMessage
|
|
|| m_msg->present == PokerTHMessage_PR_startEventMessage
|
|
|| m_msg->present == PokerTHMessage_PR_myActionRequestMessage
|
|
|| m_msg->present == PokerTHMessage_PR_resetTimeoutMessage
|
|
|| m_msg->present == PokerTHMessage_PR_chatRequestMessage)) {
|
|
retVal = true;
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
static int
|
|
net_packet_print_to_string(const void *buffer, size_t size, void *packetStr)
|
|
{
|
|
string *tmpString = (string *)packetStr;
|
|
*tmpString += string((const char *)buffer, size);
|
|
return 0;
|
|
}
|
|
|
|
string
|
|
NetPacket::ToString() const
|
|
{
|
|
string packetString;
|
|
xer_encode(&asn_DEF_PokerTHMessage, m_msg, XER_F_BASIC, &net_packet_print_to_string, &packetString);
|
|
return packetString;
|
|
}
|
|
|
|
void
|
|
NetPacket::SetGameData(const GameData &inData, NetGameInfo_t *outData)
|
|
{
|
|
assert(outData);
|
|
|
|
int numManualBlinds = (int)inData.manualBlindsList.size();
|
|
|
|
outData->netGameType = inData.gameType;
|
|
outData->maxNumPlayers = inData.maxNumberOfPlayers;
|
|
outData->raiseIntervalMode.present = static_cast<raiseIntervalMode_PR>(inData.raiseIntervalMode);
|
|
if (inData.raiseIntervalMode == RAISE_ON_HANDNUMBER) {
|
|
outData->raiseIntervalMode.present = raiseIntervalMode_PR_raiseEveryHands;
|
|
outData->raiseIntervalMode.choice.raiseEveryHands = inData.raiseSmallBlindEveryHandsValue;
|
|
} else {
|
|
outData->raiseIntervalMode.present = raiseIntervalMode_PR_raiseEveryMinutes;
|
|
outData->raiseIntervalMode.choice.raiseEveryMinutes = inData.raiseSmallBlindEveryMinutesValue;
|
|
}
|
|
outData->endRaiseMode = inData.afterManualBlindsMode;
|
|
outData->proposedGuiSpeed = inData.guiSpeed;
|
|
outData->delayBetweenHands = inData.delayBetweenHandsSec;
|
|
outData->playerActionTimeout = inData.playerActionTimeoutSec;
|
|
outData->endRaiseSmallBlindValue = inData.afterMBAlwaysRaiseValue;
|
|
outData->firstSmallBlind = inData.firstSmallBlind;
|
|
outData->startMoney = inData.startMoney;
|
|
|
|
if (numManualBlinds) {
|
|
list<int>::const_iterator i = inData.manualBlindsList.begin();
|
|
list<int>::const_iterator end = inData.manualBlindsList.end();
|
|
while (i != end) {
|
|
long *manualBlind = (long *)calloc(1, sizeof(long));
|
|
*manualBlind = *i;
|
|
ASN_SEQUENCE_ADD(&outData->manualBlinds.list, manualBlind);
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
NetPacket::GetGameData(const NetGameInfo_t *inData, GameData &outData)
|
|
{
|
|
assert(inData);
|
|
|
|
int numManualBlinds = (int)inData->manualBlinds.list.count;
|
|
|
|
outData.gameType = static_cast<GameType>(inData->netGameType);
|
|
outData.maxNumberOfPlayers = inData->maxNumPlayers;
|
|
outData.raiseIntervalMode = static_cast<RaiseIntervalMode>(inData->raiseIntervalMode.present);
|
|
outData.raiseSmallBlindEveryHandsValue = outData.raiseSmallBlindEveryMinutesValue = 0;
|
|
if (inData->raiseIntervalMode.present == raiseIntervalMode_PR_raiseEveryHands)
|
|
outData.raiseSmallBlindEveryHandsValue = inData->raiseIntervalMode.choice.raiseEveryHands;
|
|
else
|
|
outData.raiseSmallBlindEveryMinutesValue = inData->raiseIntervalMode.choice.raiseEveryMinutes;
|
|
outData.raiseMode = numManualBlinds > 0 ? MANUAL_BLINDS_ORDER : DOUBLE_BLINDS;
|
|
outData.afterManualBlindsMode = static_cast<AfterManualBlindsMode>(inData->endRaiseMode);
|
|
outData.guiSpeed = inData->proposedGuiSpeed;
|
|
outData.delayBetweenHandsSec = inData->delayBetweenHands;
|
|
outData.playerActionTimeoutSec = inData->playerActionTimeout;
|
|
outData.firstSmallBlind = inData->firstSmallBlind;
|
|
outData.afterMBAlwaysRaiseValue = inData->endRaiseSmallBlindValue;
|
|
outData.startMoney = inData->startMoney;
|
|
|
|
if (numManualBlinds) {
|
|
long **manualBlindsPtr = inData->manualBlinds.list.array;
|
|
int counter = 0;
|
|
for (int i = 0; i < numManualBlinds; i++) {
|
|
outData.manualBlindsList.push_back((int)*manualBlindsPtr[i]);
|
|
counter++;
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
NetPacket::NetErrorToGameError(long netErrorReason)
|
|
{
|
|
int retVal;
|
|
switch(netErrorReason) {
|
|
case errorReason_errorInitVersionNotSupported :
|
|
retVal = ERR_NET_VERSION_NOT_SUPPORTED;
|
|
break;
|
|
case errorReason_errorInitServerFull :
|
|
retVal = ERR_NET_SERVER_FULL;
|
|
break;
|
|
case errorReason_errorInitAuthFailure :
|
|
retVal = ERR_NET_INVALID_PASSWORD;
|
|
break;
|
|
case errorReason_errorInitPlayerNameInUse :
|
|
retVal = ERR_NET_PLAYER_NAME_IN_USE;
|
|
break;
|
|
case errorReason_errorInitInvalidPlayerName :
|
|
retVal = ERR_NET_INVALID_PLAYER_NAME;
|
|
break;
|
|
case errorReason_errorInitServerMaintenance :
|
|
retVal = ERR_NET_SERVER_MAINTENANCE;
|
|
break;
|
|
case errorReason_errorInitBlocked :
|
|
retVal = ERR_NET_INIT_BLOCKED;
|
|
break;
|
|
case errorReason_errorAvatarTooLarge :
|
|
retVal = ERR_NET_AVATAR_TOO_LARGE;
|
|
break;
|
|
case errorReason_errorInvalidPacket :
|
|
retVal = ERR_SOCK_INVALID_PACKET;
|
|
break;
|
|
case errorReason_errorInvalidState :
|
|
retVal = ERR_SOCK_INVALID_STATE;
|
|
break;
|
|
case errorReason_errorKickedFromServer :
|
|
retVal = ERR_NET_PLAYER_KICKED;
|
|
break;
|
|
case errorReason_errorBannedFromServer :
|
|
retVal = ERR_NET_PLAYER_BANNED;
|
|
break;
|
|
case errorReason_errorBlockedByServer :
|
|
retVal = ERR_NET_PLAYER_BLOCKED;
|
|
break;
|
|
case errorReason_errorSessionTimeout :
|
|
retVal = ERR_NET_SESSION_TIMED_OUT;
|
|
break;
|
|
default :
|
|
retVal = ERR_SOCK_INTERNAL;
|
|
break;
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
long
|
|
NetPacket::GameErrorToNetError(int gameErrorReason)
|
|
{
|
|
int retVal;
|
|
switch(gameErrorReason) {
|
|
case ERR_NET_VERSION_NOT_SUPPORTED :
|
|
retVal = errorReason_errorInitVersionNotSupported;
|
|
break;
|
|
case ERR_NET_SERVER_FULL :
|
|
retVal = errorReason_errorInitServerFull;
|
|
break;
|
|
case ERR_NET_INVALID_PASSWORD :
|
|
retVal = errorReason_errorInitAuthFailure;
|
|
break;
|
|
case ERR_NET_PLAYER_NAME_IN_USE :
|
|
retVal = errorReason_errorInitPlayerNameInUse;
|
|
break;
|
|
case ERR_NET_INVALID_PLAYER_NAME :
|
|
retVal = errorReason_errorInitInvalidPlayerName;
|
|
break;
|
|
case ERR_NET_SERVER_MAINTENANCE :
|
|
retVal = errorReason_errorInitServerMaintenance;
|
|
break;
|
|
case ERR_NET_INIT_BLOCKED :
|
|
retVal = errorReason_errorInitBlocked;
|
|
break;
|
|
case ERR_NET_AVATAR_TOO_LARGE :
|
|
retVal = errorReason_errorAvatarTooLarge;
|
|
break;
|
|
case ERR_SOCK_INVALID_PACKET :
|
|
retVal = errorReason_errorInvalidPacket;
|
|
break;
|
|
case ERR_SOCK_INVALID_STATE :
|
|
retVal = errorReason_errorInvalidState;
|
|
break;
|
|
case ERR_NET_PLAYER_KICKED :
|
|
retVal = errorReason_errorKickedFromServer;
|
|
break;
|
|
case ERR_NET_PLAYER_BLOCKED :
|
|
retVal = errorReason_errorBlockedByServer;
|
|
break;
|
|
case ERR_NET_PLAYER_BANNED :
|
|
retVal = errorReason_errorBannedFromServer;
|
|
break;
|
|
case ERR_NET_SESSION_TIMED_OUT :
|
|
retVal = errorReason_errorSessionTimeout;
|
|
break;
|
|
default :
|
|
retVal = errorReason_errorReserved;
|
|
break;
|
|
}
|
|
return retVal;
|
|
}
|
|
|