Socket< T, Stream > Class Template Reference

#include <Socket.h>

Public Member Functions
	Socket (tcp::socket &&socket)
virtual	~Socket ()
virtual void	Start ()=0
virtual bool	Update ()
boost::asio::ip::address	GetRemoteIpAddress () const
uint16	GetRemotePort () const
void	AsyncRead ()
void	AsyncReadWithCallback (void(T::*callback)(boost::system::error_code, std::size_t))
void	QueuePacket (MessageBuffer &&buffer)
bool	IsOpen () const
void	CloseSocket ()
void	DelayedCloseSocket ()
	Marks the socket for closing after write buffer becomes empty. More...
MessageBuffer &	GetReadBuffer ()

Protected Member Functions
virtual void	OnClose ()
virtual void	ReadHandler ()=0
bool	AsyncProcessQueue ()
void	SetNoDelay (bool enable)
Stream &	underlying_stream ()

Private Member Functions
void	ReadHandlerInternal (boost::system::error_code error, size_t transferredBytes)
void	WriteHandlerWrapper (boost::system::error_code, std::size_t)
bool	HandleQueue ()

Private Attributes
Stream	_socket
boost::asio::ip::address	_remoteAddress
uint16	_remotePort
MessageBuffer	_readBuffer
std::queue< MessageBuffer >	_writeQueue
std::atomic< bool >	_closed
std::atomic< bool >	_closing
bool	_isWritingAsync

Detailed Description

template<class T, class Stream = tcp::socket>
class Socket< T, Stream >

Base async socket implementation

Template Parameters

T	derived class type (CRTP)
Stream	stream type used for operations on socket Stream must implement the following methods:

void close(boost::system::error_code& error);

void shutdown(boost::asio::socket_base::shutdown_type what, boost::system::error_code& shutdownError);

template<typename MutableBufferSequence, typename ReadHandlerType> void async_read_some(MutableBufferSequence const& buffers, ReadHandlerType&& handler);

template<typename ConstBufferSequence, typename WriteHandlerType> void async_write_some(ConstBufferSequence const& buffers, WriteHandlerType&& handler);

template<typename ConstBufferSequence> std::size_t write_some(ConstBufferSequence const& buffers, boost::system::error_code& error);

template<typename SettableSocketOption> void set_option(SettableSocketOption const& option, boost::system::error_code& error);

tcp::socket::endpoint_type remote_endpoint() const;

Constructor & Destructor Documentation

template<class T, class Stream = tcp::socket>

Socket< T, Stream >::Socket ( tcp::socket &&  socket )

inlineexplicit

 : _socket(std::move(socket)), _remoteAddress(_socket.remote_endpoint().address()),
 _remotePort(_socket.remote_endpoint().port()), _readBuffer(), _closed(false), _closing(false), _isWritingAsync(false)
 {
 _readBuffer.Resize(READ_BLOCK_SIZE);
 }

template<class T, class Stream = tcp::socket>

virtual Socket< T, Stream >::~Socket ( )

inlinevirtual

 {
 _closed = true;
 boost::system::error_code error;
 _socket.close(error);
 }

Member Function Documentation

template<class T, class Stream = tcp::socket>

bool Socket< T, Stream >::AsyncProcessQueue ( )

inlineprotected

 {
 if (_isWritingAsync)
 return false;

 _isWritingAsync = true;

#ifdef TC_SOCKET_USE_IOCP
 MessageBuffer& buffer = _writeQueue.front();
 _socket.async_write_some(boost::asio::buffer(buffer.GetReadPointer(), buffer.GetActiveSize()), std::bind(&Socket<T, Stream>::WriteHandler,
 this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
#else
 _socket.async_write_some(boost::asio::null_buffers(), std::bind(&Socket<T, Stream>::WriteHandlerWrapper,
 this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
#endif

 return false;
 }

Here is the caller graph for this function:

template<class T, class Stream = tcp::socket>

void Socket< T, Stream >::AsyncRead ( )

inline

 {
 if (!IsOpen())
 return;

 _readBuffer.Normalize();
 _readBuffer.EnsureFreeSpace();
 _socket.async_read_some(boost::asio::buffer(_readBuffer.GetWritePointer(), _readBuffer.GetRemainingSpace()),
 std::bind(&Socket<T, Stream>::ReadHandlerInternal, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
 }

template<class T, class Stream = tcp::socket>

void Socket< T, Stream >::AsyncReadWithCallback ( void(T::*)(boost::system::error_code, std::size_t)  callback )

inline

 {
 if (!IsOpen())
 return;

 _readBuffer.Normalize();
 _readBuffer.EnsureFreeSpace();
 _socket.async_read_some(boost::asio::buffer(_readBuffer.GetWritePointer(), _readBuffer.GetRemainingSpace()),
 std::bind(callback, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
 }

template<class T, class Stream = tcp::socket>

void Socket< T, Stream >::CloseSocket ( )

inline

 {
 if (_closed.exchange(true))
 return;

 boost::system::error_code shutdownError;
 _socket.shutdown(boost::asio::socket_base::shutdown_send, shutdownError);
 if (shutdownError)
 TC_LOG_DEBUG("network", "Socket::CloseSocket: %s errored when shutting down socket: %i (%s)", GetRemoteIpAddress().to_string().c_str(),
 shutdownError.value(), shutdownError.message().c_str());

 OnClose();
 }

Here is the caller graph for this function:

template<class T, class Stream = tcp::socket>

void Socket< T, Stream >::DelayedCloseSocket ( )

inline

Marks the socket for closing after write buffer becomes empty.

{ _closing = true; }

template<class T, class Stream = tcp::socket>

MessageBuffer& Socket< T, Stream >::GetReadBuffer ( )

inline

{ return _readBuffer; }

template<class T, class Stream = tcp::socket>

boost::asio::ip::address Socket< T, Stream >::GetRemoteIpAddress ( ) const

inline

 {
 return _remoteAddress;
 }

Here is the caller graph for this function:

template<class T, class Stream = tcp::socket>

uint16 Socket< T, Stream >::GetRemotePort ( ) const

inline

 {
 return _remotePort;
 }

template<class T, class Stream = tcp::socket>

bool Socket< T, Stream >::HandleQueue ( )

inlineprivate

 {
 if (_writeQueue.empty())
 return false;

 MessageBuffer& queuedMessage = _writeQueue.front();

 std::size_t bytesToSend = queuedMessage.GetActiveSize();

 boost::system::error_code error;
 std::size_t bytesSent = _socket.write_some(boost::asio::buffer(queuedMessage.GetReadPointer(), bytesToSend), error);

 if (error)
 {
 if (error == boost::asio::error::would_block || error == boost::asio::error::try_again)
 return AsyncProcessQueue();

 _writeQueue.pop();
 if (_closing && _writeQueue.empty())
 CloseSocket();
 return false;
 }
 else if (bytesSent == 0)
 {
 _writeQueue.pop();
 if (_closing && _writeQueue.empty())
 CloseSocket();
 return false;
 }
 else if (bytesSent < bytesToSend) // now n > 0
 {
 queuedMessage.ReadCompleted(bytesSent);
 return AsyncProcessQueue();
 }

 _writeQueue.pop();
 if (_closing && _writeQueue.empty())
 CloseSocket();
 return !_writeQueue.empty();
 }

Here is the caller graph for this function:

template<class T, class Stream = tcp::socket>

bool Socket< T, Stream >::IsOpen ( ) const

inline

{ return !_closed && !_closing; }

Here is the caller graph for this function:

template<class T, class Stream = tcp::socket>

virtual void Socket< T, Stream >::OnClose ( )

inlineprotectedvirtual

Reimplemented in WorldSocket.

{ }

Here is the caller graph for this function:

template<class T, class Stream = tcp::socket>

void Socket< T, Stream >::QueuePacket ( MessageBuffer &&  buffer )

inline

 {
 _writeQueue.push(std::move(buffer));

#ifdef TC_SOCKET_USE_IOCP
 AsyncProcessQueue();
#endif
 }

template<class T, class Stream = tcp::socket>

virtual void Socket< T, Stream >::ReadHandler ( )

protectedpure virtual

Implemented in Battlenet::Session, and WorldSocket.

Here is the caller graph for this function:

template<class T, class Stream = tcp::socket>

void Socket< T, Stream >::ReadHandlerInternal ( boost::system::error_code  error, size_t  transferredBytes  )

inlineprivate

 {
 if (error)
 {
 CloseSocket();
 return;
 }

 _readBuffer.WriteCompleted(transferredBytes);
 ReadHandler();
 }

template<class T, class Stream = tcp::socket>

void Socket< T, Stream >::SetNoDelay ( bool  enable )

inlineprotected

 {
 boost::system::error_code err;
 _socket.set_option(tcp::no_delay(enable), err);
 if (err)
 TC_LOG_DEBUG("network", "Socket::SetNoDelay: failed to set_option(boost::asio::ip::tcp::no_delay) for %s - %d (%s)",
 GetRemoteIpAddress().to_string().c_str(), err.value(), err.message().c_str());
 }

template<class T, class Stream = tcp::socket>

virtual void Socket< T, Stream >::Start ( )

pure virtual

Implemented in Battlenet::Session, and WorldSocket.

template<class T, class Stream = tcp::socket>

Stream& Socket< T, Stream >::underlying_stream ( )

inlineprotected

 {
 return _socket;
 }

template<class T, class Stream = tcp::socket>

virtual bool Socket< T, Stream >::Update ( )

inlinevirtual

Reimplemented in Battlenet::Session, and WorldSocket.

 {
 if (_closed)
 return false;

#ifndef TC_SOCKET_USE_IOCP
 if (_isWritingAsync || (_writeQueue.empty() && !_closing))
 return true;

 for (; HandleQueue();)
 ;
#endif

 return true;
 }

template<class T, class Stream = tcp::socket>

void Socket< T, Stream >::WriteHandlerWrapper ( boost::system::error_code  , std::size_t    )

inlineprivate

 {
 _isWritingAsync = false;
 HandleQueue();
 }

Member Data Documentation

template<class T, class Stream = tcp::socket>

std::atomic<bool> Socket< T, Stream >::_closed

private

template<class T, class Stream = tcp::socket>

std::atomic<bool> Socket< T, Stream >::_closing

private

template<class T, class Stream = tcp::socket>

bool Socket< T, Stream >::_isWritingAsync

private

template<class T, class Stream = tcp::socket>

MessageBuffer Socket< T, Stream >::_readBuffer

private

template<class T, class Stream = tcp::socket>

boost::asio::ip::address Socket< T, Stream >::_remoteAddress

private

template<class T, class Stream = tcp::socket>

uint16 Socket< T, Stream >::_remotePort

private

template<class T, class Stream = tcp::socket>

Stream Socket< T, Stream >::_socket

private

template<class T, class Stream = tcp::socket>

std::queue<MessageBuffer> Socket< T, Stream >::_writeQueue

private

---

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

• src/server/shared/Networking/Socket.h