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; }