WorldSocket.h

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org.
* See LICENSE.md file for Copyright information
*/

 
#ifndef SF_WORLDSOCKET_H
#define SF_WORLDSOCKET_H
 
#include "AuthCrypt.h"
#include "Common.h"
#include "Platform/Threading.h"
#include "SharedDefines.h"
#include "WorldSocketSessionState.h"
#include <boost/asio/ip/tcp.hpp>
#include <boost/system/error_code.hpp>
#include <array>
#include <atomic>
#include <chrono>
#include <deque>
#include <functional>
#include <memory>
#include <mutex>
#include <vector>
 
typedef boost::asio::ip::tcp::socket WorldSocketHandle;
 
namespace Skyfire
{
namespace Net
{
    template<class AsyncWriteStream>
    class BoostAsioWriteQueue;
}
}
 
class WorldPacket;
class WorldSession;
namespace Skyfire
{
struct PacketLogServerSessionInfo;
}

class WorldSocket
{
public:
    WorldSocket(std::unique_ptr<WorldSocketHandle> socket, std::string remoteAddress);
    ~WorldSocket(void);
 
    friend class WorldSocketMgr;
    friend class ReactorRunnable;

    typedef Skyfire::Mutex LockType;
    typedef std::unique_lock<LockType> GuardType;

    bool IsClosed(void) const;

    void CloseSocket(void);

    const std::string& GetRemoteAddress(void) const;

    int SendPacket(const WorldPacket& pct);

    void LogPacketMarker(std::string const& marker);

    void RefreshPacketLogSessionInfo();

    long AddReference(void);

    long RemoveReference(void);

    int Initialize(void);

    void Start(std::function<void(WorldSocket*)> closeHandler);

    void DetachSession(WorldSession* session);

    bool HasPendingOutput(void) const;
 
private:
    int handle_input_header(void);
    int handle_input_payload(void);
    int handle_input_missing_data(char const* data, size_t length);

    int ProcessIncoming(WorldPacket* new_pct);

    int HandleAuthSession(WorldPacket& recvPacket);

    int HandlePing(WorldPacket& recvPacket);

    int HandleSendAuthSession();
 
private:
    void SendAuthResponseError(ResponseCodes code);
    bool IsValidSocket(void) const;
    void StartAsyncRead();
    void QueueSerializedPacket(std::vector<char> data);
    void HandleAsyncRead(boost::system::error_code const& error, size_t transferredBytes);
    void HandleAsyncWrite(boost::system::error_code const& error, size_t transferredBytes);
    void NotifyClosed();
    Skyfire::PacketLogServerSessionInfo BuildPacketLogSessionInfo() const;

    std::chrono::steady_clock::time_point m_LastPingTime;
    bool m_HasLastPingTime;

    uint32 m_OverSpeedPings;

    std::string m_Address;

    AuthCrypt m_Crypt;

    WorldSocketSessionState m_SessionState;

    WorldPacket* m_RecvWPct;
 
    size_t m_RecvPctRead;
    std::vector<uint8> m_Header;
    size_t m_HeaderRead;
    std::vector<uint8> m_WorldHeader;
    size_t m_WorldHeaderRead;

    mutable LockType m_SendLock;

    std::deque<std::vector<char>> m_PendingOutput;

    size_t m_OutBufferSize;
    bool m_Started;
 
    std::array<uint8, 4> m_Seed;
    std::array<char, 4096> m_ReadBuffer;
 
    std::unique_ptr<WorldSocketHandle> m_Socket;
    std::unique_ptr<Skyfire::Net::BoostAsioWriteQueue<WorldSocketHandle>> m_WriteQueue;
    std::function<void(WorldSocket*)> m_CloseHandler;
    std::atomic<long> m_ReferenceCount;
    std::atomic<bool> m_Closed;
    std::atomic<bool> m_CloseNotified;
 
    WorldSocket(WorldSocket const& right) = delete;
    WorldSocket& operator=(WorldSocket const& right) = delete;
};
 
#endif  /* _WORLDSOCKET_H */