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