Core/NetworkIO: Allow receiving packets bigger than buffer size and properly handle situations where not entire packet was read in one go

Core/Authserver: Restored authenticator functionality
This commit is contained in:
Shauren committed 2014-08-10 11:00:27 +02:00
1 parent 91053d557c
commit df11916ad5
9 files changed
+289 -149

No files matched your search

+95 -24
View File
@@ -18,7 +18,7 @@
#ifndef __SOCKET_H__
#define __SOCKET_H__
#include "Define.h"
#include "MessageBuffer.h"
#include "Log.h"
#include <vector>
#include <mutex>
@@ -28,19 +28,23 @@
#include <type_traits>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/write.hpp>
#include <boost/asio/read.hpp>
using boost::asio::ip::tcp;
#define READ_BLOCK_SIZE 4096
template<class T, class PacketType>
class Socket : public std::enable_shared_from_this<T>
{
typedef typename std::conditional<std::is_pointer<PacketType>::value, PacketType, PacketType const&>::type WritePacketType;
public:
Socket(tcp::socket&& socket, std::size_t headerSize) : _socket(std::move(socket)), _headerSize(headerSize)
Socket(tcp::socket&& socket, std::size_t headerSize) : _socket(std::move(socket))
{
_remotePort = _socket.remote_endpoint().port();
_remoteAddress = _socket.remote_endpoint().address();
_remotePort = _socket.remote_endpoint().port();
_readHeaderBuffer.Grow(headerSize);
}
virtual void Start() = 0;
@@ -57,25 +61,39 @@ public:
void AsyncReadHeader()
{
_socket.async_read_some(boost::asio::buffer(_readBuffer, _headerSize), std::bind(&Socket<T, PacketType>::ReadHeaderHandlerInternal, this->shared_from_this(),
std::placeholders::_1, std::placeholders::_2));
_readHeaderBuffer.ResetWritePointer();
_readDataBuffer.Reset();
AsyncReadMissingHeaderData();
}
void AsyncReadData(std::size_t size, std::size_t bufferOffset)
void AsyncReadData(std::size_t size)
{
_socket.async_read_some(boost::asio::buffer(&_readBuffer[bufferOffset], size), std::bind(&Socket<T, PacketType>::ReadDataHandlerInternal, this->shared_from_this(),
std::placeholders::_1, std::placeholders::_2));
if (!size)
{
// if this is a packet with 0 length body just invoke handler directly
ReadDataHandler();
return;
}
_readDataBuffer.Grow(size);
AsyncReadMissingData();
}
void ReadData(std::size_t size, std::size_t bufferOffset)
void ReadData(std::size_t size)
{
boost::system::error_code error;
_socket.read_some(boost::asio::buffer(&_readBuffer[bufferOffset], size), error);
_readDataBuffer.Grow(size);
if (error)
std::size_t bytesRead = boost::asio::read(_socket, boost::asio::buffer(_readDataBuffer.GetWritePointer(), size), error);
_readDataBuffer.WriteCompleted(bytesRead);
if (error || !_readDataBuffer.IsMessageReady())
{
TC_LOG_DEBUG("network", "Socket::ReadData: %s errored with: %i (%s)", GetRemoteIpAddress().to_string().c_str(), error.value(), error.message().c_str());
TC_LOG_DEBUG("network", "Socket::ReadData: %s errored with: %i (%s)", GetRemoteIpAddress().to_string().c_str(), error.value(),
error.message().c_str());
CloseSocket();
}
@@ -83,8 +101,8 @@ public:
void AsyncWrite(WritePacketType data)
{
boost::asio::async_write(_socket, boost::asio::buffer(data), std::bind(&Socket<T, PacketType>::WriteHandler, this->shared_from_this(), std::placeholders::_1,
std::placeholders::_2));
boost::asio::async_write(_socket, boost::asio::buffer(data), std::bind(&Socket<T, PacketType>::WriteHandler, this->shared_from_this(),
std::placeholders::_1, std::placeholders::_2));
}
bool IsOpen() const { return _socket.is_open(); }
@@ -94,7 +112,7 @@ public:
_socket.shutdown(boost::asio::socket_base::shutdown_both, 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());
shutdownError.value(), shutdownError.message().c_str());
boost::system::error_code error;
_socket.close(error);
@@ -103,18 +121,72 @@ public:
error.value(), error.message().c_str());
}
uint8* GetReadBuffer() { return _readBuffer; }
virtual bool IsHeaderReady() const { return _readHeaderBuffer.IsMessageReady(); }
virtual bool IsDataReady() const { return _readDataBuffer.IsMessageReady(); }
uint8* GetHeaderBuffer() { return _readHeaderBuffer.Data(); }
uint8* GetDataBuffer() { return _readDataBuffer.Data(); }
MessageBuffer&& MoveHeader() { return std::move(_readHeaderBuffer); }
MessageBuffer&& MoveData() { return std::move(_readDataBuffer); }
protected:
virtual void ReadHeaderHandler(boost::system::error_code error, size_t transferedBytes) = 0;
virtual void ReadDataHandler(boost::system::error_code error, size_t transferedBytes) = 0;
virtual void ReadHeaderHandler() = 0;
virtual void ReadDataHandler() = 0;
std::mutex _writeLock;
std::queue<PacketType> _writeQueue;
private:
void ReadHeaderHandlerInternal(boost::system::error_code error, size_t transferedBytes) { ReadHeaderHandler(error, transferedBytes); }
void ReadDataHandlerInternal(boost::system::error_code error, size_t transferedBytes) { ReadDataHandler(error, transferedBytes); }
void AsyncReadMissingHeaderData()
{
_socket.async_read_some(boost::asio::buffer(_readHeaderBuffer.GetWritePointer(), std::min<std::size_t>(READ_BLOCK_SIZE, _readHeaderBuffer.GetMissingSize())),
std::bind(&Socket<T, PacketType>::ReadHeaderHandlerInternal, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
}
void AsyncReadMissingData()
{
_socket.async_read_some(boost::asio::buffer(_readDataBuffer.GetWritePointer(), std::min<std::size_t>(READ_BLOCK_SIZE, _readDataBuffer.GetMissingSize())),
std::bind(&Socket<T, PacketType>::ReadDataHandlerInternal, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
}
void ReadHeaderHandlerInternal(boost::system::error_code error, size_t transferredBytes)
{
if (error)
{
CloseSocket();
return;
}
_readHeaderBuffer.WriteCompleted(transferredBytes);
if (!IsHeaderReady())
{
// incomplete, read more
AsyncReadMissingHeaderData();
return;
}
ReadHeaderHandler();
}
void ReadDataHandlerInternal(boost::system::error_code error, size_t transferredBytes)
{
if (error)
{
CloseSocket();
return;
}
_readDataBuffer.WriteCompleted(transferredBytes);
if (!IsDataReady())
{
// incomplete, read more
AsyncReadMissingData();
return;
}
ReadDataHandler();
}
void WriteHandler(boost::system::error_code error, size_t /*transferedBytes*/)
{
@@ -140,12 +212,11 @@ private:
tcp::socket _socket;
uint8 _readBuffer[4096];
uint16 _remotePort;
boost::asio::ip::address _remoteAddress;
uint16 _remotePort;
std::size_t _headerSize;
MessageBuffer _readHeaderBuffer;
MessageBuffer _readDataBuffer;
};
#endif // __SOCKET_H__