Leviathan::NetworkInterface Class Reference

Class that encapsulates common networking functionality that is required by all networked programs. More...

#include <NetworkInterface.h>

Inheritance diagram for Leviathan::NetworkInterface:

Public Member Functions
DLLEXPORT	NetworkInterface (NETWORKED_TYPE type)
virtual DLLEXPORT	~NetworkInterface ()
virtual DLLEXPORT std::vector< std::shared_ptr< Connection > > &	GetClientConnections ()=0
	If this is a server returns all the clients. More...
virtual DLLEXPORT void	HandleRequestPacket (const std::shared_ptr< NetworkRequest > &request, Connection &connection)=0
	Called by ConnectionInfo to handle incoming packets. More...
virtual DLLEXPORT bool	PreHandleResponse (const std::shared_ptr< NetworkResponse > &response, SentNetworkThing *originalrequest, Connection &connection)
	Called by ConnectionInfo to verify that a response is good. More...
virtual DLLEXPORT void	HandleResponseOnlyPacket (const std::shared_ptr< NetworkResponse > &message, Connection &connection)=0
	Called by ConnectionInfo when it receives a response without a matching request object. More...
virtual DLLEXPORT bool	CanConnectionTerminate (Connection &connection)
	Called by Connection just before terminating an inactive connection. More...
virtual DLLEXPORT void	TickIt ()=0
	Should be used to update various network interfaces. More...
virtual DLLEXPORT void	CloseDown ()=0
	Called when the program is closing. More...
DLLEXPORT void	VerifyType (NETWORKED_TYPE type) const
	Asserts if types don't match. More...
NetworkHandler *	GetOwner ()

Protected Member Functions
virtual bool	_CustomHandleRequestPacket (const std::shared_ptr< NetworkRequest > &request, Connection &connection)
virtual bool	_CustomHandleResponseOnlyPacket (const std::shared_ptr< NetworkResponse > &message, Connection &connection)
DLLEXPORT bool	_HandleDefaultRequest (const std::shared_ptr< NetworkRequest > &request, Connection &connectiontosendresult)
	Utility function for subclasses to call for default handling. More...
DLLEXPORT bool	_HandleDefaultResponseOnly (const std::shared_ptr< NetworkResponse > &message, Connection &connection)
	Utility function for subclasses to call for default handling of non-request responses. More...
DLLEXPORT void	SetOwner (NetworkHandler *owner)

Protected Attributes
NETWORKED_TYPE	OurNetworkType
NetworkHandler *	Owner = nullptr

Detailed Description

Class that encapsulates common networking functionality that is required by all networked programs.

See also

NetworkServerInterface NetworkClientInterface

Definition at line 18 of file NetworkInterface.h.

Constructor & Destructor Documentation

NetworkInterface()

DLLEXPORT NetworkInterface::NetworkInterface

(

NETWORKED_TYPE

type

)

Definition at line 16 of file NetworkInterface.cpp.

: OurNetworkType(type) {}

~NetworkInterface()

DLLEXPORT NetworkInterface::~NetworkInterface ( )

virtual

Definition at line 18 of file NetworkInterface.cpp.

{}

Member Function Documentation

_CustomHandleRequestPacket()

virtual bool Leviathan::NetworkInterface::_CustomHandleRequestPacket ( const std::shared_ptr< NetworkRequest > &  request, Connection &  connection  )

inlineprotectedvirtual

Definition at line 93 of file NetworkInterface.h.

    {
        return false;
    }

_CustomHandleResponseOnlyPacket()

virtual bool Leviathan::NetworkInterface::_CustomHandleResponseOnlyPacket ( const std::shared_ptr< NetworkResponse > &  message, Connection &  connection  )

inlineprotectedvirtual

Definition at line 99 of file NetworkInterface.h.

    {
        return false;
    }

_HandleDefaultRequest()

bool NetworkInterface::_HandleDefaultRequest ( const std::shared_ptr< NetworkRequest > &  request, Connection &  connectiontosendresult  )

protected

Utility function for subclasses to call for default handling.

Handles default types of request packages and returns true if processed.

Definition at line 38 of file NetworkInterface.cpp.

{
    // Switch based on type //

    // See if it is a sync packet //
    if(Owner->GetSyncedVariables()->HandleSyncRequests(request, &connection))
        return true;

    switch(request->GetType()) {
    case NETWORK_REQUEST_TYPE::Identification: {
        // Avoid allowing DDOS amplification
        const uint32_t maxlength = static_cast<uint32_t>(
            static_cast<RequestIdentification*>(request.get())->DDOSBlock.size());

        // Fetch the data from the configuration object //
        std::string userreadable, gamename, gameversion;

        AppDef::GetDefault()->GetGameIdentificationData(userreadable, gamename, gameversion);

        auto response = ResponseIdentification(
            0, userreadable, gamename, gameversion, LEVIATHAN_VERSION_ANSIS);

        NetworkResponse::LimitResponseSize(response, maxlength);

        // Should be critical, but it is not to avoid DDoS amplification
        connection.SendPacketToConnection(response);

        return true;
    }
    case NETWORK_REQUEST_TYPE::Echo: {
        // Send an empty response back //
        connection.SendPacketToConnection(
            std::make_shared<ResponseNone>(NETWORK_RESPONSE_TYPE::None),
            RECEIVE_GUARANTEE::None);

        return true;
    }
    case NETWORK_REQUEST_TYPE::RemoteConsoleAccess:
    case NETWORK_REQUEST_TYPE::CloseRemoteConsole: {
        Engine::Get()->GetRemoteConsole()->HandleRemoteConsoleRequestPacket(
            request, Owner->GetConnection(&connection));

        return true;
    }
    case NETWORK_REQUEST_TYPE::ConnectInput: {
        DEBUG_BREAK;
        // if (!Owner->GetInputHandler())
        //    return false;

        // Owner->GetInputHandler()->HandleInputPacket(request, connection);

        return true;
    }
    default: return false;
    }

    // Unhandled //
    return false;
}

_HandleDefaultResponseOnly()

bool NetworkInterface::_HandleDefaultResponseOnly ( const std::shared_ptr< NetworkResponse > &  message, Connection &  connection  )

protected

Utility function for subclasses to call for default handling of non-request responses.

Handles default types of response packages and returns true if processed.

Definition at line 99 of file NetworkInterface.cpp.

{
    // See if it is a sync packet //
    if(Owner->GetSyncedVariables()->HandleResponseOnlySync(message, &connection))
        return true;

    // Switch on type //
    switch(message->GetType()) {
    case NETWORK_RESPONSE_TYPE::Keepalive:
    case NETWORK_RESPONSE_TYPE::None: {
        // Empty packets without a matching request are just ignored,
        // but marked as received
        return true;
    }
    case NETWORK_RESPONSE_TYPE::CloseConnection: {
        // This connection should be closed //
        Logger::Get()->Info("NetworkInterface: dropping connection due to "
                            "receiving a connection close packet (" +
                            connection.GenerateFormatedAddressString() + ")");

        Owner->CloseConnection(connection);
        return true;
    }
    case NETWORK_RESPONSE_TYPE::RemoteConsoleOpened:
    case NETWORK_RESPONSE_TYPE::RemoteConsoleClosed: {
        // Pass to remote console //
        Engine::Get()->GetRemoteConsole()->HandleRemoteConsoleResponse(
            message, connection, NULL);
        return true;
    }
    case NETWORK_RESPONSE_TYPE::CreateNetworkedInput:
    case NETWORK_RESPONSE_TYPE::UpdateNetworkedInput: {
        DEBUG_BREAK;

        // if (!Owner->GetInputHandler())
        //    return false;

        // Owner->GetInputHandler()->HandleInputPacket(request, connection);

        return true;
    }

    default: return false;
    }

    // Not handled //
    return false;
}

CanConnectionTerminate()

DLLEXPORT bool NetworkInterface::CanConnectionTerminate ( Connection &  connection )

virtual

Called by Connection just before terminating an inactive connection.

Return true if you want to allow the connection to close (it will close before next packet receive update) By default will allow all requesting connections to terminate.

Definition at line 149 of file NetworkInterface.cpp.

{
    // By default allow connections to close //
    return true;
}

CloseDown()

virtual DLLEXPORT void Leviathan::NetworkInterface::CloseDown ( )

pure virtual

Called when the program is closing.

Implemented in Leviathan::NetworkClientInterface, Leviathan::NetworkServerInterface, and Leviathan::NetworkMasterServerInterface.

GetClientConnections()

virtual DLLEXPORT std::vector<std::shared_ptr<Connection> >& Leviathan::NetworkInterface::GetClientConnections ( )

pure virtual

If this is a server returns all the clients.

Implemented in Leviathan::NetworkClientInterface, Leviathan::NetworkServerInterface, and Leviathan::NetworkMasterServerInterface.

GetOwner()

NetworkHandler* Leviathan::NetworkInterface::GetOwner ( )

inline

Definition at line 86 of file NetworkInterface.h.

    {

        return Owner;
    }

HandleRequestPacket()

DLLEXPORT void NetworkInterface::HandleRequestPacket ( const std::shared_ptr< NetworkRequest > &  request, Connection &  connection  )

pure virtual

Called by ConnectionInfo to handle incoming packets.

This function is responsible for interpreting the packet data and generating a response. If the response could take a long time to generate it is recommended to queue a task to the ThreadingManager.

Note

The connection parameter shouldn't be stored directly since it can become invalid after this function returns. Get a shared pointer from NetworkHandler instead

Implemented in Leviathan::NetworkClientInterface, Leviathan::NetworkServerInterface, and Leviathan::NetworkMasterServerInterface.

Definition at line 27 of file NetworkInterface.cpp.

{
    // We can only try the default handle function //
    if(!_HandleDefaultRequest(request, connection)) {
        // We couldn't handle it //

        throw InvalidArgument("could not handle request with default handler");
    }
}

HandleResponseOnlyPacket()

virtual DLLEXPORT void Leviathan::NetworkInterface::HandleResponseOnlyPacket ( const std::shared_ptr< NetworkResponse > &  message, Connection &  connection  )

pure virtual

Called by ConnectionInfo when it receives a response without a matching request object.

This is called when the host on the connection sends a response without a matching request. Usually the other program instance wants us to do something without expecting a response, for example they could want us to add a new message to our inbox without expecting a response (other than an ack which is automatically sent) from us. The function can optionally ignore keepalive acks (to reduce spam between clients) by setting dontmarkasreceived as true. This function shouldn't throw any exceptions.

Implemented in Leviathan::NetworkClientInterface, Leviathan::NetworkServerInterface, and Leviathan::NetworkMasterServerInterface.

PreHandleResponse()

DLLEXPORT bool NetworkInterface::PreHandleResponse ( const std::shared_ptr< NetworkResponse > &  response, SentNetworkThing *  originalrequest, Connection &  connection  )

virtual

Called by ConnectionInfo to verify that a response is good.

By default this will always return true, but that can be overloaded to return false if the response is no good When returning false the connection will pretend that the response never arrived and possibly resends the request

Definition at line 20 of file NetworkInterface.cpp.

{
    return true;
}

SetOwner()

DLLEXPORT void NetworkInterface::SetOwner ( NetworkHandler *  owner )

protected

Definition at line 160 of file NetworkInterface.cpp.

{
    Owner = owner;
}

TickIt()

virtual DLLEXPORT void Leviathan::NetworkInterface::TickIt ( )

pure virtual

Should be used to update various network interfaces.

Note

This NetworkInterface doesn't need any ticking, but NetworkClientInterface does

See also

NetworkClientInterface::UpdateClientStatus

Implemented in Leviathan::NetworkClientInterface, Leviathan::NetworkServerInterface, and Leviathan::NetworkMasterServerInterface.

VerifyType()

DLLEXPORT void NetworkInterface::VerifyType

(

NETWORKED_TYPE

type

)

const

Asserts if types don't match.

Definition at line 155 of file NetworkInterface.cpp.

{
    LEVIATHAN_ASSERT(type == OurNetworkType, "NetworkInterface::VerifyType doesn't match");
}

Member Data Documentation

OurNetworkType

NETWORKED_TYPE Leviathan::NetworkInterface::OurNetworkType

protected

Definition at line 122 of file NetworkInterface.h.

Owner

NetworkHandler* Leviathan::NetworkInterface::Owner = nullptr

protected

Definition at line 123 of file NetworkInterface.h.

---

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

• NetworkInterface.h
• NetworkInterface.cpp