void BlueVexWrapper::RelayToServer(const unsigned char* bytes, int length, IProxy* proxy, IModule* module)
{
IPacket* packet = proxy->CreatePacket(bytes, length);
packet->SetFlag(IPacket::PacketFlag_Hidden);
proxy->RelayDataToServer(packet,module);
delete packet;
}
int StateLobby::OnRestoreCharacter (IPacket &packet)
{
if (!m_loaded)
return MSG_ERROR_ORDER;
std::string name = packet.Read();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
player_iterator i = FindCharacterIndex(name);
if ( i != m_player_list.end() )
{
(*i)->restore();
(*i)->set_timeleft(0);
boost::shared_ptr<OPacket> pkt(new OPacket);
srv_pkt::Lobby(pkt,srv_pkt::LOBBY_ACTION_RESTORE);
m_connection->Send(pkt);
DB::PLAYER::Restore query;
query(m_server->DBConnection(),(*i)->ID());
}
else
return MSG_ERROR_ARG;
return MSG_SUCCESS;
}
int StateGlobal::OnTicket (const IPacket &packet)
{
Ticket ticket;
ticket.ID = packet.Read<uint32_t>();
ticket.usr = packet.Read();
ticket.pw = packet.Read();
ticket.IP = packet.Read();
ticket.AccountID = packet.Read<uint32_t>();
ticket.access_lv = packet.Read<uint8_t>();
ticket.sec_lv = packet.Read<uint8_t>();
ticket.silk = packet.Read<uint32_t>();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
m_service->addTicket(ticket);
return MSG_SUCCESS;
}
void BlueVexWrapper::RelayToClient(const unsigned char* bytes, int length, IProxy* proxy, IModule* module) //System::IntPtr _proxy, System::IntPtr _module,
{
IPacket* packet = proxy->CreatePacket(bytes, length);
packet->SetFlag(IPacket::PacketFlag_Hidden);
proxy->RelayDataToClient(packet,module);
delete packet;
}
void IsdnL2::DataReq(QVector<byte> l3data)
{
SimpleLog("DataReq from L3", m_logKinds.general);
IPacket* pPacket = m_pInfra->CreatePacket<IPacket>();
pPacket->Fill(l3data);
//m_l2obj.DatReq( pPacket->Clone() );
m_l2obj.DatReq( pPacket );
}
/**将缓冲区的数据 解码为请求，并且放置请求队列
*/
void Connection::decode(){
IPacket *p = NULL;
_readlock.lock();
while( (p = _streamer->decodeToPacket(_readbuf) ) !=NULL ){
p->setConnection( const_cast<const Connection*>(this) );
Transport::instance().getWritePacketQueue()->push(p);
}
_readlock.unlock();
}
int StateGame::OnGMCommand_AllowLogout (IPacket &packet)
{
std::string playerName = packet.Read();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
return MSG_SUCCESS;
}
int StateGame::OnGMCommand_RecallGuild (IPacket &packet)
{
std::string guildName = packet.Read();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
return MSG_SUCCESS;
}
int StateGame::OnGMCommand_LieName (IPacket &packet)
{
std::string name = packet.Read();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
return MSG_SUCCESS;
}
void PrintPacketToSyslog (const IPacket &packet)
{
std::stringstream ss;
const char *buffer = (const char*)packet.buffer();
for (int i = 0; i < packet.size(); ++i)
ss << std::hex << std::setw(2) << std::setfill('0') << ((int)buffer[i] & 0xFF) << " ";
syslog(LOG_DEBUG,"Hexed Packet:\n%s",ss.str().c_str());
}
bool Server::sendPacket (IPacket& packet) {
buffer_t b;
packet.toBuffer (b);
THeader h;
h.type = packet.getType ();
h.size = b.size ();
THeader* tHPtr = &h;
send (ConnectSocket, reinterpret_cast<char*>(tHPtr), sizeof (h), 0);
send (ConnectSocket, &b[0], b.size(), 0);
return true;
}
IPacket *PacketBuilder::build(char *data, int clientId)
{
int opcode = *(int *)(data + 4);
if (builder_.find(opcode) != builder_.end())
{
IPacket *packet;
if ((packet = (this->*builder_[opcode])(opcode, data + HEADER_SIZE)) == nullptr)
return (nullptr);
packet->setClientId(clientId);
return (packet);
}
return (nullptr);
}
int IStateHandshake::OnWhoIs (const IPacket &packet)
{
std::string srvID = packet.Read();
uint8_t resv = packet.Read<uint8_t>();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
if (resv || srvID != m_SrvID)
return MSG_ERROR_ARG;
OnConfig();
return MSG_SUCCESS;
}
int StateLobby::OnValidateCharacterName (IPacket &packet)
{
std::string name = packet.Read();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
if (IsNameValid(name))
{
boost::shared_ptr<OPacket> pkt(new OPacket);
srv_pkt::Lobby(pkt,srv_pkt::LOBBY_ACTION_VALIDATE_NAME);
m_connection->Send(pkt);
}
return MSG_SUCCESS;
}
int StateGame::OnStatsStrInc (IPacket &packet)
{
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
boost::shared_ptr<Player> player = static_cast<srv::Connection*>(m_connection)->GetPlayer();
if (!player)
return MSG_ERROR;
if (player->get_stat())
{
player->inc_str();
DB::PLAYER::Stats query;
query(m_server->DBConnection(),player);
boost::shared_ptr<OPacket> pkt(new OPacket);
srv_pkt::IncStr(pkt);
m_connection->Send(pkt);
boost::shared_ptr<Party> party = player->get_party();
if (party)
{
party->SendHPMPNotification(player->GetUniqueID(),player->hp(),player->max_hp(),player->mp(),
player->max_mp());
}
}
return MSG_SUCCESS;
}
int StateGame::OnGMCommand_SpawnAllUniques (IPacket &packet)
{
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
return MSG_SUCCESS;
}
int StateGame::OnExchangeRequest (IPacket &packet)
{
uint32_t targetID = packet.Read<uint32_t>();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
World *world = m_server->GetWorld();
boost::shared_ptr<Player> player = static_cast<srv::Connection*>(m_connection)->GetPlayer();
if (!player)
return MSG_ERROR;
if (player->get_selected_object() != targetID)
return MSG_ERROR_ARG;
boost::shared_ptr<Player> target = world->FindPlayer_ByID(targetID);
if(!target)
return MSG_SUCCESS;
player->set_invitation_player(targetID);
target->set_invitation_player(player->GetUniqueID());
target->set_invitation(INVITATION_EXCHANGE);
boost::shared_ptr<OPacket> pkt(new OPacket);
srv_pkt::Invite(pkt,INVITATION_EXCHANGE,player->GetUniqueID());
m_server->Send(pkt,target->ConnectionID());
return MSG_SUCCESS;
}
int StateGame::OnExchangeConfirm (IPacket &packet)
{
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
boost::shared_ptr<Player> player = static_cast<srv::Connection*>(m_connection)->GetPlayer();
if (!player)
return MSG_ERROR;
boost::shared_ptr<Player> target = get_invitation_player(player);
if(!target)
return MSG_SUCCESS;
boost::shared_ptr<OPacket> pkt(new OPacket);
srv_pkt::ExchangeConfirm(pkt);
m_connection->Send(pkt);
pkt.reset(new OPacket);
srv_pkt::ExchangePlayerConfirm(pkt);
m_server->Send(pkt,target->ConnectionID());
return MSG_SUCCESS;
}
bool Server::readPacket (int replyType, IPacket& p, int timeout)
{
THeader h;
int rd = recvallWin(ConnectSocket, &h, sizeof(h), 1000);
if(rd == 0)
{
closesocket(ConnectSocket);
WSACleanup();
m_state = NotConnected;
return false;
}
if(h.size > 0)
{
buffer_t buf;
buf.resize (h.size);
rd = recvallWin (ConnectSocket, &buf[0], h.size, 1000);
if(rd == 0)
{
closesocket(ConnectSocket);
WSACleanup();
m_state = NotConnected;
return false;
}
if(h.type == replyType)
{
p.fromBuffer(buf);
return true;
}
}
return false;
}
int StateCertify::OnCertify (const IPacket &packet)
{
uint8_t ret = packet.Read<uint8_t>();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
if (ret > ANSWER_ERROR)
return MSG_ERROR_ARG;
if (ret == ANSWER_ACCEPT)
{
syslog(LOG_INFO,"Certification Successfull.");
m_service->runServer();
m_connection->stop();
}
else
{
syslog(LOG_INFO,"Certification failed.");
m_service->stop();
}
return MSG_SUCCESS;
}
int IStateHandshake::OnHandshake_Signature (const IPacket &packet)
{
uint8_t signature[KEY_LENGTH] = { 0 };
for (int i=0; i < KEY_LENGTH; ++i)
signature[i] = packet.Read<uint8_t>();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
/// Simple check to see if the handshake is good
if(memcmp(m_srv_signature,signature,KEY_LENGTH))
{
#if defined DEBUG
syslog(LOG_DEBUG,"clt::IStateHandshake::OnHandshake_Signature - Invalid Server Signature.");
syslog(LOG_DEBUG,"Server Key = %i %i, Client Key = %i %i",m_srv_signature[0],m_srv_signature[1],
signature[0],signature[1]);
#endif
return MSG_ERROR_ARG;
}
Func_X_2(m_base_key, m_S, 0x3);
boost::shared_ptr<SROAuth> auth =
boost::shared_static_cast<SROAuth,Authentication>(m_connection->getAuthentication());
auth->setKey(m_base_key,KEY_LENGTH);
SendID();
return MSG_SUCCESS;
}
int StateGame::OnGMCommand_CreateItem (IPacket &packet)
{
uint32_t itemID = packet.Read<uint32_t>();
uint8_t arg = packet.Read<uint8_t>();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
boost::shared_ptr<Player> player = static_cast<srv::Connection*>(m_connection)->GetPlayer();
if (!player)
return MSG_ERROR;
World *world = m_server->GetWorld();
if (!world)
return MSG_ERROR;
boost::shared_ptr<OPacket> pkt(new OPacket);
try
{
Item item = world->GetItemFactory()->Create(itemID);
boost::shared_ptr<Storage> inv = player->get_storage(STORAGE_INVENTORY);
uint8_t pos = inv->get_empty_position(13);
if (pos == 255)
{
srv_pkt::ItemMove(pkt,srv_pkt::ITEM_ERROR_INVENTORY_FULL);
m_connection->Send(pkt);
return MSG_SUCCESS;
}
item.set_quantity(1);
item.set_position(pos);
item.set_place(STORAGE_INVENTORY);
if (item.IsWeapon() || item.IsShield() || item.IsArmor() || item.IsAccessory())
item.set_enchant_lv(arg);
else
item.set_quantity(arg);
inv->InsertItem(item);
srv_pkt::Item(pkt,srv_pkt::ITEM_MOVE_PICKUP,item);
m_connection->Send(pkt);
}
catch (const Exception::InvalidItemID &error)
{
syslog(LOG_INFO,"Failed to create item with ID = %i",itemID);
}
return MSG_SUCCESS;
}
int IStateHandshake::OnHandshake_Clean (const IPacket &packet)
{
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
SendID();
return MSG_SUCCESS;
}
void PacketStream::emit(IPacket& packet)
{
TraceS(this) << "Emit: " << packet.size() << endl;
// Ensure the stream is still running
if (!stateEquals(PacketStreamState::Active)) {
TraceS(this) << "Dropping packet on inactive stream: " << state()
<< endl;
return;
}
try {
emitter.emit(packet);
} catch (std::exception& exc) {
handleException(exc);
}
TraceS(this) << "Emit: OK: " << packet.size() << endl;
}
void SyncPacketQueue::process(IPacket& packet)
{
if (cancelled()) {
WarnLS(this) << "Process late packet" << endl;
assert(0);
return;
}
push(packet.clone());
}
int StateGame::OnGMCommand_MoveToUser (IPacket &packet)
{
std::string name = packet.Read();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
boost::shared_ptr<Player> player = static_cast<srv::Connection*>(m_connection)->GetPlayer();
if (!player)
return MSG_ERROR;
boost::shared_ptr<Player> target = m_server->GetWorld()->FindPlayer_ByName(name);
if (target)
{
player->SetCurrentTask(PLAYER_TASK_TELEPORT);
m_server->GetWorld()->InitTaskTeleport(player->GetUniqueID(),target->get_position(),0);
}
return MSG_SUCCESS;
}
int SocketAdapter::sendPacket(const IPacket& packet, int flags)
{
// Try to cast as RawPacket so we can send without copying any data.
auto raw = dynamic_cast<const RawPacket*>(&packet);
if (raw)
return send((const char*)raw->data(), raw->size(), flags);
// Dynamically generated packets need to be written to a
// temp buffer for sending.
else {
Buffer buf;
packet.write(buf);
return send(buf.data(), buf.size(), flags);
}
}
int StateLobby::OnListCharacter (IPacket &packet)
{
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
if (!m_loaded)
{
LoadCharacters();
m_loaded = true;
}
boost::shared_ptr<OPacket> pkt(new OPacket);
srv_pkt::Lobby(pkt,m_player_list);
m_connection->Send(pkt);
return MSG_SUCCESS;
}
int StateGame::OnGMCommand_LoadMonster (IPacket &packet)
{
uint32_t ID = packet.Read<uint32_t>();
uint8_t quantity = packet.Read<uint8_t>();
uint8_t type = packet.Read<uint8_t>();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
if (!quantity)
quantity = 1;
boost::shared_ptr<Player> player = static_cast<srv::Connection*>(m_connection)->GetPlayer();
if (!player)
return MSG_ERROR;
if(m_server->GetWorld()->IsInsideTown(player->get_position()))
return MSG_SUCCESS;
boost::shared_ptr<NPC> mob;
std::vector<boost::shared_ptr<NPC> > list;
World *world = m_server->GetWorld();
for (uint16_t i = 0; i < quantity; ++i)
{
mob = world->GetCharacterFactory()->Create(ID);
if (!mob)
{
syslog(LOG_INFO,"Failed to create NPC with ID = %i",ID);
return MSG_SUCCESS;
}
mob->set_position(player->get_position());
list.push_back(mob);
}
world->InsertNPC(list,player->get_position());
return MSG_SUCCESS;
}
int StateGame::OnGMCommand_ClearInventory (IPacket &packet)
{
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
// boost::shared_ptr<Storage> inv = m_player->get_storage(STORAGE_INVENTORY);
//
// for (Storage::iterator iter = inv->begin(); iter != inv->end(); ++iter)
// {
// if (iter->first >= Item::MAX_EQUIPMENT_SLOT)
// {
// send(packet::ItemEnchant(iter->first)); ///REMOVE ITEM FROM INVENTORY
//
// inv->RemoveItem(iter->first);
// }
// }
return MSG_SUCCESS;
}
