void SFMulitiCasualGameDispatcher::Dispatch(BasePacket* pPacket)
{
ISession* pSession = pPacket->GetSessionDesc().pSession;
switch (pPacket->GetPacketType())
{
case SFPACKET_CONNECT:
{
#ifdef _DEBUG
pSession->SetLoginState(SESSION_STATE_AUTENTICATE);
pSession->m_channelNum = 1;
SFPacket* pkt = PacketPoolSingleton::instance()->Alloc();
pkt->SetPacketType(SFPACKET_DATA);
pkt->SetSerial(pPacket->GetSerial());
pkt->SetPacketID(12345);
pkt->SetSessionDesc(pPacket->GetSessionDesc());
DistributePacket(pkt);
#else
pSession->SetLoginState(SESSION_STATE_CONNECT);
#endif
ReleasePacket(pPacket);
}
return;
case SFPACKET_DISCONNECT:
{
if (pSession->GetLoginState() == SESSION_STATE_AUTENTICATE)
{
DistributePacket(pPacket);
}
return;
}
case SFPACKET_DATA:
if (pSession->GetLoginState() == SESSION_STATE_AUTENTICATE)
DistributePacket(pPacket);
else if (pSession->GetLoginState() == SESSION_STATE_CONNECT)
{
if (true == OnAuthenticate(pPacket))
{
pSession->m_channelNum = 1;
pSession->SetLoginState(SESSION_STATE_AUTENTICATE);
}
else
{
pSession->SetLoginState(SESSION_STATE_NULL);
SFEngine::GetInstance()->Disconnect(pPacket->GetSerial());
}
ReleasePacket(pPacket);
}
else
{
pSession->SetLoginState(SESSION_STATE_NULL);
SFEngine::GetInstance()->Disconnect(pPacket->GetSerial());
ReleasePacket(pPacket);
}
}
}
void RPCClientTransportLayer::recv(std::string &outBuf) throw(ServiceException)
{
SFPacket* pPacket = NULL;
DWORD dwCurrentTime = GetTickCount();
DWORD dwLastTime = dwCurrentTime;
while (pPacket == NULL)
{
pPacket = (SFPacket*)SFNetworkEntry::GetInstance()->GetTCPNetwork()->GetRPCResult();
//if (dwLastTime - dwCurrentTime > 5000)
//break;
//dwLastTime = GetTickCount();
Sleep(1);
}
if (pPacket != NULL)
{
int size = pPacket->GetDataSize();
outBuf.append((const char*)pPacket->GetData(), pPacket->GetDataSize());
SFEngine::GetInstance()->ReleasePacket(pPacket);
}
}
void RPCClientTransportLayer::send(char * buf, int size) throw(ServiceException)
{
SFPacket packet;
packet.SetPacketID(60000);
packet.Write((const BYTE*)buf, size);
SFNetworkEntry::GetInstance()->TCPSend(&packet);
}
/* == operator */
bool SFPacket::operator==(SFPacket const& pPacket)
{
bool retval=false;
if((pPacket.getType() == type) && (pPacket.getLength() == length) && (pPacket.getSeqno() == seqno)) {
if((type == SF_PACKET_ACK) || (type == SF_PACKET_NO_ACK)) {
retval = (memcmp(pPacket.getPayload(), getPayload(), length) == 0);
}
}
return retval;
}
bool SFCGSFPacketProtocol::Encode(BasePacket* pPacket, char** ppBuffer, int& bufferSize)
{
SFPacket* pSFPacket = (SFPacket*)pPacket;
if (false == pSFPacket->Encode(m_packetSize, m_packetOption))
return false;
*ppBuffer = (char*)pSFPacket->GetHeader();
bufferSize = pSFPacket->GetPacketSize();
return true;
}
void ProtocolSocket::OnRawData(const char *buf, size_t len)
{
m_pIOBuffer->AppendData(buf, len);
SFPacket packet;
int errorCode = 0;
if (false == GetPacket(&packet, errorCode))
return;
if (packet.GetHeader()->packetID == PACKET_SAMPLE1)
{
static_cast<ProtocolHandler&>(Handler()).OnSample1(this, &packet);
}
}
void PacketSendThread(void* Args)
{
SFEngine* pEngine = (SFEngine*)Args;
INetworkEngine* pNetworkEngine = pEngine->GetNetworkEngine();
while (SFEngine::GetInstance()->ServerTerminated() == FALSE)
{
SFPacket* pPacket = (SFPacket*)PacketSendSingleton::instance()->PopPacket();
if (SFPACKET_SERVERSHUTDOWN == pPacket->GetPacketType())
break;
pNetworkEngine->SendInternal(pPacket->GetOwnerSerial(), (char*)pPacket->GetHeader(), pPacket->GetPacketSize());
PacketPoolSingleton::instance()->Release(pPacket);
}
}
BasePacket* SFCGSFPacketProtocol::GetPacket(int& errorCode)
{
SFPacket* pPacket = SFPacketPool::GetInstance()->Alloc();
pPacket->Initialize();
if (FALSE == m_pPacketIOBuffer->GetPacket(*pPacket->GetHeader(), (char*)pPacket->GetData(), m_packetSize, errorCode))
{
SFPacketPool::GetInstance()->Release(pPacket);
return nullptr;
}
if (FALSE == pPacket->Decode(m_packetSize, errorCode))
{
SFPacketPool::GetInstance()->Release(pPacket);
return nullptr;
}
return pPacket;
}
// copy constructor
SFPacket::SFPacket(const SFPacket &pPacket) {
length = pPacket.getLength();
type = pPacket.getType();
seqno = pPacket.getSeqno();
setPayload(pPacket.getPayload(), length);
}
/* reads packet */
bool SerialComm::readPacket(SFPacket &pPacket)
{
bool sync = false;
bool escape = false;
bool completePacket = false;
int count = 0;
uint16_t crc = 0;
char buffer[maxMTU];
while(!completePacket)
{
buffer[count] = nextRaw();
if(sync && (count == 1) && (buffer[count] == SYNC_BYTE)) {
DEBUG("SerialComm::readPacket double sync byte");
sync = false;
escape = false;
count = 1;
crc = 0;
buffer[0] = SYNC_BYTE;
}
if (!sync)
{
// wait for sync
if (buffer[0] == SYNC_BYTE)
{
sync = true;
escape = false;
count = 1;
crc = 0;
}
}
else if (count >= maxMTU)
{
DEBUG("SerialComm::readPacket : frame too long - size = " << count << " : resynchronising")
sync = false;
escape = false;
count = crc = 0;
badPacketCount++;
}
else if (escape)
{
if (buffer[count] == SYNC_BYTE)
{
DEBUG("SerialComm::readPacket : resynchronising")
sync = false;
escape = false;
count = crc = 0;
badPacketCount++;
}
else
{
buffer[count] ^= 0x20;
if (count > 3)
{
crc = SerialComm::byteCRC(buffer[count-3], crc);
}
++count;
escape = false;
}
}
else if (buffer[count] == ESCAPE_BYTE)
{
// next byte is escaped
escape = true;
}
else if (buffer[count] == SYNC_BYTE)
{
// calculate last crc byte
if (count > 3)
{
crc = SerialComm::byteCRC(buffer[count-3], crc);
}
uint16_t packetCRC = (buffer[count - 2] & 0xff) | ((buffer[count - 1] << 8) & 0xff00);
if (count < minMTU)
{
DEBUG("SerialComm::readPacket : frame too short - size = " << count << " : resynchronising ")
sync = false;
escape = false;
count = crc = 0;
badPacketCount++;
}
else if (crc != packetCRC)
{
DEBUG("SerialComm::readPacket : bad crc - calculated crc = " << crc << " packet crc = " << packetCRC << " : resynchronising " )
sync = false;
escape = false;
count = crc = 0;
badPacketCount++;
}
else
{
pPacket.setType(buffer[typeOffset]);
pPacket.setSeqno(buffer[seqnoOffset]);
switch (buffer[typeOffset])
{
case SF_ACK:
break;
case SF_PACKET_NO_ACK:
case SF_PACKET_ACK:
// buffer / payload
// FIXME: strange packet format!? because seqno is not really defined - missing :(
pPacket.setPayload(&buffer[payloadOffset]-1, count+1+1 - serialHeaderBytes);
break;
default:
DEBUG("SerialComm::readPacket : unknown packet type = " << static_cast<uint16_t>(buffer[typeOffset] & 0xff))
;
}
completePacket = true;
#ifdef DEBUG_RAW_SERIALCOMM
DEBUG("SerialComm::readPacket : raw data >>")
for (int j=0; j <= count; j++)
{
cout << std::hex << static_cast<uint16_t>(buffer[j] & 0xff) << " " << std::dec;
}
cout << endl;
cout << "as payload >> " << endl;
const char* ptr = pPacket.getPayload();
for (int j=0; j < pPacket.getLength(); j++)
{
cout << std::hex << static_cast<uint16_t>(ptr[j] & 0xff) << " " << std::dec;
}
cout << endl;
#endif
}
}
else
{
if (count > 3)
{
crc = SerialComm::byteCRC(buffer[count-3], crc);
}
++count;
}
}
BasePacket* SFDefaultPacketProtocol::GetPacket(int& ErrorCode)
{
SFPacket* pPacket = PacketPoolSingleton::instance()->Alloc();
pPacket->Initialize();
if(FALSE == m_pPacketIOBuffer->GetPacket(pPacket, ErrorCode))
{
PacketPoolSingleton::instance()->Release(pPacket);
return NULL;
}
SFPacketHeader* pHeader = pPacket->GetHeader();
if(TRUE == pHeader->CheckDataCRC())
{
DWORD dwDataCRC = 0;
BOOL Result = SFPacket::GetDataCRC((BYTE*)pPacket->GetDataBuffer(), pHeader->PacketLen - sizeof(SFPacketHeader), dwDataCRC);
if(TRUE != Result || pHeader->DataCRC != dwDataCRC)
{
//SFLOG_WARN(L"Packet CRC Check Fail!! %d %d", pHeader->DataCRC, dwDataCRC);
ErrorCode = PACKETIO_ERROR_DATA_CRC;
PacketPoolSingleton::instance()->Release(pPacket);
return NULL;
}
}
if (TRUE == pHeader->CheckEncryption())
{
if(FALSE == SFEncrytion<SFEncryptionXOR>::Decrypt((BYTE*)pPacket->GetDataBuffer(), pHeader->PacketLen - sizeof(SFPacketHeader)))
{
SFASSERT(0);
PacketPoolSingleton::instance()->Release(pPacket);
ErrorCode = PACKETIO_ERROR_DATA_ENCRYPTION;
return FALSE;
}
}
if(TRUE == pHeader->CheckCompressed())
{
BYTE pSrcBuf[MAX_PACKET_DATA] = {0,};
int DestSize = MAX_PACKET_DATA;
memcpy(pSrcBuf, pPacket->GetDataBuffer(), pPacket->GetDataSize());
pPacket->ResetDataBuffer();
if(FALSE == SFCompressor<SFCompressLzf>::GetCompressor()->Uncompress(pPacket->GetDataBuffer(), DestSize, pSrcBuf, pPacket->GetDataSize()))
{
//SFLOG_WARN(L"Packet Uncompress Fail!! %d %d", pHeader->DataCRC, dwDataCRC);
PacketPoolSingleton::instance()->Release(pPacket);
ErrorCode = PACKETIO_ERROR_DATA_COMPRESS;
return FALSE;
}
pHeader->PacketLen = DestSize + sizeof(SFPacketHeader);
}
return pPacket;
}
