WorldSocket.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
 * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 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 General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __WORLDSOCKET_H__
#define __WORLDSOCKET_H__

#include "Common.h"
#include "WorldPacketCrypt.h"
#include "ServerPktHeader.h"
#include "Socket.h"
#include "Util.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#include "MPSCQueue.h"
#include <chrono>
#include <boost/asio/ip/tcp.hpp>

using boost::asio::ip::tcp;
struct z_stream_s;
class EncryptablePacket;

namespace WorldPackets
{
 class ServerPacket;
 namespace Auth
 {
 class AuthSession;
 class AuthContinuedSession;
 class ConnectToFailed;
 }
}

#pragma pack(push, 1)

union ClientPktHeader
{
 struct
 {
 uint16 Size;
 uint16 Command;
 } Setup;

 struct
 {
 uint32 Size;
 uint16 Command;
 } Normal;

 static bool IsValidSize(uint32 size) { return size < 10240; }
 static bool IsValidOpcode(uint32 opcode) { return opcode < NUM_OPCODE_HANDLERS; }
};

#pragma pack(pop)

class TC_GAME_API WorldSocket : public Socket<WorldSocket>
{
 static uint32 const ConnectionInitializeMagic;
 static std::string const ServerConnectionInitialize;
 static std::string const ClientConnectionInitialize;
 static uint32 const MinSizeForCompression;

 static uint8 const AuthCheckSeed[16];
 static uint8 const SessionKeySeed[16];
 static uint8 const ContinuedSessionSeed[16];

 typedef Socket<WorldSocket> BaseSocket;

public:
 WorldSocket(tcp::socket&& socket);
 ~WorldSocket();

 WorldSocket(WorldSocket const& right) = delete;
 WorldSocket& operator=(WorldSocket const& right) = delete;

 void Start() override;
 bool Update() override;

 void SendPacket(WorldPacket const& packet);

 ConnectionType GetConnectionType() const { return _type; }

 void SendAuthResponseError(uint32 code);
 void SetWorldSession(WorldSession* session);

protected:
 void OnClose() override;
 void ReadHandler() override;
 bool ReadHeaderHandler();

 enum class ReadDataHandlerResult
 {
 Ok = 0,
 Error = 1,
 WaitingForQuery = 2
 };

 ReadDataHandlerResult ReadDataHandler();
private:
 void CheckIpCallback(PreparedQueryResult result);
 void InitializeHandler(boost::system::error_code error, std::size_t transferedBytes);

 void LogOpcodeText(OpcodeClient opcode, std::unique_lock<std::mutex> const& guard) const;
 void SendPacketAndLogOpcode(WorldPacket const& packet);
 void WritePacketToBuffer(EncryptablePacket const& packet, MessageBuffer& buffer);
 uint32 CompressPacket(uint8* buffer, WorldPacket const& packet);

 void HandleSendAuthSession();
 void HandleAuthSession(std::shared_ptr<WorldPackets::Auth::AuthSession> authSession);
 void HandleAuthSessionCallback(std::shared_ptr<WorldPackets::Auth::AuthSession> authSession, PreparedQueryResult result);
 void HandleAuthContinuedSession(std::shared_ptr<WorldPackets::Auth::AuthContinuedSession> authSession);
 void HandleAuthContinuedSessionCallback(std::shared_ptr<WorldPackets::Auth::AuthContinuedSession> authSession, PreparedQueryResult result);
 void LoadSessionPermissionsCallback(PreparedQueryResult result);
 void HandleConnectToFailed(WorldPackets::Auth::ConnectToFailed& connectToFailed);

 bool HandlePing(WorldPacket& recvPacket);

 void ExtractOpcodeAndSize(ClientPktHeader const* header, uint32& opcode, uint32& size) const;

 ConnectionType _type;

 BigNumber _serverChallenge;
 WorldPacketCrypt _authCrypt;
 BigNumber _encryptSeed;
 BigNumber _decryptSeed;

 std::chrono::steady_clock::time_point _LastPingTime;
 uint32 _OverSpeedPings;

 std::mutex _worldSessionLock;
 WorldSession* _worldSession;
 bool _authed;

 MessageBuffer _headerBuffer;
 MessageBuffer _packetBuffer;
 MPSCQueue<EncryptablePacket> _bufferQueue;

 z_stream_s* _compressionStream;

 PreparedQueryResultFuture _queryFuture;
 std::function<void(PreparedQueryResult&&)> _queryCallback;
 std::string _ipCountry;
};

#endif