TCPConnection Class Reference

Generic class for TCP connections. More...

#include "TCPConnection.h"

Inheritance diagram for TCPConnection:

Collaboration diagram for TCPConnection:

Public Types
enum	state_t { STATE_DISCONNECTED, STATE_CONNECTING, STATE_CONNECTED, STATE_DISCONNECTING }

Public Member Functions
	TCPConnection ()
	Creates new connection in STATE_DISCONNECTED. More...
virtual	~TCPConnection ()
	Cleans connection up. More...
uint32	GetrIP () const
uint16	GetrPort () const
std::string	GetAddress ()
state_t	GetState () const
bool	Connect (uint32 rIP, uint16 rPort, char *errbuf=0)
	Connects to specified address. More...
void	AsyncConnect (uint32 rIP, uint16 rPort)
	Schedules asynchronous connect to specified address. More...
void	Disconnect ()
	Schedules disconnect of current connection. More...
bool	Send (Buffer **data)
	Enqueues data to be sent. More...

Protected Member Functions
	TCPConnection (Socket *sock, uint32 rIP, uint16 rPort)
	Creates connection from an existing socket. More...
void	StartLoop ()
	Starts working thread. More...
void	WaitLoop ()
	Blocks calling thread until working thread terminates. More...
virtual bool	Process ()
	Does all stuff that needs to be periodically done to keep connection alive. More...
virtual bool	ProcessReceivedData (char *errbuf=0)=0
	Processes received data. More...
virtual bool	SendData (char *errbuf=0)
	Sends data in send queue. More...
virtual bool	RecvData (char *errbuf=0)
	Receives data and puts them into receive queue. More...
void	DoDisconnect ()
	Disconnects socket. More...
virtual void	ClearBuffers ()
	Clears send and receive buffers. More...
void	TCPConnectionLoop ()
	Loop for worker threads. More...

Static Protected Member Functions
static void *	TCPConnectionLoop (void *arg)
	Loop for worker threads. More...

Protected Attributes
Mutex	mMSock
Socket *	mSock
state_t	mSockState
uint32	mrIP
uint16	mrPort
Mutex	mMLoopRunning
Mutex	mMSendQueue
std::deque< Buffer * >	mSendQueue
Buffer *	mRecvBuf

Detailed Description

Generic class for TCP connections.

Author

Zhur, Bloody.Rabbit

Definition at line 45 of file TCPConnection.h.

Member Enumeration Documentation

enum TCPConnection::state_t

Describes all states this object may be in.

Enumerator
STATE_DISCONNECTED	No connection.
STATE_CONNECTING	Connection pending (asynchronous connection).
STATE_CONNECTED	Connection established, transferring data.
STATE_DISCONNECTING	Disconnect pending, waiting for all data to be sent.

Definition at line 49 of file TCPConnection.h.

    {
        STATE_DISCONNECTED, 
        STATE_CONNECTING,   
        STATE_CONNECTED,    
        STATE_DISCONNECTING 
    };

Constructor & Destructor Documentation

TCPConnection::TCPConnection

(

)

Creates new connection in STATE_DISCONNECTED.

Definition at line 39 of file TCPConnection.cpp.

: mSock( nullptr ),
  mSockState( STATE_DISCONNECTED ),
  mrIP( 0 ),
  mrPort( 0 ),
  mRecvBuf( nullptr )
{
}

TCPConnection::~TCPConnection ( )

virtual

Cleans connection up.

Definition at line 59 of file TCPConnection.cpp.

References _log, ClearBuffers(), Disconnect(), and WaitLoop().

{
    _log(THREAD__WARNING, "Destroying TCPConnection for thread 0x%X", pthread_self());
    // Make sure we are disconnected
    Disconnect();
    // Wait for loop to stop
    WaitLoop();
    // Clear buffers
    ClearBuffers();
}

Here is the call graph for this function:

TCPConnection::TCPConnection ( Socket *  sock, uint32  rIP, uint16  rPort  )

protected

Creates connection from an existing socket.

Parameters

[in]	sock	Socket to be used for connection.
[in]	rIP	Remote IP socket is connected to.
[in]	rPort	Remote TCP port socket is connected to.

Definition at line 48 of file TCPConnection.cpp.

References StartLoop().

: mSock( socket ),
  mSockState( STATE_CONNECTED ),
  mrIP( mrIP ),
  mrPort( mrPort ),
  mRecvBuf( nullptr )
{
    // Start worker thread
    StartLoop();
}

Here is the call graph for this function:

Member Function Documentation

void TCPConnection::AsyncConnect	(	uint32	rIP,
		uint16	rPort
	)

Schedules asynchronous connect to specified address.

This function does asynchronous connect, ie. does not block calling thread at all. However, result of connect is not known immediately.

Parameters

[in]	rIP	Target remote IP address.
[in]	rPort	Target remote TCP port.

Definition at line 134 of file TCPConnection.cpp.

References GetState(), Mutex::Lock(), mMSock, mrIP, mrPort, mSockState, StartLoop(), STATE_CONNECTING, STATE_DISCONNECTED, Mutex::Unlock(), and WaitLoop().

{
    // Changing state; acquire mutex
    MutexLock lock( mMSock );

    if (GetState() == STATE_DISCONNECTED) {
        mMSock.Unlock();
        // Wait for working thread to stop.
        WaitLoop();
        mMSock.Lock();
    }

    if (GetState() != STATE_DISCONNECTED)
        return;

    mrIP = rIP;
    mrPort = rPort;
    mSockState = STATE_CONNECTING;
    // Start processing thread
    StartLoop();
}

Here is the call graph for this function:

void TCPConnection::ClearBuffers ( )

protectedvirtual

Clears send and receive buffers.

Reimplemented in EVETCPConnection.

Definition at line 365 of file TCPConnection.cpp.

References mMSendQueue, mRecvBuf, mSendQueue, and SafeDelete().

Referenced by EVETCPConnection::ClearBuffers(), DoDisconnect(), and ~TCPConnection().

{
    MutexLock lock( mMSendQueue );

    Buffer* buf = nullptr;
    while (!mSendQueue.empty()) {
        buf = mSendQueue.front();
        mSendQueue.pop_front();
        SafeDelete(buf);
    }
    SafeDelete(mRecvBuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool TCPConnection::Connect	(	uint32	rIP,
		uint16	rPort,
		char *	errbuf = 0
	)

Connects to specified address.

This function does synchronous connect, ie. blocks calling thread until connect either succeeds or fails. Benefit is that outcome of connect is known immediately.

Parameters

[in]	rIP	Target remote IP address.
[in]	rPort	Target remote TCP port.
[out]	errbuf	String buffer which receives error desription.

Returns

True if connection succeeds, false if not.

Definition at line 86 of file TCPConnection.cpp.

References Socket::connect(), Socket::fcntl(), GetState(), Mutex::Lock(), mMSock, mrIP, mrPort, mSock, mSockState, SafeDelete(), Socket::setopt(), snprintf, SOCKET_ERROR, StartLoop(), STATE_CONNECTED, STATE_CONNECTING, STATE_DISCONNECTED, TCPCONN_ERRBUF_SIZE, Mutex::Unlock(), and WaitLoop().

Referenced by Process().

{
    if (errbuf)
        errbuf[0] = 0;

    MutexLock lock( mMSock );

    if (GetState() == STATE_DISCONNECTED) {
        mMSock.Unlock();
        // Wait for working thread to stop.
        WaitLoop();
        mMSock.Lock();
    }

    state_t oldState = GetState();
    if (oldState != STATE_DISCONNECTED && oldState != STATE_CONNECTING)
        return false;

    mSock = new Socket( AF_INET, SOCK_STREAM, 0 );

    sockaddr_in server_sin;
    server_sin.sin_family = AF_INET;
    server_sin.sin_addr.s_addr = rIP;
    server_sin.sin_port = htons( rPort );

    // Establish a connection to the server socket.
    if( mSock->connect( (sockaddr*)&server_sin, sizeof( server_sin ) ) == SOCKET_ERROR )
    {
        if( errbuf )
            snprintf( errbuf, TCPCONN_ERRBUF_SIZE, "%s", strerror( errno ) );

        SafeDelete( mSock );
        return false;
    }

    int bufsize = 64 * 1024; // 64kbyte recieve buffer, up from default of 8k
    mSock->setopt( SOL_SOCKET, SO_RCVBUF, (char*) &bufsize, sizeof( bufsize ) );
    mSock->fcntl( F_SETFL, O_NONBLOCK );
    mrIP = rIP;
    mrPort = rPort;
    mSockState = STATE_CONNECTED;
    // Start processing thread if necessary
    if( oldState == STATE_DISCONNECTED )
        StartLoop();

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TCPConnection::Disconnect

(

)

Schedules disconnect of current connection.

Connection will be closed as soon as possible. Note that this may take some time since we wait for emptying send queue before actually disconnecting.

Definition at line 156 of file TCPConnection.cpp.

References GetState(), mMSock, mSockState, state, STATE_CONNECTED, STATE_CONNECTING, and STATE_DISCONNECTING.

Referenced by EVEClientSession::CloseClientConnection(), and ~TCPConnection().

{
    MutexLock lock( mMSock );

    state_t state = GetState();
    if( state != STATE_CONNECTING && state != STATE_CONNECTED )
        return;

    // Change state
    mSockState = STATE_DISCONNECTING;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TCPConnection::DoDisconnect ( )

protected

Disconnects socket.

Definition at line 350 of file TCPConnection.cpp.

References ClearBuffers(), GetState(), mMSock, mrIP, mrPort, mSock, mSockState, SafeDelete(), state, STATE_CONNECTED, STATE_DISCONNECTED, and STATE_DISCONNECTING.

Referenced by Process(), and TCPConnectionLoop().

{
    MutexLock lock( mMSock );

    state_t state = GetState();
    if ((state != STATE_CONNECTED) && (state != STATE_DISCONNECTING))
        return;

    ClearBuffers();
    mrIP = mrPort = 0;
    SafeDelete( mSock );

    mSockState = STATE_DISCONNECTED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string TCPConnection::GetAddress

(

)

Returns

String in format "<remote_address>:<remote_port>".

Note

It's kinda slow this way.

Definition at line 70 of file TCPConnection.cpp.

References GetrIP(), GetrPort(), and snprintf.

Referenced by EVEClientSession::GetAddress(), and Process().

{
    /* "The Matrix is a system, Neo. That system is our enemy. But when you're inside, you look around, what do you see?" */
    in_addr addr;
    addr.s_addr = GetrIP();

    char address[22];
    int len = snprintf( address, 22, "%s:%u", inet_ntoa( addr ), GetrPort() );

    /* snprintf will return < 0 when a error occurs so return empty string */
    if( len < 0 )
        return std::string();

    return address;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 TCPConnection::GetrIP ( ) const

inline

Returns

Remote IP.

Definition at line 67 of file TCPConnection.h.

References mrIP.

Referenced by GetAddress(), and Process().

{ return mrIP; }

Here is the caller graph for this function:

uint16 TCPConnection::GetrPort ( ) const

inline

Returns

Remote port.

Definition at line 69 of file TCPConnection.h.

References mrPort.

Referenced by GetAddress(), and Process().

{ return mrPort; }

Here is the caller graph for this function:

state_t TCPConnection::GetState ( ) const

inline

Returns

Current state of connection.

Definition at line 77 of file TCPConnection.h.

References mSockState.

Referenced by AsyncConnect(), Connect(), Disconnect(), DoDisconnect(), EVEClientSession::GetState(), Process(), RecvData(), Send(), and SendData().

{ return mSockState; }

Here is the caller graph for this function:

bool TCPConnection::Process ( )

protectedvirtual

Does all stuff that needs to be periodically done to keep connection alive.

Returns

True if connection should be further processed, false if not (eg. error, disconnected).

Definition at line 215 of file TCPConnection.cpp.

References _log, Connect(), DoDisconnect(), GetAddress(), GetrIP(), GetrPort(), GetState(), mMSock, RecvData(), SendData(), STATE_CONNECTED, STATE_CONNECTING, STATE_DISCONNECTED, STATE_DISCONNECTING, and TCPCONN_ERRBUF_SIZE.

Referenced by TCPConnectionLoop().

                            {
    char errbuf[ TCPCONN_ERRBUF_SIZE ];
    MutexLock lock( mMSock );
    switch (GetState()) {
        case STATE_CONNECTING: {
            if (!Connect( GetrIP(), GetrPort(), errbuf)) {
                _log(TCP_CLIENT__TRACE, "Process() - Connecting Failed at %s: %s", GetAddress().c_str(), errbuf );
                return false;
            }
            _log(TCP_CLIENT__INFO, "Process() - TCP connectection from %s", GetAddress().c_str() );
            return true;
        }
        case STATE_CONNECTED: {
            if (!RecvData(errbuf)) {
                _log(TCP_CLIENT__TRACE, "Process() - Connected RecvData() Failed at %s: %s", GetAddress().c_str(), errbuf );
                return false;
            }
            if (!SendData(errbuf)) {
                _log(TCP_CLIENT__TRACE, "Process() - Connected SendData() Failed at", "%s: %s", GetAddress().c_str(), errbuf );
                return false;
            }
            return true;
        }
        case STATE_DISCONNECTING: {
            if (!SendData(errbuf)) {
                _log(TCP_CLIENT__TRACE, "Process() - Disconnecting SendData() Failed at", "%s: %s", GetAddress().c_str(), errbuf );
                return false;
            }
            DoDisconnect();
            return true;
        }
        case STATE_DISCONNECTED:
        default: {
            return false;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual bool TCPConnection::ProcessReceivedData ( char *  errbuf = 0 )

protectedpure virtual

Processes received data.

This function must be overloaded by children to process received data. Called every time a chunk of new data is received. Please note that receive buffer is overwritten every time data is received.

Parameters

[out]

errbuf

Buffer which receives description of error.

Returns

True if processing ran fine, false if not.

Implemented in EVETCPConnection.

Referenced by RecvData().

Here is the caller graph for this function:

bool TCPConnection::RecvData ( char *  errbuf = 0 )

protectedvirtual

Receives data and puts them into receive queue.

Parameters

[out]

errbuf

Buffer which receives description of error.

Returns

True if receive was OK, false if not.

Reimplemented in EVETCPConnection.

Definition at line 307 of file TCPConnection.cpp.

References _log, GetState(), mMSock, mRecvBuf, mSock, ProcessReceivedData(), Socket::recv(), Buffer::Resize(), Buffer::size(), snprintf, SOCKET_ERROR, state, STATE_CONNECTED, STATE_DISCONNECTING, TCPCONN_ERRBUF_SIZE, and TCPCONN_RECVBUF_SIZE.

Referenced by Process(), and EVETCPConnection::RecvData().

{
    if (errbuf)
        errbuf[0] = 0;

    MutexLock lock( mMSock );

    state_t state = GetState();
    if ((state != STATE_CONNECTED) && (state != STATE_DISCONNECTING))
        return false;

    int status = 0;
    while (true) {
        if (!mRecvBuf)
            mRecvBuf = new Buffer( TCPCONN_RECVBUF_SIZE );
        else if( mRecvBuf->size() < TCPCONN_RECVBUF_SIZE )
            mRecvBuf->Resize<uint8>( TCPCONN_RECVBUF_SIZE );

        status = mSock->recv( &(*mRecvBuf)[ 0 ], (uint)mRecvBuf->size(), MSG_DONTWAIT);
        if (status == SOCKET_ERROR) {
            if (errno == EWOULDBLOCK)
                return true;
            if (errbuf)
                snprintf( errbuf, TCPCONN_ERRBUF_SIZE, "%s", strerror(errno));
            return false;
        } else if (status == 0) {
            if (errbuf)
                snprintf( errbuf, TCPCONN_ERRBUF_SIZE, "No Data Received.");
            return false;
        } else if (status) {
            mRecvBuf->Resize<uint8>(status);
            if (!ProcessReceivedData(errbuf))
                return false;
        } else {
            if (errbuf)
                snprintf( errbuf, TCPCONN_ERRBUF_SIZE, "recv() returned unknown status");
            _log(TCP_CLIENT__ERROR, "TCPConnection::RecvData(): Error: recv() returned unknown status");
            return false;
        }
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool TCPConnection::Send

(

Buffer **

data

)

Enqueues data to be sent.

Parameters

[in]

data

Buffer with data; pointer is invalidated by the function.

Returns

True if data has been accepted, false if not.

Definition at line 168 of file TCPConnection.cpp.

References GetState(), mMSendQueue, mMSock, mSendQueue, SafeDelete(), and STATE_CONNECTED.

Referenced by EVETCPConnection::QueueRep().

{
    // Invalidate pointer
    Buffer* buf = *data;
    *data = nullptr;

    // Check we are in STATE_CONNECTED
    MutexLock sockLock( mMSock );

    if (GetState() != STATE_CONNECTED) {
        SafeDelete( buf );
        return false;
    }

    // Push buffer to the send queue
    MutexLock queueLock( mMSendQueue );

    mSendQueue.push_back( buf );
    buf = nullptr;

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool TCPConnection::SendData ( char *  errbuf = 0 )

protectedvirtual

Sends data in send queue.

Parameters

[out]

errbuf

Buffer which receives desription of error.

Returns

True if send was OK, false if not.

Definition at line 253 of file TCPConnection.cpp.

References Buffer::AssignSeq(), Buffer::begin(), Buffer::end(), GetState(), Mutex::Lock(), mMSendQueue, mMSock, mSendQueue, MSG_NOSIGNAL, mSock, SafeDelete(), Socket::send(), Buffer::size(), snprintf, SOCKET_ERROR, state, STATE_CONNECTED, STATE_DISCONNECTING, TCPCONN_ERRBUF_SIZE, and Mutex::Unlock().

Referenced by Process().

{
    if( errbuf )
    errbuf[0] = 0;

    MutexLock lock( mMSock );

    state_t state = GetState();
    if( state != STATE_CONNECTED && state != STATE_DISCONNECTING )
        return false;

    mMSendQueue.Lock();
    Buffer* buf(nullptr);
    int status(0);
    while (!mSendQueue.empty()) {
        buf = mSendQueue.front();
        mSendQueue.pop_front();
        mMSendQueue.Unlock();
        if (mSendQueue.empty())
            status = mSock->send( &(*buf)[ 0 ], (uint)buf->size(), MSG_NOSIGNAL);
        else
            status = mSock->send( &(*buf)[ 0 ], (uint)buf->size(), (MSG_NOSIGNAL | MSG_MORE) );
        if (status == SOCKET_ERROR) {
            if (errno == EWOULDBLOCK) {
                status = 0;
            } else {
                if( errbuf )
                    snprintf( errbuf, TCPCONN_ERRBUF_SIZE, "%s", strerror( errno ) );
                SafeDelete( buf );
                return false;
            }
        }

        if ((size_t)status > buf->size()) {
            if (errbuf)
                snprintf( errbuf, TCPCONN_ERRBUF_SIZE, "WTF?!?   status > size." );

            SafeDelete( buf );
            return false;
        } else if ((size_t)status < buf->size()) {
            if (status > 0)
                buf->AssignSeq( buf->begin<uint8>() + status, buf->end<uint8>() );
            MutexLock queueLock( mMSendQueue );
            mSendQueue.push_front( buf );
            buf = nullptr;
        } else {
            SafeDelete( buf );
        }
        mMSendQueue.Lock();
    }
    mMSendQueue.Unlock();
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TCPConnection::StartLoop ( )

protected

Starts working thread.

This function just starts a thread, does not check whether there is already one running!

Note

update this to use thread pool instead of creating new threads. check with sThread.XXXX() for avalible thread from current thread pool. if one is avalible, it will be used, and if not, sThread will create a new one

Definition at line 191 of file TCPConnection.cpp.

References sThread, and TCPConnectionLoop().

Referenced by AsyncConnect(), Connect(), and TCPConnection().

{
    sThread.CreateThread(TCPConnectionLoop, this);
    /*   ORIGINAL CODE HERE
    // Spawn new thread
    pthread_t thread;
    pthread_create( &thread, nullptr, TCPConnectionLoop, this );
    _log(THREAD__WARNING, "StartLoop() - Created thread ID 0x%X for TCPConnectionLoop", thread);
    sThread.AddThread(thread);*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

void * TCPConnection::TCPConnectionLoop ( void *  arg )

staticprotected

Loop for worker threads.

This function just casts given arg into TCPConnection and calls member TCPConnectionLoop.

Parameters

[in]

arg

Pointer to TCPConnection.

Definition at line 378 of file TCPConnection.cpp.

References sThread, and TCPConnectionLoop().

Referenced by TCPConnectionLoop().

{
    TCPConnection* tcpc = reinterpret_cast< TCPConnection* >( arg );
    assert( tcpc != nullptr );

    tcpc->TCPConnectionLoop();
    sThread.RemoveThread(pthread_self());

    return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TCPConnection::TCPConnectionLoop ( )

protected

Loop for worker threads.

Definition at line 389 of file TCPConnection.cpp.

References DoDisconnect(), GetTickCount(), Mutex::Lock(), mMLoopRunning, Process(), Sleep(), TCPCONN_LOOP_GRANULARITY, and Mutex::Unlock().

Referenced by StartLoop().

{
    mMLoopRunning.Lock();
    uint32 start = GetTickCount();
    while (Process()) {
        // do the stuff for thread sleeping
        start = GetTickCount() - start;
        if (TCPCONN_LOOP_GRANULARITY > start)
            Sleep(TCPCONN_LOOP_GRANULARITY - start);
        start = GetTickCount();
    }
    DoDisconnect();
    mMLoopRunning.Unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TCPConnection::WaitLoop ( )

protected

Blocks calling thread until working thread terminates.

Definition at line 206 of file TCPConnection.cpp.

References Mutex::Lock(), mMLoopRunning, and Mutex::Unlock().

Referenced by AsyncConnect(), Connect(), and ~TCPConnection().

{
    // Block calling thread until work thread terminates
    mMLoopRunning.Lock();
    mMLoopRunning.Unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Mutex TCPConnection::mMLoopRunning

mutableprotected

When a thread is running TCPConnectionLoop, it acquires this mutex first; used for synchronization.

Definition at line 215 of file TCPConnection.h.

Referenced by TCPConnectionLoop(), and WaitLoop().

Mutex TCPConnection::mMSendQueue

mutableprotected

Mutex protecting send queue.

Definition at line 218 of file TCPConnection.h.

Referenced by ClearBuffers(), Send(), and SendData().

Mutex TCPConnection::mMSock

mutableprotected

Protection of socket and associated variables.

Definition at line 204 of file TCPConnection.h.

Referenced by AsyncConnect(), Connect(), Disconnect(), DoDisconnect(), Process(), RecvData(), Send(), and SendData().

Buffer* TCPConnection::mRecvBuf

protected

Receive buffer.

Definition at line 223 of file TCPConnection.h.

Referenced by ClearBuffers(), EVETCPConnection::ProcessReceivedData(), and RecvData().

uint32 TCPConnection::mrIP

protected

Remote IP the socket is connected to.

Definition at line 210 of file TCPConnection.h.

Referenced by AsyncConnect(), Connect(), DoDisconnect(), and GetrIP().

uint16 TCPConnection::mrPort

protected

Remote TCP port the socket is connected to; is in host byte order.

Definition at line 212 of file TCPConnection.h.

Referenced by AsyncConnect(), Connect(), DoDisconnect(), and GetrPort().

std::deque<Buffer*> TCPConnection::mSendQueue

protected

Send queue.

Definition at line 220 of file TCPConnection.h.

Referenced by ClearBuffers(), Send(), and SendData().

Socket* TCPConnection::mSock

protected

Socket for connection.

Definition at line 206 of file TCPConnection.h.

Referenced by Connect(), DoDisconnect(), RecvData(), and SendData().

state_t TCPConnection::mSockState

protected

State the socket is in.

Definition at line 208 of file TCPConnection.h.

Referenced by AsyncConnect(), Connect(), Disconnect(), DoDisconnect(), and GetState().

---

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

• /backups/local/src/eve/EvEmu_Crucible/src/eve-core/network/TCPConnection.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-core/network/TCPConnection.cpp