Leviathan::NetworkResponse Class Reference

#include <NetworkResponse.h>

Inheritance diagram for Leviathan::NetworkResponse:

Public Member Functions
	NetworkResponse (NETWORK_RESPONSE_TYPE type, uint32_t responseid)
virtual	~NetworkResponse ()
void	AddDataToPacket (sf::Packet &packet) const
NETWORK_RESPONSE_TYPE	GetType () const
DLLEXPORT std::string	GetTypeStr () const
auto	GetResponseID () const

Static Public Member Functions
static DLLEXPORT std::shared_ptr< NetworkResponse >	LoadFromPacket (sf::Packet &packet)
static DLLEXPORT void	LimitResponseSize (ResponseIdentification &response, uint32_t maxsize)
	Limits size of response to avoid the application being used for DDoS amplification. More...

Protected Member Functions
virtual DLLEXPORT void	_SerializeCustom (sf::Packet &packet) const =0
	Base classes serialize their data. More...

Protected Attributes
const NETWORK_RESPONSE_TYPE	Type
	Type of response. Specifies which subclass this object is. More...
const uint32_t	ResponseID = 0

Detailed Description

Base class for all request objects

Note

Even though it cannot be required by the base class, sub classes should implement a constructor taking in an sf::Packet object

Todo:

Re-implement limiting string lengths in messages

Definition at line 141 of file NetworkResponse.h.

Constructor & Destructor Documentation

NetworkResponse()

Leviathan::NetworkResponse::NetworkResponse ( NETWORK_RESPONSE_TYPE  type, uint32_t  responseid  )

inline

Definition at line 143 of file NetworkResponse.h.

                                                                     :
        Type(type), ResponseID(responseid)
    {
        LEVIATHAN_ASSERT(responseid != static_cast<uint32_t>(-1),
            "Response should use 0 if in response to anything");
    }

~NetworkResponse()

virtual Leviathan::NetworkResponse::~NetworkResponse ( )

inlinevirtual

Definition at line 150 of file NetworkResponse.h.

{};

Member Function Documentation

_SerializeCustom()

virtual DLLEXPORT void Leviathan::NetworkResponse::_SerializeCustom ( sf::Packet &  packet ) const

protectedpure virtual

Base classes serialize their data.

Implemented in Leviathan::ResponseNone, and Leviathan::ResponseCustom.

AddDataToPacket()

void Leviathan::NetworkResponse::AddDataToPacket ( sf::Packet &  packet ) const

inline

Definition at line 152 of file NetworkResponse.h.

    {
        packet << static_cast<uint16_t>(Type) << ResponseID;

        _SerializeCustom(packet);
    }

GetResponseID()

auto Leviathan::NetworkResponse::GetResponseID ( ) const

inline

Definition at line 167 of file NetworkResponse.h.

    {
        return ResponseID;
    }

GetType()

NETWORK_RESPONSE_TYPE Leviathan::NetworkResponse::GetType ( ) const

inline

Definition at line 159 of file NetworkResponse.h.

    {
        return Type;
    }

GetTypeStr()

DLLEXPORT std::string NetworkResponse::GetTypeStr

(

)

const

Returns

Name of this type. For prettier debug printing

Definition at line 73 of file NetworkResponse.cpp.

{
    switch(Type) {
    case NETWORK_RESPONSE_TYPE::Connect: return "ResponseConnect";
    case NETWORK_RESPONSE_TYPE::Security: return "ResponseSecurity";
    case NETWORK_RESPONSE_TYPE::Authenticate: return "ResponseAuthenticate";
    case NETWORK_RESPONSE_TYPE::Identification: return "ResponseIdentification";
    case NETWORK_RESPONSE_TYPE::Keepalive: return "ResponseKeepalive";
    case NETWORK_RESPONSE_TYPE::CloseConnection: return "ResponseCloseConnection";
    case NETWORK_RESPONSE_TYPE::RemoteConsoleClosed: return "ResponseRemoteConsoleClosed";
    case NETWORK_RESPONSE_TYPE::RemoteConsoleOpened: return "ResponseRemoteConsoleOpened";
    case NETWORK_RESPONSE_TYPE::InvalidRequest: return "ResponseInvalidRequest";
    case NETWORK_RESPONSE_TYPE::ServerDisallow: return "ResponseServerDisallow";
    case NETWORK_RESPONSE_TYPE::ServerAllow: return "ResponseServerAllow";
    case NETWORK_RESPONSE_TYPE::ServerStatus: return "ResponseServerStatus";
    case NETWORK_RESPONSE_TYPE::SyncValData: return "ResponseSyncValData";
    case NETWORK_RESPONSE_TYPE::SyncDataEnd: return "ResponseSyncDataEnd";
    case NETWORK_RESPONSE_TYPE::SyncResourceData: return "ResponseSyncResourceData";
    case NETWORK_RESPONSE_TYPE::CreateNetworkedInput: return "ResponseCreateNetworkedInput";
    case NETWORK_RESPONSE_TYPE::UpdateNetworkedInput: return "ResponseUpdateNetworkedInput";
    case NETWORK_RESPONSE_TYPE::DisconnectInput: return "ResponseDisconnectInput";
    case NETWORK_RESPONSE_TYPE::StartWorldReceive: return "ResponseStartWorldReceive";
    case NETWORK_RESPONSE_TYPE::EntityCreation: return "ResponseEntityCreation";
    case NETWORK_RESPONSE_TYPE::EntityUpdate: return "ResponseEntityUpdate";
    case NETWORK_RESPONSE_TYPE::EntityDestruction: return "ResponseEntityDestruction";
    case NETWORK_RESPONSE_TYPE::EntityLocalControlStatus:
        return "ResponseEntityLocalControlStatus";
    case NETWORK_RESPONSE_TYPE::CacheUpdated: return "ResponseCacheUpdated";
    case NETWORK_RESPONSE_TYPE::CacheRemoved: return "ResponseCacheRemoved";
    case NETWORK_RESPONSE_TYPE::WorldFrozen: return "ResponseWorldFrozen";
    case NETWORK_RESPONSE_TYPE::ServerHeartbeat: return "ResponseServerHeartbeat";
    case NETWORK_RESPONSE_TYPE::StartHeartbeats: return "ResponseStartHeartbeats";
    case NETWORK_RESPONSE_TYPE::None: return "ResponseNone";
    default: break;
    }

    if(Type > NETWORK_RESPONSE_TYPE::Custom) {

        return "ResponseCustom(+" +
               std::to_string(
                   static_cast<int>(Type) - static_cast<int>(NETWORK_RESPONSE_TYPE::Custom)) +
               ")";

    } else {

        return std::to_string(static_cast<int>(Type));
    }
}

LimitResponseSize()

DLLEXPORT void Leviathan::NetworkResponse::LimitResponseSize ( ResponseIdentification &  response, uint32_t  maxsize  )

static

Limits size of response to avoid the application being used for DDoS amplification.

Definition at line 61 of file NetworkResponse.cpp.

{
    if(response.GameName.length() + response.GameVersionString.length() +
            response.LeviathanVersionString.length() + response.UserReadableData.length() >
        maxsize) {
        // Need to trim something //
        DEBUG_BREAK;
        response.UserReadableData = "";
    }
}

LoadFromPacket()

DLLEXPORT std::shared_ptr< NetworkResponse > NetworkResponse::LoadFromPacket ( sf::Packet &  packet )

static

Definition at line 8 of file NetworkResponse.cpp.

{
    // First thing is the type, based on which we handle the rest of the data
    // This is before responseid to look more like a request packet
    uint16_t rawtype;
    packet >> rawtype;

    // Second thing is the response ID //
    uint32_t responseid = 0;
    packet >> responseid;

    if(!packet)
        throw InvalidArgument("packet has invalid format");

    const auto responsetype = static_cast<NETWORK_RESPONSE_TYPE>(rawtype);

    // Process based on the type //
    switch(responsetype) {
    case NETWORK_RESPONSE_TYPE::Connect:
        return std::make_shared<ResponseConnect>(responseid, packet);
    case NETWORK_RESPONSE_TYPE::Authenticate:
        return std::make_shared<ResponseAuthenticate>(responseid, packet);
    case NETWORK_RESPONSE_TYPE::Security:
        return std::make_shared<ResponseSecurity>(responseid, packet);
    case NETWORK_RESPONSE_TYPE::ServerAllow:
        return std::make_shared<ResponseServerAllow>(responseid, packet);
    case NETWORK_RESPONSE_TYPE::ServerDisallow:
        return std::make_shared<ResponseServerDisallow>(responseid, packet);
    case NETWORK_RESPONSE_TYPE::StartWorldReceive:
        return std::make_shared<ResponseStartWorldReceive>(responseid, packet);
    case NETWORK_RESPONSE_TYPE::EntityCreation:
        return std::make_shared<ResponseEntityCreation>(responseid, packet);
    case NETWORK_RESPONSE_TYPE::EntityDestruction:
        return std::make_shared<ResponseEntityDestruction>(responseid, packet);
    case NETWORK_RESPONSE_TYPE::EntityUpdate:
        return std::make_shared<ResponseEntityUpdate>(responseid, packet);
    case NETWORK_RESPONSE_TYPE::EntityLocalControlStatus:
        return std::make_shared<ResponseEntityLocalControlStatus>(responseid, packet);
    // None based types
    case NETWORK_RESPONSE_TYPE::CloseConnection:
    case NETWORK_RESPONSE_TYPE::Keepalive:
    case NETWORK_RESPONSE_TYPE::None:
        return std::make_shared<ResponseNone>(responsetype, responseid, packet);

    default: {
        Logger::Get()->Warning("NetworkResponse: unused type: " +
                               Convert::ToString(static_cast<int>(responsetype)));
        throw InvalidArgument("packet has response type that is missing from "
                              "switch(responsetype)");
    } break;
    }
}

Member Data Documentation

ResponseID

const uint32_t Leviathan::NetworkResponse::ResponseID = 0

protected

Definition at line 186 of file NetworkResponse.h.

Type

const NETWORK_RESPONSE_TYPE Leviathan::NetworkResponse::Type

protected

Type of response. Specifies which subclass this object is.

Definition at line 184 of file NetworkResponse.h.

---

The documentation for this class was generated from the following files:

• NetworkResponse.h
• NetworkResponse.cpp