Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-15 23:20:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/Network: Socket refactors

Browse Source 
* Devirtualize calls to Read and Update by marking concrete implementations as final
* Removed derived class template argument
* Specialize boost::asio::basic_stream_socket for boost::asio::io_context instead of type-erased any_io_executor
* Make socket initialization easier composable (before entering Read loop)
* Remove use of deprecated boost::asio::null_buffers and boost::beast::ssl_stream
This commit is contained in:
Shauren
2025-04-08 19:15:16 +02:00
parent 40d80f3476
commit e8b2be3527
32 changed files with 967 additions and 811 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/common/Utilities/Containers.h
View File

@@ -259,7 +259,7 @@ namespace Trinity
if (!p(*rpos))
{
if (rpos != wpos)
std::swap(*rpos, *wpos);
std::ranges::swap(*rpos, *wpos);
++wpos;
}
}

171
src/server/bnetserver/REST/LoginHttpSession.cpp
View File

@@ -17,126 +17,117 @@
#include "LoginHttpSession.h"
#include "DatabaseEnv.h"
#include "HttpSocket.h"
#include "HttpSslSocket.h"
#include "IpBanCheckConnectionInitializer.h"
#include "LoginRESTService.h"
#include "SslContext.h"
#include "Util.h"
#include <boost/container/static_vector.hpp>
namespace Battlenet
namespace
{
template<template<typename> typename SocketImpl>
LoginHttpSession<SocketImpl>::LoginHttpSession(boost::asio::ip::tcp::socket&& socket, LoginHttpSessionWrapper& owner)
: BaseSocket(std::move(socket), SslContext::instance()), _owner(owner)
{
}
template<template<typename> typename SocketImpl>
LoginHttpSession<SocketImpl>::~LoginHttpSession() = default;
template<template<typename> typename SocketImpl>
void LoginHttpSession<SocketImpl>::Start()
{
std::string ip_address = this->GetRemoteIpAddress().to_string();
TC_LOG_TRACE("server.http.session", "{} Accepted connection", this->GetClientInfo());
// Verify that this IP is not in the ip_banned table
LoginDatabase.Execute(LoginDatabase.GetPreparedStatement(LOGIN_DEL_EXPIRED_IP_BANS));
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_IP_INFO);
stmt->setString(0, ip_address);
this->_queryProcessor.AddCallback(LoginDatabase.AsyncQuery(stmt)
.WithPreparedCallback([sess = this->shared_from_this()](PreparedQueryResult result) { sess->CheckIpCallback(std::move(result)); }));
}
template<template<typename> typename SocketImpl>
void LoginHttpSession<SocketImpl>::CheckIpCallback(PreparedQueryResult result)
{
if (result)
{
bool banned = false;
do
{
Field* fields = result->Fetch();
if (fields[0].GetUInt64() != 0)
banned = true;
} while (result->NextRow());
if (banned)
{
TC_LOG_DEBUG("server.http.session", "{} tries to log in using banned IP!", this->GetClientInfo());
this->CloseSocket();
return;
}
}
if constexpr (std::is_same_v<BaseSocket, Trinity::Net::Http::SslSocket<LoginHttpSession<Trinity::Net::Http::SslSocket>>>)
{
this->AsyncHandshake();
}
else
{
this->ResetHttpParser();
this->AsyncRead();
}
}
template<template<typename> typename SocketImpl>
Trinity::Net::Http::RequestHandlerResult LoginHttpSession<SocketImpl>::RequestHandler(Trinity::Net::Http::RequestContext& context)
{
return sLoginService.HandleRequest(_owner.shared_from_this(), context);
}
std::shared_ptr<Trinity::Net::Http::SessionState> ObtainSessionState(Trinity::Net::Http::RequestContext& context, boost::asio::ip::address const& remoteAddress)
{
using namespace std::string_literals;
std::shared_ptr<Trinity::Net::Http::SessionState> state;
auto cookieItr = context.request.find(boost::beast::http::field::cookie);
if (cookieItr != context.request.end())
{
std::vector<std::string_view> cookies = Trinity::Tokenize(Trinity::Net::Http::ToStdStringView(cookieItr->value()), ';', false);
std::size_t eq = 0;
auto sessionIdItr = std::find_if(cookies.begin(), cookies.end(), [&](std::string_view cookie)
auto sessionIdItr = std::ranges::find_if(cookies, [](std::string_view const& cookie)
{
std::string_view name = cookie;
eq = cookie.find('=');
if (eq != std::string_view::npos)
name = cookie.substr(0, eq);
return name == LoginHttpSessionWrapper::SESSION_ID_COOKIE;
return cookie.length() > Battlenet::LoginHttpSession::SESSION_ID_COOKIE.length()
&& cookie.starts_with(Battlenet::LoginHttpSession::SESSION_ID_COOKIE);
});
if (sessionIdItr != cookies.end())
{
std::string_view value = sessionIdItr->substr(eq + 1);
state = sLoginService.FindAndRefreshSessionState(value, remoteAddress);
sessionIdItr->remove_prefix(Battlenet::LoginHttpSession::SESSION_ID_COOKIE.length());
state = sLoginService.FindAndRefreshSessionState(*sessionIdItr, remoteAddress);
}
}
if (!state)
{
state = sLoginService.CreateNewSessionState(remoteAddress);
std::string_view host = Trinity::Net::Http::ToStdStringView(context.request[boost::beast::http::field::host]);
if (std::size_t port = host.find(':'); port != std::string_view::npos)
if (size_t port = host.find(':'); port != std::string_view::npos)
host.remove_suffix(host.length() - port);
context.response.insert(boost::beast::http::field::set_cookie, Trinity::StringFormat("{}={}; Path=/bnetserver; Domain={}; Secure; HttpOnly; SameSite=None",
LoginHttpSessionWrapper::SESSION_ID_COOKIE, boost::uuids::to_string(state->Id), host));
context.response.insert(boost::beast::http::field::set_cookie, Trinity::StringFormat("{}{}; Path=/bnetserver; Domain={}; Secure; HttpOnly; SameSite=None",
Battlenet::LoginHttpSession::SESSION_ID_COOKIE, boost::uuids::to_string(state->Id), host));
}
return state;
}
template class LoginHttpSession<Trinity::Net::Http::SslSocket>;
template class LoginHttpSession<Trinity::Net::Http::Socket>;
LoginHttpSessionWrapper::LoginHttpSessionWrapper(boost::asio::ip::tcp::socket&& socket)
template<typename SocketImpl>
class LoginHttpSocketImpl final : public SocketImpl
{
public:
using BaseSocket = SocketImpl;
explicit LoginHttpSocketImpl(Trinity::Net::IoContextTcpSocket&& socket, Battlenet::LoginHttpSession& owner)
: BaseSocket(std::move(socket)), _owner(owner)
{
}
LoginHttpSocketImpl(LoginHttpSocketImpl const&) = delete;
LoginHttpSocketImpl(LoginHttpSocketImpl&&) = delete;
LoginHttpSocketImpl& operator=(LoginHttpSocketImpl const&) = delete;
LoginHttpSocketImpl& operator=(LoginHttpSocketImpl&&) = delete;
~LoginHttpSocketImpl() = default;
void Start() override
{
// build initializer chain
boost::container::static_vector<std::shared_ptr<Trinity::Net::SocketConnectionInitializer>, 4> initializers;
initializers.stable_emplace_back(std::make_shared<Trinity::Net::IpBanCheckConnectionInitializer<BaseSocket>>(this));
if constexpr (std::is_same_v<BaseSocket, Trinity::Net::Http::SslSocket>)
initializers.stable_emplace_back(std::make_shared<Trinity::Net::SslHandshakeConnectionInitializer<BaseSocket>>(this));
initializers.stable_emplace_back(std::make_shared<Trinity::Net::Http::HttpConnectionInitializer<BaseSocket>>(this));
initializers.stable_emplace_back(std::make_shared<Trinity::Net::ReadConnectionInitializer<BaseSocket>>(this));
Trinity::Net::SocketConnectionInitializer::SetupChain(std::span(initializers.data(), initializers.size()))->Start();
}
Trinity::Net::Http::RequestHandlerResult RequestHandler(Trinity::Net::Http::RequestContext& context) override
{
return sLoginService.HandleRequest(_owner.shared_from_this(), context);
}
protected:
std::shared_ptr<Trinity::Net::Http::SessionState> ObtainSessionState(Trinity::Net::Http::RequestContext& context) const override
{
return ::ObtainSessionState(context, this->GetRemoteIpAddress());
}
Battlenet::LoginHttpSession& _owner;
};
template<>
LoginHttpSocketImpl<Trinity::Net::Http::SslSocket>::LoginHttpSocketImpl(Trinity::Net::IoContextTcpSocket&& socket, Battlenet::LoginHttpSession& owner)
: BaseSocket(std::move(socket), Battlenet::SslContext::instance()), _owner(owner)
{
if (!SslContext::UsesDevWildcardCertificate())
_socket = std::make_shared<LoginHttpSession<Trinity::Net::Http::SslSocket>>(std::move(socket), *this);
else
_socket = std::make_shared<LoginHttpSession<Trinity::Net::Http::Socket>>(std::move(socket), *this);
}
}
namespace Battlenet
{
LoginHttpSession::LoginHttpSession(Trinity::Net::IoContextTcpSocket&& socket)
: _socket(!SslContext::UsesDevWildcardCertificate()
? std::shared_ptr<AbstractSocket>(std::make_shared<LoginHttpSocketImpl<Trinity::Net::Http::SslSocket>>(std::move(socket), *this))
: std::shared_ptr<AbstractSocket>(std::make_shared<LoginHttpSocketImpl<Trinity::Net::Http::Socket>>(std::move(socket), *this)))
{
}
void LoginHttpSession::Start()
{
TC_LOG_TRACE("server.http.session", "{} Accepted connection", GetClientInfo());
return _socket->Start();
}
}

64
src/server/bnetserver/REST/LoginHttpSession.h
View File

@@ -18,10 +18,8 @@
#ifndef TRINITYCORE_LOGIN_HTTP_SESSION_H
#define TRINITYCORE_LOGIN_HTTP_SESSION_H
#include "HttpSocket.h"
#include "HttpSslSocket.h"
#include "BaseHttpSocket.h"
#include "SRP6.h"
#include <variant>
namespace Battlenet
{
@@ -30,59 +28,27 @@ struct LoginSessionState : public Trinity::Net::Http::SessionState
std::unique_ptr<Trinity::Crypto::SRP::BnetSRP6Base> Srp;
};
class LoginHttpSessionWrapper;
std::shared_ptr<Trinity::Net::Http::SessionState> ObtainSessionState(Trinity::Net::Http::RequestContext& context, boost::asio::ip::address const& remoteAddress);
template<template<typename> typename SocketImpl>
class LoginHttpSession : public SocketImpl<LoginHttpSession<SocketImpl>>
class LoginHttpSession : public Trinity::Net::Http::AbstractSocket, public std::enable_shared_from_this<LoginHttpSession>
{
using BaseSocket = SocketImpl<LoginHttpSession<SocketImpl>>;
public:
explicit LoginHttpSession(boost::asio::ip::tcp::socket&& socket, LoginHttpSessionWrapper& owner);
~LoginHttpSession();
static constexpr std::string_view SESSION_ID_COOKIE = "JSESSIONID=";
explicit LoginHttpSession(Trinity::Net::IoContextTcpSocket&& socket);
void Start() override;
bool Update() override { return _socket->Update(); }
boost::asio::ip::address const& GetRemoteIpAddress() const override { return _socket->GetRemoteIpAddress(); }
bool IsOpen() const override { return _socket->IsOpen(); }
void CloseSocket() override { return _socket->CloseSocket(); }
void CheckIpCallback(PreparedQueryResult result);
Trinity::Net::Http::RequestHandlerResult RequestHandler(Trinity::Net::Http::RequestContext& context) override;
LoginSessionState* GetSessionState() const { return static_cast<LoginSessionState*>(this->_state.get()); }
protected:
std::shared_ptr<Trinity::Net::Http::SessionState> ObtainSessionState(Trinity::Net::Http::RequestContext& context) const override
{
return Battlenet::ObtainSessionState(context, this->GetRemoteIpAddress());
}
LoginHttpSessionWrapper& _owner;
};
class LoginHttpSessionWrapper : public Trinity::Net::Http::AbstractSocket, public std::enable_shared_from_this<LoginHttpSessionWrapper>
{
public:
static constexpr std::string_view SESSION_ID_COOKIE = "JSESSIONID";
explicit LoginHttpSessionWrapper(boost::asio::ip::tcp::socket&& socket);
void Start() { return std::visit([&](auto&& socket) { return socket->Start(); }, _socket); }
bool Update() { return std::visit([&](auto&& socket) { return socket->Update(); }, _socket); }
boost::asio::ip::address GetRemoteIpAddress() const { return std::visit([&](auto&& socket) { return socket->GetRemoteIpAddress(); }, _socket); }
bool IsOpen() const { return std::visit([&](auto&& socket) { return socket->IsOpen(); }, _socket); }
void CloseSocket() { return std::visit([&](auto&& socket) { return socket->CloseSocket(); }, _socket); }
void SendResponse(Trinity::Net::Http::RequestContext& context) override { return std::visit([&](auto&& socket) { return socket->SendResponse(context); }, _socket); }
void QueueQuery(QueryCallback&& queryCallback) override { return std::visit([&](auto&& socket) { return socket->QueueQuery(std::move(queryCallback)); }, _socket); }
std::string GetClientInfo() const override { return std::visit([&](auto&& socket) { return socket->GetClientInfo(); }, _socket); }
Optional<boost::uuids::uuid> GetSessionId() const override { return std::visit([&](auto&& socket) { return socket->GetSessionId(); }, _socket); }
LoginSessionState* GetSessionState() const { return std::visit([&](auto&& socket) { return socket->GetSessionState(); }, _socket); }
void SendResponse(Trinity::Net::Http::RequestContext& context) override { return _socket->SendResponse(context); }
void QueueQuery(QueryCallback&& queryCallback) override { return _socket->QueueQuery(std::move(queryCallback)); }
std::string GetClientInfo() const override { return _socket->GetClientInfo(); }
LoginSessionState* GetSessionState() const override { return static_cast<LoginSessionState*>(_socket->GetSessionState()); }
private:
std::variant<
std::shared_ptr<LoginHttpSession<Trinity::Net::Http::SslSocket>>,
std::shared_ptr<LoginHttpSession<Trinity::Net::Http::Socket>>
> _socket;
std::shared_ptr<Trinity::Net::Http::AbstractSocket> _socket;
};
}
#endif // TRINITYCORE_LOGIN_HTTP_SESSION_H

34
src/server/bnetserver/REST/LoginRESTService.cpp
View File

@@ -44,32 +44,32 @@ bool LoginRESTService::StartNetwork(Trinity::Asio::IoContext& ioContext, std::st
using Trinity::Net::Http::RequestHandlerFlag;
RegisterHandler(boost::beast::http::verb::get, "/bnetserver/login/", [this](std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context)
RegisterHandler(boost::beast::http::verb::get, "/bnetserver/login/", [this](std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context)
{
return HandleGetForm(std::move(session), context);
});
RegisterHandler(boost::beast::http::verb::get, "/bnetserver/gameAccounts/", [](std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context)
RegisterHandler(boost::beast::http::verb::get, "/bnetserver/gameAccounts/", [](std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context)
{
return HandleGetGameAccounts(std::move(session), context);
});
RegisterHandler(boost::beast::http::verb::get, "/bnetserver/portal/", [this](std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context)
RegisterHandler(boost::beast::http::verb::get, "/bnetserver/portal/", [this](std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context)
{
return HandleGetPortal(std::move(session), context);
});
RegisterHandler(boost::beast::http::verb::post, "/bnetserver/login/", [this](std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context)
RegisterHandler(boost::beast::http::verb::post, "/bnetserver/login/", [this](std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context)
{
return HandlePostLogin(std::move(session), context);
}, RequestHandlerFlag::DoNotLogRequestContent);
RegisterHandler(boost::beast::http::verb::post, "/bnetserver/login/srp/", [](std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context)
RegisterHandler(boost::beast::http::verb::post, "/bnetserver/login/srp/", [](std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context)
{
return HandlePostLoginSrpChallenge(std::move(session), context);
});
RegisterHandler(boost::beast::http::verb::post, "/bnetserver/refreshLoginTicket/", [this](std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context)
RegisterHandler(boost::beast::http::verb::post, "/bnetserver/refreshLoginTicket/", [this](std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context)
{
return HandlePostRefreshLoginTicket(std::move(session), context);
});
@@ -121,7 +121,10 @@ bool LoginRESTService::StartNetwork(Trinity::Asio::IoContext& ioContext, std::st
MigrateLegacyPasswordHashes();
_acceptor->AsyncAcceptWithCallback<&LoginRESTService::OnSocketAccept>();
_acceptor->AsyncAccept([this](Trinity::Net::IoContextTcpSocket&& sock, uint32 threadIndex)
{
OnSocketOpen(std::move(sock), threadIndex);
});
return true;
}
@@ -165,7 +168,7 @@ std::string LoginRESTService::ExtractAuthorization(HttpRequest const& request)
return ticket;
}
LoginRESTService::RequestHandlerResult LoginRESTService::HandleGetForm(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context) const
LoginRESTService::RequestHandlerResult LoginRESTService::HandleGetForm(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context) const
{
JSON::Login::FormInputs form = _formInputs;
form.set_srp_url(Trinity::StringFormat("http{}://{}:{}/bnetserver/login/srp/", !SslContext::UsesDevWildcardCertificate() ? "s" : "",
@@ -176,7 +179,7 @@ LoginRESTService::RequestHandlerResult LoginRESTService::HandleGetForm(std::shar
return RequestHandlerResult::Handled;
}
LoginRESTService::RequestHandlerResult LoginRESTService::HandleGetGameAccounts(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context)
LoginRESTService::RequestHandlerResult LoginRESTService::HandleGetGameAccounts(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context)
{
std::string ticket = ExtractAuthorization(context.request);
if (ticket.empty())
@@ -225,14 +228,14 @@ LoginRESTService::RequestHandlerResult LoginRESTService::HandleGetGameAccounts(s
return RequestHandlerResult::Async;
}
LoginRESTService::RequestHandlerResult LoginRESTService::HandleGetPortal(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context) const
LoginRESTService::RequestHandlerResult LoginRESTService::HandleGetPortal(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context) const
{
context.response.set(boost::beast::http::field::content_type, "text/plain");
context.response.body() = Trinity::StringFormat("{}:{}", GetHostnameForClient(session->GetRemoteIpAddress()), sConfigMgr->GetIntDefault("BattlenetPort", 1119));
return RequestHandlerResult::Handled;
}
LoginRESTService::RequestHandlerResult LoginRESTService::HandlePostLogin(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context) const
LoginRESTService::RequestHandlerResult LoginRESTService::HandlePostLogin(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context) const
{
std::shared_ptr<JSON::Login::LoginForm> loginForm = std::make_shared<JSON::Login::LoginForm>();
if (!::JSON::Deserialize(context.request.body(), loginForm.get()))
@@ -396,7 +399,7 @@ LoginRESTService::RequestHandlerResult LoginRESTService::HandlePostLogin(std::sh
return RequestHandlerResult::Async;
}
LoginRESTService::RequestHandlerResult LoginRESTService::HandlePostLoginSrpChallenge(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context)
LoginRESTService::RequestHandlerResult LoginRESTService::HandlePostLoginSrpChallenge(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context)
{
JSON::Login::LoginForm loginForm;
if (!::JSON::Deserialize(context.request.body(), &loginForm))
@@ -483,7 +486,7 @@ LoginRESTService::RequestHandlerResult LoginRESTService::HandlePostLoginSrpChall
return RequestHandlerResult::Async;
}
LoginRESTService::RequestHandlerResult LoginRESTService::HandlePostRefreshLoginTicket(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context) const
LoginRESTService::RequestHandlerResult LoginRESTService::HandlePostRefreshLoginTicket(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context) const
{
std::string ticket = ExtractAuthorization(context.request);
if (ticket.empty())
@@ -551,11 +554,6 @@ std::shared_ptr<Trinity::Net::Http::SessionState> LoginRESTService::CreateNewSes
return state;
}
void LoginRESTService::OnSocketAccept(boost::asio::ip::tcp::socket&& sock, uint32 threadIndex)
{
sLoginService.OnSocketOpen(std::move(sock), threadIndex);
}
void LoginRESTService::MigrateLegacyPasswordHashes() const
{
if (!LoginDatabase.Query("SELECT 1 FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = SCHEMA() AND TABLE_NAME = 'battlenet_accounts' AND COLUMN_NAME = 'sha_pass_hash'"))

22
src/server/bnetserver/REST/LoginRESTService.h
View File

@@ -15,8 +15,8 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef LoginRESTService_h__
#define LoginRESTService_h__
#ifndef TRINITYCORE_LOGIN_REST_SERVICE_H
#define TRINITYCORE_LOGIN_REST_SERVICE_H
#include "HttpService.h"
#include "Login.pb.h"
@@ -42,7 +42,7 @@ enum class BanMode
BAN_ACCOUNT = 1
};
class LoginRESTService : public Trinity::Net::Http::HttpService<LoginHttpSessionWrapper>
class LoginRESTService : public Trinity::Net::Http::HttpService<LoginHttpSession>
{
public:
using RequestHandlerResult = Trinity::Net::Http::RequestHandlerResult;
@@ -63,17 +63,15 @@ public:
std::shared_ptr<Trinity::Net::Http::SessionState> CreateNewSessionState(boost::asio::ip::address const& address) override;
private:
static void OnSocketAccept(boost::asio::ip::tcp::socket&& sock, uint32 threadIndex);
static std::string ExtractAuthorization(HttpRequest const& request);
RequestHandlerResult HandleGetForm(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context) const;
static RequestHandlerResult HandleGetGameAccounts(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context);
RequestHandlerResult HandleGetPortal(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context) const;
RequestHandlerResult HandleGetForm(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context) const;
static RequestHandlerResult HandleGetGameAccounts(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context);
RequestHandlerResult HandleGetPortal(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context) const;
RequestHandlerResult HandlePostLogin(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context) const;
static RequestHandlerResult HandlePostLoginSrpChallenge(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context);
RequestHandlerResult HandlePostRefreshLoginTicket(std::shared_ptr<LoginHttpSessionWrapper> session, HttpRequestContext& context) const;
RequestHandlerResult HandlePostLogin(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context) const;
static RequestHandlerResult HandlePostLoginSrpChallenge(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context);
RequestHandlerResult HandlePostRefreshLoginTicket(std::shared_ptr<LoginHttpSession> session, HttpRequestContext& context) const;
static std::unique_ptr<Trinity::Crypto::SRP::BnetSRP6Base> CreateSrpImplementation(SrpVersion version, SrpHashFunction hashFunction,
std::string const& username, Trinity::Crypto::SRP::Salt const& salt, Trinity::Crypto::SRP::Verifier const& verifier);
@@ -90,4 +88,4 @@ private:
#define sLoginService Battlenet::LoginRESTService::Instance()
#endif // LoginRESTService_h__
#endif // TRINITYCORE_LOGIN_REST_SERVICE_H

103
src/server/bnetserver/Server/Session.cpp
View File

@@ -23,6 +23,7 @@
#include "Errors.h"
#include "Hash.h"
#include "IPLocation.h"
#include "IpBanCheckConnectionInitializer.h"
#include "LoginRESTService.h"
#include "MapUtils.h"
#include "ProtobufJSON.h"
@@ -74,7 +75,7 @@ void Battlenet::Session::GameAccountInfo::LoadResult(Field const* fields)
DisplayName = Name;
}
Battlenet::Session::Session(boost::asio::ip::tcp::socket&& socket) : BattlenetSocket(std::move(socket), SslContext::instance()),
Battlenet::Session::Session(Trinity::Net::IoContextTcpSocket&& socket) : BaseSocket(std::move(socket), SslContext::instance()),
_accountInfo(new AccountInfo()), _gameAccountInfo(nullptr), _locale(),
_os(), _build(0), _clientInfo(), _timezoneOffset(0min), _ipCountry(), _clientSecret(), _authed(false), _requestToken(0)
{
@@ -83,54 +84,24 @@ Battlenet::Session::Session(boost::asio::ip::tcp::socket&& socket) : BattlenetSo
Battlenet::Session::~Session() = default;
void Battlenet::Session::AsyncHandshake()
{
underlying_stream().async_handshake(boost::asio::ssl::stream_base::server,
[sess = shared_from_this()](boost::system::error_code const& error) { sess->HandshakeHandler(error); });
}
void Battlenet::Session::Start()
{
std::string ip_address = GetRemoteIpAddress().to_string();
TC_LOG_TRACE("session", "{} Accepted connection", GetClientInfo());
// Verify that this IP is not in the ip_banned table
LoginDatabase.Execute(LoginDatabase.GetPreparedStatement(LOGIN_DEL_EXPIRED_IP_BANS));
// build initializer chain
std::array<std::shared_ptr<Trinity::Net::SocketConnectionInitializer>, 3> initializers =
{ {
std::make_shared<Trinity::Net::IpBanCheckConnectionInitializer<Session>>(this),
std::make_shared<Trinity::Net::SslHandshakeConnectionInitializer<Session>>(this),
std::make_shared<Trinity::Net::ReadConnectionInitializer<Session>>(this),
} };
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_IP_INFO);
stmt->setString(0, ip_address);
_queryProcessor.AddCallback(LoginDatabase.AsyncQuery(stmt)
.WithPreparedCallback([sess = shared_from_this()](PreparedQueryResult result) { sess->CheckIpCallback(std::move(result)); }));
}
void Battlenet::Session::CheckIpCallback(PreparedQueryResult result)
{
if (result)
{
bool banned = false;
do
{
Field* fields = result->Fetch();
if (fields[0].GetUInt64() != 0)
banned = true;
} while (result->NextRow());
if (banned)
{
TC_LOG_DEBUG("session", "{} tries to log in using banned IP!", GetClientInfo());
CloseSocket();
return;
}
}
AsyncHandshake();
Trinity::Net::SocketConnectionInitializer::SetupChain(initializers)->Start();
}
bool Battlenet::Session::Update()
{
if (!BattlenetSocket::Update())
if (!BaseSocket::Update())
return false;
_queryProcessor.ProcessReadyCallbacks();
@@ -211,6 +182,11 @@ void Battlenet::Session::SendRequest(uint32 serviceHash, uint32 methodId, pb::Me
AsyncWrite(&packet);
}
void Battlenet::Session::QueueQuery(QueryCallback&& queryCallback)
{
_queryProcessor.AddCallback(std::move(queryCallback));
}
uint32 Battlenet::Session::HandleLogon(authentication::v1::LogonRequest const* logonRequest, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation)
{
if (logonRequest->program() != "WoW")
@@ -292,7 +268,7 @@ uint32 Battlenet::Session::HandleGenerateWebCredentials(authentication::v1::Gene
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_BNET_EXISTING_AUTHENTICATION_BY_ID);
stmt->setUInt32(0, _accountInfo->Id);
_queryProcessor.AddCallback(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, asyncContinuation = std::move(continuation)](PreparedQueryResult result)
QueueQuery(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, asyncContinuation = std::move(continuation)](PreparedQueryResult result)
{
// just send existing credentials back (not the best but it works for now with them being stored in db)
Battlenet::Services::Authentication asyncContinuationService(this);
@@ -314,7 +290,7 @@ uint32 Battlenet::Session::VerifyWebCredentials(std::string const& webCredential
std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> asyncContinuation = std::move(continuation);
std::shared_ptr<AccountInfo> accountInfo = std::make_shared<AccountInfo>();
_queryProcessor.AddCallback(LoginDatabase.AsyncQuery(stmt).WithChainingPreparedCallback([this, accountInfo, asyncContinuation](QueryCallback& callback, PreparedQueryResult result)
QueueQuery(LoginDatabase.AsyncQuery(stmt).WithChainingPreparedCallback([this, accountInfo, asyncContinuation](QueryCallback& callback, PreparedQueryResult result)
{
Battlenet::Services::Authentication asyncContinuationService(this);
NoData response;
@@ -713,20 +689,8 @@ uint32 Battlenet::Session::HandleGetAllValuesForAttribute(game_utilities::v1::Ge
return ERROR_RPC_NOT_IMPLEMENTED;
}
void Battlenet::Session::HandshakeHandler(boost::system::error_code const& error)
{
if (error)
{
TC_LOG_ERROR("session", "{} SSL Handshake failed {}", GetClientInfo(), error.message());
CloseSocket();
return;
}
AsyncRead();
}
template<bool(Battlenet::Session::*processMethod)(), MessageBuffer Battlenet::Session::*outputBuffer>
inline bool PartialProcessPacket(Battlenet::Session* session, MessageBuffer& inputBuffer)
static inline Optional<Trinity::Net::SocketReadCallbackResult> PartialProcessPacket(Battlenet::Session* session, MessageBuffer& inputBuffer)
{
MessageBuffer& buffer = session->*outputBuffer;
@@ -738,46 +702,45 @@ inline bool PartialProcessPacket(Battlenet::Session* session, MessageBuffer& inp
buffer.Write(inputBuffer.GetReadPointer(), readDataSize);
inputBuffer.ReadCompleted(readDataSize);
}
else
return { }; // go to next buffer
if (buffer.GetRemainingSpace() > 0)
{
// Couldn't receive the whole data this time.
ASSERT(inputBuffer.GetActiveSize() == 0);
return false;
return Trinity::Net::SocketReadCallbackResult::KeepReading;
}
// just received fresh new payload
if (!(session->*processMethod)())
{
session->CloseSocket();
return false;
return Trinity::Net::SocketReadCallbackResult::Stop;
}
return true;
return { }; // go to next buffer
}
void Battlenet::Session::ReadHandler()
Trinity::Net::SocketReadCallbackResult Battlenet::Session::ReadHandler()
{
if (!IsOpen())
return;
MessageBuffer& packet = GetReadBuffer();
while (packet.GetActiveSize() > 0)
{
if (!PartialProcessPacket<&Battlenet::Session::ReadHeaderLengthHandler, &Battlenet::Session::_headerLengthBuffer>(this, packet))
break;
if (Optional<Trinity::Net::SocketReadCallbackResult> partialResult = PartialProcessPacket<&Session::ReadHeaderLengthHandler, &Session::_headerLengthBuffer>(this, packet))
return *partialResult;
if (!PartialProcessPacket<&Battlenet::Session::ReadHeaderHandler, &Battlenet::Session::_headerBuffer>(this, packet))
break;
if (Optional<Trinity::Net::SocketReadCallbackResult> partialResult = PartialProcessPacket<&Session::ReadHeaderHandler, &Session::_headerBuffer>(this, packet))
return *partialResult;
if (!PartialProcessPacket<&Battlenet::Session::ReadDataHandler, &Battlenet::Session::_packetBuffer>(this, packet))
break;
if (Optional<Trinity::Net::SocketReadCallbackResult> partialResult = PartialProcessPacket<&Session::ReadDataHandler, &Session::_packetBuffer>(this, packet))
return *partialResult;
_headerLengthBuffer.Reset();
_headerBuffer.Reset();
}
AsyncRead();
return Trinity::Net::SocketReadCallbackResult::KeepReading;
}
bool Battlenet::Session::ReadHeaderLengthHandler()
@@ -835,5 +798,5 @@ std::string Battlenet::Session::GetClientInfo() const
stream << ']';
return stream.str();
return std::move(stream).str();
}

24
src/server/bnetserver/Server/Session.h
View File

@@ -15,8 +15,8 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef Session_h__
#define Session_h__
#ifndef TRINITYCORE_SESSION_H
#define TRINITYCORE_SESSION_H
#include "AsyncCallbackProcessor.h"
#include "ClientBuildInfo.h"
@@ -24,7 +24,7 @@
#include "QueryResult.h"
#include "Realm.h"
#include "Socket.h"
#include "SslSocket.h"
#include "SslStream.h"
#include <boost/asio/ip/tcp.hpp>
#include <google/protobuf/message.h>
#include <memory>
@@ -65,9 +65,9 @@ using namespace bgs::protocol;
namespace Battlenet
{
class Session : public Socket<Session, SslSocket<>>
class Session final : public Trinity::Net::Socket<Trinity::Net::SslStream<>>
{
typedef Socket<Session, SslSocket<>> BattlenetSocket;
using BaseSocket = Socket<Trinity::Net::SslStream<>>;
public:
struct LastPlayedCharacterInfo
@@ -110,7 +110,7 @@ namespace Battlenet
std::unordered_map<uint32, GameAccountInfo> GameAccounts;
};
explicit Session(boost::asio::ip::tcp::socket&& socket);
explicit Session(Trinity::Net::IoContextTcpSocket&& socket);
~Session();
void Start() override;
@@ -130,6 +130,8 @@ namespace Battlenet
void SendRequest(uint32 serviceHash, uint32 methodId, pb::Message const* request);
void QueueQuery(QueryCallback&& queryCallback);
uint32 HandleLogon(authentication::v1::LogonRequest const* logonRequest, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
uint32 HandleVerifyWebCredentials(authentication::v1::VerifyWebCredentialsRequest const* verifyWebCredentialsRequest, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
uint32 HandleGenerateWebCredentials(authentication::v1::GenerateWebCredentialsRequest const* request, std::function<void(ServiceBase*, uint32, google::protobuf::Message const*)>& continuation);
@@ -140,9 +142,9 @@ namespace Battlenet
std::string GetClientInfo() const;
Trinity::Net::SocketReadCallbackResult ReadHandler() override;
protected:
void HandshakeHandler(boost::system::error_code const& error);
void ReadHandler() override;
bool ReadHeaderLengthHandler();
bool ReadHeaderHandler();
bool ReadDataHandler();
@@ -150,10 +152,6 @@ namespace Battlenet
private:
void AsyncWrite(MessageBuffer* packet);
void AsyncHandshake();
void CheckIpCallback(PreparedQueryResult result);
uint32 VerifyWebCredentials(std::string const& webCredentials, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
typedef uint32(Session::*ClientRequestHandler)(std::unordered_map<std::string, Variant const*> const&, game_utilities::v1::ClientResponse*);
@@ -190,4 +188,4 @@ namespace Battlenet
};
}
#endif // Session_h__
#endif // TRINITYCORE_SESSION_H

15
src/server/bnetserver/Server/SessionManager.cpp
View File

@@ -16,7 +16,6 @@
*/
#include "SessionManager.h"
#include "DatabaseEnv.h"
#include "Util.h"
bool Battlenet::SessionManager::StartNetwork(Trinity::Asio::IoContext& ioContext, std::string const& bindIp, uint16 port, int threadCount)
@@ -24,18 +23,16 @@ bool Battlenet::SessionManager::StartNetwork(Trinity::Asio::IoContext& ioContext
if (!BaseSocketMgr::StartNetwork(ioContext, bindIp, port, threadCount))
return false;
_acceptor->AsyncAcceptWithCallback<&OnSocketAccept>();
_acceptor->AsyncAccept([this](Trinity::Net::IoContextTcpSocket&& sock, uint32 threadIndex)
{
OnSocketOpen(std::move(sock), threadIndex);
});
return true;
}
NetworkThread<Battlenet::Session>* Battlenet::SessionManager::CreateThreads() const
Trinity::Net::NetworkThread<Battlenet::Session>* Battlenet::SessionManager::CreateThreads() const
{
return new NetworkThread<Session>[GetNetworkThreadCount()];
}
void Battlenet::SessionManager::OnSocketAccept(boost::asio::ip::tcp::socket&& sock, uint32 threadIndex)
{
sSessionMgr.OnSocketOpen(std::move(sock), threadIndex);
return new Trinity::Net::NetworkThread<Session>[GetNetworkThreadCount()];
}
Battlenet::SessionManager& Battlenet::SessionManager::Instance()

13
src/server/bnetserver/Server/SessionManager.h
View File

@@ -15,15 +15,15 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SessionManager_h__
#define SessionManager_h__
#ifndef TRINITYCORE_SESSION_MANAGER_H
#define TRINITYCORE_SESSION_MANAGER_H
#include "SocketMgr.h"
#include "Session.h"
namespace Battlenet
{
class SessionManager : public SocketMgr<Session>
class SessionManager : public Trinity::Net::SocketMgr<Session>
{
typedef SocketMgr<Session> BaseSocketMgr;
@@ -33,13 +33,10 @@ namespace Battlenet
bool StartNetwork(Trinity::Asio::IoContext& ioContext, std::string const& bindIp, uint16 port, int threadCount = 1) override;
protected:
NetworkThread<Session>* CreateThreads() const override;
private:
static void OnSocketAccept(boost::asio::ip::tcp::socket&& sock, uint32 threadIndex);
Trinity::Net::NetworkThread<Session>* CreateThreads() const override;
};
}
#define sSessionMgr Battlenet::SessionManager::Instance()
#endif // SessionManager_h__
#endif // TRINITYCORE_SESSION_MANAGER_H

4
src/server/game/Scripting/ScriptMgr.cpp
View File

@@ -1474,14 +1474,14 @@ void ScriptMgr::OnNetworkStop()
FOREACH_SCRIPT(ServerScript)->OnNetworkStop();
}
void ScriptMgr::OnSocketOpen(std::shared_ptr<WorldSocket> socket)
void ScriptMgr::OnSocketOpen(std::shared_ptr<WorldSocket> const& socket)
{
ASSERT(socket);
FOREACH_SCRIPT(ServerScript)->OnSocketOpen(socket);
}
void ScriptMgr::OnSocketClose(std::shared_ptr<WorldSocket> socket)
void ScriptMgr::OnSocketClose(std::shared_ptr<WorldSocket> const& socket)
{
ASSERT(socket);

4
src/server/game/Scripting/ScriptMgr.h
View File

@@ -1067,8 +1067,8 @@ class TC_GAME_API ScriptMgr
void OnNetworkStart();
void OnNetworkStop();
void OnSocketOpen(std::shared_ptr<WorldSocket> socket);
void OnSocketClose(std::shared_ptr<WorldSocket> socket);
void OnSocketOpen(std::shared_ptr<WorldSocket> const& socket);
void OnSocketClose(std::shared_ptr<WorldSocket> const& socket);
void OnPacketReceive(WorldSession* session, WorldPacket const& packet);
void OnPacketSend(WorldSession* session, WorldPacket const& packet);

250
src/server/game/Server/WorldSocket.cpp
View File

@@ -26,6 +26,7 @@
#include "GameTime.h"
#include "HMAC.h"
#include "IPLocation.h"
#include "IpBanCheckConnectionInitializer.h"
#include "PacketLog.h"
#include "ProtobufJSON.h"
#include "RealmList.h"
@@ -33,6 +34,7 @@
#include "RealmList.pb.h"
#include "ScriptMgr.h"
#include "SessionKeyGenerator.h"
#include "SslStream.h"
#include "World.h"
#include "WorldPacket.h"
#include "WorldSession.h"
@@ -49,8 +51,6 @@ struct CompressedWorldPacket
#pragma pack(pop)
std::string const WorldSocket::ServerConnectionInitialize("WORLD OF WARCRAFT CONNECTION - SERVER TO CLIENT - V2");
std::string const WorldSocket::ClientConnectionInitialize("WORLD OF WARCRAFT CONNECTION - CLIENT TO SERVER - V2");
uint32 const WorldSocket::MinSizeForCompression = 0x400;
std::array<uint8, 32> const WorldSocket::AuthCheckSeed = { 0xDE, 0x3A, 0x2A, 0x8E, 0x6B, 0x89, 0x52, 0x66, 0x88, 0x9D, 0x7E, 0x7A, 0x77, 0x1D, 0x5D, 0x1F,
@@ -62,7 +62,7 @@ std::array<uint8, 32> const WorldSocket::ContinuedSessionSeed = { 0x56, 0x5C, 0x
std::array<uint8, 32> const WorldSocket::EncryptionKeySeed = { 0x71, 0xC9, 0xED, 0x5A, 0xA7, 0x0E, 0x4D, 0xFF, 0x4C, 0x36, 0xA6, 0x5A, 0x3E, 0x46, 0x8A, 0x4A,
0x5D, 0xA1, 0x48, 0xC8, 0x30, 0x47, 0x4A, 0xDE, 0xF6, 0x0D, 0x6C, 0xBE, 0x6F, 0xE4, 0x55, 0x73 };
WorldSocket::WorldSocket(boost::asio::ip::tcp::socket&& socket) : Socket(std::move(socket)),
WorldSocket::WorldSocket(Trinity::Net::IoContextTcpSocket&& socket) : BaseSocket(std::move(socket)),
_type(CONNECTION_TYPE_REALM), _key(0), _serverChallenge(), _sessionKey(), _encryptKey(), _OverSpeedPings(0),
_worldSession(nullptr), _authed(false), _canRequestHotfixes(true), _headerBuffer(sizeof(IncomingPacketHeader)), _sendBufferSize(4096), _compressionStream(nullptr)
{
@@ -77,127 +77,127 @@ WorldSocket::~WorldSocket()
}
}
struct WorldSocketProtocolInitializer final : Trinity::Net::SocketConnectionInitializer
{
static constexpr std::string_view ServerConnectionInitialize = "WORLD OF WARCRAFT CONNECTION - SERVER TO CLIENT - V2\n";
static constexpr std::string_view ClientConnectionInitialize = "WORLD OF WARCRAFT CONNECTION - CLIENT TO SERVER - V2\n";
explicit WorldSocketProtocolInitializer(WorldSocket* socket) : _socket(socket) { }
void Start() override
{
_packetBuffer.Resize(ClientConnectionInitialize.length());
AsyncRead();
MessageBuffer initializer;
initializer.Write(ServerConnectionInitialize.data(), ServerConnectionInitialize.length());
// - IoContext.run thread, safe.
_socket->QueuePacket(std::move(initializer));
}
void AsyncRead()
{
_socket->AsyncRead(
[socketRef = _socket->weak_from_this(), self = static_pointer_cast<WorldSocketProtocolInitializer>(this->shared_from_this())]
{
if (!socketRef.expired())
return self->ReadHandler();
return Trinity::Net::SocketReadCallbackResult::Stop;
});
}
Trinity::Net::SocketReadCallbackResult ReadHandler();
void HandleDataReady();
private:
WorldSocket* _socket;
MessageBuffer _packetBuffer;
};
void WorldSocket::Start()
{
std::string ip_address = GetRemoteIpAddress().to_string();
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_IP_INFO);
stmt->setString(0, ip_address);
// build initializer chain
std::array<std::shared_ptr<Trinity::Net::SocketConnectionInitializer>, 3> initializers =
{ {
std::make_shared<Trinity::Net::IpBanCheckConnectionInitializer<WorldSocket>>(this),
std::make_shared<WorldSocketProtocolInitializer>(this),
std::make_shared<Trinity::Net::ReadConnectionInitializer<WorldSocket>>(this),
} };
_queryProcessor.AddCallback(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([self = shared_from_this()](PreparedQueryResult result)
{
self->CheckIpCallback(std::move(result));
}));
Trinity::Net::SocketConnectionInitializer::SetupChain(initializers)->Start();
}
void WorldSocket::CheckIpCallback(PreparedQueryResult result)
Trinity::Net::SocketReadCallbackResult WorldSocketProtocolInitializer::ReadHandler()
{
if (result)
MessageBuffer& packet = _socket->GetReadBuffer();
if (packet.GetActiveSize() > 0 && _packetBuffer.GetRemainingSpace() > 0)
{
bool banned = false;
do
{
Field* fields = result->Fetch();
if (fields[0].GetUInt64() != 0)
banned = true;
// need to receive the header
std::size_t readHeaderSize = std::min(packet.GetActiveSize(), _packetBuffer.GetRemainingSpace());
_packetBuffer.Write(packet.GetReadPointer(), readHeaderSize);
packet.ReadCompleted(readHeaderSize);
} while (result->NextRow());
if (banned)
if (_packetBuffer.GetRemainingSpace() == 0)
{
TC_LOG_ERROR("network", "WorldSocket::CheckIpCallback: Sent Auth Response (IP {} banned).", GetRemoteIpAddress().to_string());
DelayedCloseSocket();
HandleDataReady();
return Trinity::Net::SocketReadCallbackResult::Stop;
}
// Couldn't receive the whole header this time.
ASSERT(packet.GetActiveSize() == 0);
}
return Trinity::Net::SocketReadCallbackResult::KeepReading;
}
void WorldSocketProtocolInitializer::HandleDataReady()
{
try
{
ByteBuffer buffer(std::move(_packetBuffer));
if (buffer.ReadString(ClientConnectionInitialize.length()) != ClientConnectionInitialize)
{
_socket->CloseSocket();
return;
}
}
_packetBuffer.Resize(ClientConnectionInitialize.length() + 1);
AsyncReadWithCallback(&WorldSocket::InitializeHandler);
MessageBuffer initializer;
initializer.Write(ServerConnectionInitialize.c_str(), ServerConnectionInitialize.length());
initializer.Write("\n", 1);
// - IoContext.run thread, safe.
QueuePacket(std::move(initializer));
}
void WorldSocket::InitializeHandler(boost::system::error_code const& error, std::size_t transferedBytes)
{
if (error)
catch (ByteBufferException const& ex)
{
CloseSocket();
TC_LOG_ERROR("network", "WorldSocket::InitializeHandler ByteBufferException {} occured while parsing initial packet from {}",
ex.what(), _socket->GetRemoteIpAddress().to_string());
_socket->CloseSocket();
return;
}
GetReadBuffer().WriteCompleted(transferedBytes);
if (!_socket->InitializeCompression())
return;
MessageBuffer& packet = GetReadBuffer();
if (packet.GetActiveSize() > 0)
_socket->SendAuthSession();
if (next)
next->Start();
}
bool WorldSocket::InitializeCompression()
{
_compressionStream = new z_stream();
_compressionStream->zalloc = (alloc_func)nullptr;
_compressionStream->zfree = (free_func)nullptr;
_compressionStream->opaque = (voidpf)nullptr;
_compressionStream->avail_in = 0;
_compressionStream->next_in = nullptr;
int32 z_res = deflateInit2(_compressionStream, sWorld->getIntConfig(CONFIG_COMPRESSION), Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
if (z_res != Z_OK)
{
if (_packetBuffer.GetRemainingSpace() > 0)
{
// need to receive the header
std::size_t readHeaderSize = std::min(packet.GetActiveSize(), _packetBuffer.GetRemainingSpace());
_packetBuffer.Write(packet.GetReadPointer(), readHeaderSize);
packet.ReadCompleted(readHeaderSize);
if (_packetBuffer.GetRemainingSpace() > 0)
{
// Couldn't receive the whole header this time.
ASSERT(packet.GetActiveSize() == 0);
AsyncReadWithCallback(&WorldSocket::InitializeHandler);
return;
}
try
{
ByteBuffer buffer(std::move(_packetBuffer));
std::string initializer(buffer.ReadString(ClientConnectionInitialize.length()));
if (initializer != ClientConnectionInitialize)
{
CloseSocket();
return;
}
uint8 terminator;
buffer >> terminator;
if (terminator != '\n')
{
CloseSocket();
return;
}
}
catch (ByteBufferException const& ex)
{
TC_LOG_ERROR("network", "WorldSocket::InitializeHandler ByteBufferException {} occured while parsing initial packet from {}",
ex.what(), GetRemoteIpAddress().to_string());
CloseSocket();
return;
}
_compressionStream = new z_stream();
_compressionStream->zalloc = (alloc_func)nullptr;
_compressionStream->zfree = (free_func)nullptr;
_compressionStream->opaque = (voidpf)nullptr;
_compressionStream->avail_in = 0;
_compressionStream->next_in = nullptr;
int32 z_res = deflateInit2(_compressionStream, sWorld->getIntConfig(CONFIG_COMPRESSION), Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
if (z_res != Z_OK)
{
CloseSocket();
TC_LOG_ERROR("network", "Can't initialize packet compression (zlib: deflateInit) Error code: {} ({})", z_res, zError(z_res));
return;
}
_packetBuffer.Reset();
HandleSendAuthSession();
AsyncRead();
return;
}
CloseSocket();
TC_LOG_ERROR("network", "Can't initialize packet compression (zlib: deflateInit) Error code: {} ({})", z_res, zError(z_res));
return false;
}
AsyncReadWithCallback(&WorldSocket::InitializeHandler);
return true;
}
bool WorldSocket::Update()
@@ -206,7 +206,7 @@ bool WorldSocket::Update()
MessageBuffer buffer(_sendBufferSize);
while (_bufferQueue.Dequeue(queued))
{
uint32 packetSize = queued->size() + 2 /*opcode*/;
uint32 packetSize = queued->size() + 4 /*opcode*/;
if (packetSize > MinSizeForCompression && queued->NeedsEncryption())
packetSize = deflateBound(_compressionStream, packetSize) + sizeof(CompressedWorldPacket);
@@ -240,7 +240,7 @@ bool WorldSocket::Update()
return true;
}
void WorldSocket::HandleSendAuthSession()
void WorldSocket::SendAuthSession()
{
Trinity::Crypto::GetRandomBytes(_serverChallenge);
@@ -260,11 +260,8 @@ void WorldSocket::OnClose()
}
}
void WorldSocket::ReadHandler()
Trinity::Net::SocketReadCallbackResult WorldSocket::ReadHandler()
{
if (!IsOpen())
return;
MessageBuffer& packet = GetReadBuffer();
while (packet.GetActiveSize() > 0)
{
@@ -286,7 +283,7 @@ void WorldSocket::ReadHandler()
if (!ReadHeaderHandler())
{
CloseSocket();
return;
return Trinity::Net::SocketReadCallbackResult::Stop;
}
}
@@ -314,11 +311,16 @@ void WorldSocket::ReadHandler()
if (result != ReadDataHandlerResult::WaitingForQuery)
CloseSocket();
return;
return Trinity::Net::SocketReadCallbackResult::Stop;
}
}
AsyncRead();
return Trinity::Net::SocketReadCallbackResult::KeepReading;
}
void WorldSocket::QueueQuery(QueryCallback&& queryCallback)
{
_queryProcessor.AddCallback(std::move(queryCallback));
}
void WorldSocket::SetWorldSession(WorldSession* session)
@@ -510,14 +512,13 @@ WorldSocket::ReadDataHandlerResult WorldSocket::ReadDataHandler()
void WorldSocket::LogOpcodeText(OpcodeClient opcode, std::unique_lock<std::mutex> const& guard) const
{
if (!guard)
if (!guard || !_worldSession)
{
TC_LOG_TRACE("network.opcode", "C->S: {} {}", GetRemoteIpAddress().to_string(), GetOpcodeNameForLogging(opcode));
}
else
{
TC_LOG_TRACE("network.opcode", "C->S: {} {}", (_worldSession ? _worldSession->GetPlayerInfo() : GetRemoteIpAddress().to_string()),
GetOpcodeNameForLogging(opcode));
TC_LOG_TRACE("network.opcode", "C->S: {} {}", _worldSession->GetPlayerInfo(), GetOpcodeNameForLogging(opcode));
}
}
@@ -688,7 +689,7 @@ void WorldSocket::HandleAuthSession(std::shared_ptr<WorldPackets::Auth::AuthSess
stmt->setInt32(0, int32(sRealmList->GetCurrentRealmId().Realm));
stmt->setString(1, joinTicket->gameaccount());
_queryProcessor.AddCallback(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, authSession = std::move(authSession), joinTicket = std::move(joinTicket)](PreparedQueryResult result) mutable
QueueQuery(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, authSession = std::move(authSession), joinTicket = std::move(joinTicket)](PreparedQueryResult result) mutable
{
HandleAuthSessionCallback(std::move(authSession), std::move(joinTicket), std::move(result));
}));
@@ -898,19 +899,20 @@ void WorldSocket::HandleAuthSessionCallback(std::shared_ptr<WorldPackets::Auth::
sScriptMgr->OnAccountLogin(account.Game.Id);
_authed = true;
_worldSession = new WorldSession(account.Game.Id, std::move(*joinTicket->mutable_gameaccount()), account.BattleNet.Id, shared_from_this(), account.Game.Security,
account.Game.Expansion, mutetime, account.Game.OS, account.Game.TimezoneOffset, account.Game.Build, buildVariant, account.Game.Locale,
_worldSession = new WorldSession(account.Game.Id, std::move(*joinTicket->mutable_gameaccount()), account.BattleNet.Id,
static_pointer_cast<WorldSocket>(shared_from_this()), account.Game.Security, account.Game.Expansion, mutetime,
account.Game.OS, account.Game.TimezoneOffset, account.Game.Build, buildVariant, account.Game.Locale,
account.Game.Recruiter, account.Game.IsRectuiter);
// Initialize Warden system only if it is enabled by config
if (wardenActive)
_worldSession->InitWarden(_sessionKey);
_queryProcessor.AddCallback(_worldSession->LoadPermissionsAsync().WithPreparedCallback([this](PreparedQueryResult result)
QueueQuery(_worldSession->LoadPermissionsAsync().WithPreparedCallback([this](PreparedQueryResult result)
{
LoadSessionPermissionsCallback(std::move(result));
}));
AsyncRead();
AsyncRead(Trinity::Net::InvokeReadHandlerCallback<WorldSocket>{ .Socket = this });
}
void WorldSocket::LoadSessionPermissionsCallback(PreparedQueryResult result)
@@ -938,7 +940,7 @@ void WorldSocket::HandleAuthContinuedSession(std::shared_ptr<WorldPackets::Auth:
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_INFO_CONTINUED_SESSION);
stmt->setUInt32(0, accountId);
_queryProcessor.AddCallback(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, authSession = std::move(authSession)](PreparedQueryResult result) mutable
QueueQuery(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, authSession = std::move(authSession)](PreparedQueryResult result) mutable
{
HandleAuthContinuedSessionCallback(std::move(authSession), std::move(result));
}));
@@ -985,7 +987,7 @@ void WorldSocket::HandleAuthContinuedSessionCallback(std::shared_ptr<WorldPacket
memcpy(_encryptKey.data(), encryptKeyGen.GetDigest().data(), 32);
SendPacketAndLogOpcode(*WorldPackets::Auth::EnterEncryptedMode(_encryptKey, true).Write());
AsyncRead();
AsyncRead(Trinity::Net::InvokeReadHandlerCallback<WorldSocket>{ .Socket = this });
}
void WorldSocket::HandleConnectToFailed(WorldPackets::Auth::ConnectToFailed& connectToFailed)
@@ -1032,7 +1034,7 @@ void WorldSocket::HandleEnterEncryptedModeAck()
if (_type == CONNECTION_TYPE_REALM)
sWorld->AddSession(_worldSession);
else
sWorld->AddInstanceSocket(shared_from_this(), _key);
sWorld->AddInstanceSocket(static_pointer_cast<WorldSocket>(shared_from_this()), _key);
}
void WorldSocket::SendAuthResponseError(uint32 code)

30
src/server/game/Server/WorldSocket.h
View File

@@ -15,8 +15,8 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __WORLDSOCKET_H__
#define __WORLDSOCKET_H__
#ifndef TRINITYCORE_WORLD_SOCKET_H
#define TRINITYCORE_WORLD_SOCKET_H
#include "AsyncCallbackProcessor.h"
#include "AuthDefines.h"
@@ -77,7 +77,7 @@ struct PacketHeader
uint32 Size;
uint8 Tag[12];
bool IsValidSize() { return Size < 0x10000; }
bool IsValidSize() const { return Size < 0x10000; }
};
struct IncomingPacketHeader : PacketHeader
@@ -87,10 +87,8 @@ struct IncomingPacketHeader : PacketHeader
#pragma pack(pop)
class TC_GAME_API WorldSocket : public Socket<WorldSocket>
class TC_GAME_API WorldSocket final : public Trinity::Net::Socket<>
{
static std::string const ServerConnectionInitialize;
static std::string const ClientConnectionInitialize;
static uint32 const MinSizeForCompression;
static std::array<uint8, 32> const AuthCheckSeed;
@@ -98,14 +96,16 @@ class TC_GAME_API WorldSocket : public Socket<WorldSocket>
static std::array<uint8, 32> const ContinuedSessionSeed;
static std::array<uint8, 32> const EncryptionKeySeed;
typedef Socket<WorldSocket> BaseSocket;
using BaseSocket = Socket;
public:
WorldSocket(boost::asio::ip::tcp::socket&& socket);
WorldSocket(Trinity::Net::IoContextTcpSocket&& socket);
~WorldSocket();
WorldSocket(WorldSocket const& right) = delete;
WorldSocket(WorldSocket&& right) = delete;
WorldSocket& operator=(WorldSocket const& right) = delete;
WorldSocket& operator=(WorldSocket&& right) = delete;
void Start() override;
bool Update() override;
@@ -118,9 +118,15 @@ public:
void SetWorldSession(WorldSession* session);
void SetSendBufferSize(std::size_t sendBufferSize) { _sendBufferSize = sendBufferSize; }
protected:
void OnClose() override;
void ReadHandler() override;
Trinity::Net::SocketReadCallbackResult ReadHandler() override;
void QueueQuery(QueryCallback&& queryCallback);
void SendAuthSession();
bool InitializeCompression();
protected:
bool ReadHeaderHandler();
enum class ReadDataHandlerResult
@@ -132,9 +138,6 @@ protected:
ReadDataHandlerResult ReadDataHandler();
private:
void CheckIpCallback(PreparedQueryResult result);
void InitializeHandler(boost::system::error_code const& error, std::size_t transferedBytes);
/// writes network.opcode log
/// accessing WorldSession is not threadsafe, only do it when holding _worldSessionLock
void LogOpcodeText(OpcodeClient opcode, std::unique_lock<std::mutex> const& guard) const;
@@ -143,7 +146,6 @@ private:
void WritePacketToBuffer(EncryptablePacket const& packet, MessageBuffer& buffer);
uint32 CompressPacket(uint8* buffer, WorldPacket const& packet);
void HandleSendAuthSession();
void HandleAuthSession(std::shared_ptr<WorldPackets::Auth::AuthSession> authSession);
void HandleAuthSessionCallback(std::shared_ptr<WorldPackets::Auth::AuthSession> authSession,
std::shared_ptr<JSON::RealmList::RealmJoinTicket> joinTicket, PreparedQueryResult result);

20
src/server/game/Server/WorldSocketMgr.cpp
View File

@@ -22,21 +22,16 @@
#include "WorldSocket.h"
#include <boost/system/error_code.hpp>
static void OnSocketAccept(boost::asio::ip::tcp::socket&& sock, uint32 threadIndex)
{
sWorldSocketMgr.OnSocketOpen(std::move(sock), threadIndex);
}
class WorldSocketThread : public NetworkThread<WorldSocket>
class WorldSocketThread : public Trinity::Net::NetworkThread<WorldSocket>
{
public:
void SocketAdded(std::shared_ptr<WorldSocket> sock) override
void SocketAdded(std::shared_ptr<WorldSocket> const& sock) override
{
sock->SetSendBufferSize(sWorldSocketMgr.GetApplicationSendBufferSize());
sScriptMgr->OnSocketOpen(sock);
}
void SocketRemoved(std::shared_ptr<WorldSocket> sock) override
void SocketRemoved(std::shared_ptr<WorldSocket>const& sock) override
{
sScriptMgr->OnSocketClose(sock);
}
@@ -75,7 +70,10 @@ bool WorldSocketMgr::StartNetwork(Trinity::Asio::IoContext& ioContext, std::stri
if (!BaseSocketMgr::StartNetwork(ioContext, bindIp, port, threadCount))
return false;
_acceptor->AsyncAcceptWithCallback<&OnSocketAccept>();
_acceptor->AsyncAccept([this](Trinity::Net::IoContextTcpSocket&& sock, uint32 threadIndex)
{
OnSocketOpen(std::move(sock), threadIndex);
});
sScriptMgr->OnNetworkStart();
return true;
@@ -88,7 +86,7 @@ void WorldSocketMgr::StopNetwork()
sScriptMgr->OnNetworkStop();
}
void WorldSocketMgr::OnSocketOpen(boost::asio::ip::tcp::socket&& sock, uint32 threadIndex)
void WorldSocketMgr::OnSocketOpen(Trinity::Net::IoContextTcpSocket&& sock, uint32 threadIndex)
{
// set some options here
if (_socketSystemSendBufferSize >= 0)
@@ -117,7 +115,7 @@ void WorldSocketMgr::OnSocketOpen(boost::asio::ip::tcp::socket&& sock, uint32 th
BaseSocketMgr::OnSocketOpen(std::move(sock), threadIndex);
}
NetworkThread<WorldSocket>* WorldSocketMgr::CreateThreads() const
Trinity::Net::NetworkThread<WorldSocket>* WorldSocketMgr::CreateThreads() const
{
return new WorldSocketThread[GetNetworkThreadCount()];
}

17
src/server/game/Server/WorldSocketMgr.h
View File

@@ -15,21 +15,15 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** \addtogroup u2w User to World Communication
* @{
* \file WorldSocketMgr.h
* \author Derex <derex101@gmail.com>
*/
#ifndef __WORLDSOCKETMGR_H
#define __WORLDSOCKETMGR_H
#ifndef TRINITYCORE_WORLD_SOCKET_MGR_H
#define TRINITYCORE_WORLD_SOCKET_MGR_H
#include "SocketMgr.h"
class WorldSocket;
/// Manages all sockets connected to peers and network threads
class TC_GAME_API WorldSocketMgr : public SocketMgr<WorldSocket>
class TC_GAME_API WorldSocketMgr : public Trinity::Net::SocketMgr<WorldSocket>
{
typedef SocketMgr<WorldSocket> BaseSocketMgr;
@@ -44,14 +38,14 @@ public:
/// Stops all network threads, It will wait for all running threads .
void StopNetwork() override;
void OnSocketOpen(boost::asio::ip::tcp::socket&& sock, uint32 threadIndex) override;
void OnSocketOpen(Trinity::Net::IoContextTcpSocket&& sock, uint32 threadIndex) override;
std::size_t GetApplicationSendBufferSize() const { return _socketApplicationSendBufferSize; }
protected:
WorldSocketMgr();
NetworkThread<WorldSocket>* CreateThreads() const override;
Trinity::Net::NetworkThread<WorldSocket>* CreateThreads() const override;
private:
int32 _socketSystemSendBufferSize;
@@ -62,4 +56,3 @@ private:
#define sWorldSocketMgr WorldSocketMgr::Instance()
#endif
/// @}

64
src/server/shared/Networking/AsyncAcceptor.h
View File

@@ -15,12 +15,13 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __ASYNCACCEPT_H_
#define __ASYNCACCEPT_H_
#ifndef TRINITYCORE_ASYNC_ACCEPTOR_H
#define TRINITYCORE_ASYNC_ACCEPTOR_H
#include "IoContext.h"
#include "IpAddress.h"
#include "Log.h"
#include "Socket.h"
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ip/v6_only.hpp>
#include <atomic>
@@ -28,28 +29,28 @@
#define TRINITY_MAX_LISTEN_CONNECTIONS boost::asio::socket_base::max_listen_connections
namespace Trinity::Net
{
template <typename Callable>
concept AcceptCallback = std::invocable<Callable, IoContextTcpSocket&&, uint32>;
class AsyncAcceptor
{
public:
typedef void(*AcceptCallback)(boost::asio::ip::tcp::socket&& newSocket, uint32 threadIndex);
AsyncAcceptor(Trinity::Asio::IoContext& ioContext, std::string const& bindIp, uint16 port) :
_acceptor(ioContext), _endpoint(Trinity::Net::make_address(bindIp), port),
AsyncAcceptor(Asio::IoContext& ioContext, std::string const& bindIp, uint16 port) :
_acceptor(ioContext), _endpoint(make_address(bindIp), port),
_socket(ioContext), _closed(false), _socketFactory([this] { return DefeaultSocketFactory(); })
{
}
template<class T>
void AsyncAccept();
template<AcceptCallback acceptCallback>
void AsyncAcceptWithCallback()
template <AcceptCallback Callback>
void AsyncAccept(Callback&& acceptCallback)
{
auto [tmpSocket, tmpThreadIndex] = _socketFactory();
// TODO: get rid of temporary variables (clang 15 cannot handle variables from structured bindings as lambda captures)
boost::asio::ip::tcp::socket* socket = tmpSocket;
IoContextTcpSocket* socket = tmpSocket;
uint32 threadIndex = tmpThreadIndex;
_acceptor.async_accept(*socket, [this, socket, threadIndex](boost::system::error_code error)
_acceptor.async_accept(*socket, [this, socket, threadIndex, acceptCallback = std::forward<Callback>(acceptCallback)](boost::system::error_code const& error) mutable
{
if (!error)
{
@@ -66,7 +67,7 @@ public:
}
if (!_closed)
this->AsyncAcceptWithCallback<acceptCallback>();
this->AsyncAccept(std::move(acceptCallback));
});
}
@@ -120,40 +121,17 @@ public:
_acceptor.close(err);
}
void SetSocketFactory(std::function<std::pair<boost::asio::ip::tcp::socket*, uint32>()> func) { _socketFactory = std::move(func); }
void SetSocketFactory(std::function<std::pair<IoContextTcpSocket*, uint32>()> func) { _socketFactory = std::move(func); }
private:
std::pair<boost::asio::ip::tcp::socket*, uint32> DefeaultSocketFactory() { return std::make_pair(&_socket, 0); }
std::pair<IoContextTcpSocket*, uint32> DefeaultSocketFactory() { return std::make_pair(&_socket, 0); }
boost::asio::ip::tcp::acceptor _acceptor;
boost::asio::basic_socket_acceptor<boost::asio::ip::tcp, IoContextTcpSocket::executor_type> _acceptor;
boost::asio::ip::tcp::endpoint _endpoint;
boost::asio::ip::tcp::socket _socket;
IoContextTcpSocket _socket;
std::atomic<bool> _closed;
std::function<std::pair<boost::asio::ip::tcp::socket*, uint32>()> _socketFactory;
std::function<std::pair<IoContextTcpSocket*, uint32>()> _socketFactory;
};
template<class T>
void AsyncAcceptor::AsyncAccept()
{
_acceptor.async_accept(_socket, [this](boost::system::error_code error)
{
if (!error)
{
try
{
// this-> is required here to fix an segmentation fault in gcc 4.7.2 - reason is lambdas in a templated class
std::make_shared<T>(std::move(this->_socket))->Start();
}
catch (boost::system::system_error const& err)
{
TC_LOG_INFO("network", "Failed to retrieve client's remote address {}", err.what());
}
}
// lets slap some more this-> on this so we can fix this bug with gcc 4.7.2 throwing internals in yo face
if (!_closed)
this->AsyncAccept<T>();
});
}
#endif /* __ASYNCACCEPT_H_ */
#endif // TRINITYCORE_ASYNC_ACCEPTOR_H

42
src/server/shared/Networking/ConnectionInitializers/IpBanCheckConnectionInitializer.cpp Normal file
View File

@@ -0,0 +1,42 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "IpBanCheckConnectionInitializer.h"
#include "DatabaseEnv.h"
QueryCallback Trinity::Net::IpBanCheckHelpers::AsyncQuery(std::string_view ipAddress)
{
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_IP_INFO);
stmt->setString(0, ipAddress);
return LoginDatabase.AsyncQuery(stmt);
}
bool Trinity::Net::IpBanCheckHelpers::IsBanned(PreparedQueryResult const& result)
{
if (result)
{
do
{
Field* fields = result->Fetch();
if (fields[0].GetUInt64() != 0)
return true;
} while (result->NextRow());
}
return false;
}

64
src/server/shared/Networking/ConnectionInitializers/IpBanCheckConnectionInitializer.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TRINITYCORE_IP_BAN_CHECK_CONNECTION_INITIALIZER_H
#define TRINITYCORE_IP_BAN_CHECK_CONNECTION_INITIALIZER_H
#include "DatabaseEnvFwd.h"
#include "Log.h"
#include "QueryCallback.h"
#include "SocketConnectionInitializer.h"
namespace Trinity::Net
{
namespace IpBanCheckHelpers
{
TC_SHARED_API QueryCallback AsyncQuery(std::string_view ipAddress);
TC_SHARED_API bool IsBanned(PreparedQueryResult const& result);
}
template <typename SocketImpl>
struct IpBanCheckConnectionInitializer final : SocketConnectionInitializer
{
explicit IpBanCheckConnectionInitializer(SocketImpl* socket) : _socket(socket) { }
void Start() override
{
_socket->QueueQuery(IpBanCheckHelpers::AsyncQuery(_socket->GetRemoteIpAddress().to_string()).WithPreparedCallback([socketRef = _socket->weak_from_this(), self = this->shared_from_this()](PreparedQueryResult const& result)
{
std::shared_ptr<SocketImpl> socket = static_pointer_cast<SocketImpl>(socketRef.lock());
if (!socket)
return;
if (IpBanCheckHelpers::IsBanned(result))
{
TC_LOG_ERROR("network", "IpBanCheckConnectionInitializer: IP {} is banned.", socket->GetRemoteIpAddress().to_string());
socket->DelayedCloseSocket();
return;
}
if (self->next)
self->next->Start();
}));
}
private:
SocketImpl* _socket;
};
}
#endif // TRINITYCORE_IP_BAN_CHECK_CONNECTION_INITIALIZER_H

51
src/server/shared/Networking/ConnectionInitializers/SocketConnectionInitializer.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TRINITYCORE_SOCKET_CONNECTION_INITIALIZER_H
#define TRINITYCORE_SOCKET_CONNECTION_INITIALIZER_H
#include <memory>
#include <span>
namespace Trinity::Net
{
struct SocketConnectionInitializer : public std::enable_shared_from_this<SocketConnectionInitializer>
{
SocketConnectionInitializer() = default;
SocketConnectionInitializer(SocketConnectionInitializer const&) = delete;
SocketConnectionInitializer(SocketConnectionInitializer&&) noexcept = default;
SocketConnectionInitializer& operator=(SocketConnectionInitializer const&) = delete;
SocketConnectionInitializer& operator=(SocketConnectionInitializer&&) noexcept = default;
virtual ~SocketConnectionInitializer() = default;
virtual void Start() = 0;
std::shared_ptr<SocketConnectionInitializer> next;
static std::shared_ptr<SocketConnectionInitializer>& SetupChain(std::span<std::shared_ptr<SocketConnectionInitializer>> initializers)
{
for (std::size_t i = initializers.size(); i > 1; --i)
initializers[i - 2]->next.swap(initializers[i - 1]);
return initializers[0];
}
};
}
#endif // TRINITYCORE_SOCKET_CONNECTION_INITIALIZER_H

31
src/server/shared/Networking/Http/BaseHttpSocket.cpp
View File

@@ -16,6 +16,7 @@
*/
#include "BaseHttpSocket.h"
#include <boost/asio/buffers_iterator.hpp>
#include <boost/beast/http/serializer.hpp>
namespace Trinity::Net::Http
@@ -112,4 +113,34 @@ MessageBuffer AbstractSocket::SerializeResponse(Request const& request, Response
return buffer;
}
void AbstractSocket::LogRequestAndResponse(RequestContext const& context, MessageBuffer& buffer) const
{
if (Logger const* logger = sLog->GetEnabledLogger("server.http", LOG_LEVEL_DEBUG))
{
std::string clientInfo = GetClientInfo();
sLog->OutMessageTo(logger, "server.http", LOG_LEVEL_DEBUG, "{} Request {} {} done, status {}", clientInfo,
ToStdStringView(context.request.method_string()), ToStdStringView(context.request.target()), context.response.result_int());
if (sLog->ShouldLog("server.http", LOG_LEVEL_TRACE))
{
sLog->OutMessageTo(logger, "server.http", LOG_LEVEL_TRACE, "{} Request: {}", clientInfo,
CanLogRequestContent(context) ? SerializeRequest(context.request) : "<REDACTED>");
sLog->OutMessageTo(logger, "server.http", LOG_LEVEL_TRACE, "{} Response: {}", clientInfo,
CanLogResponseContent(context) ? std::string_view(reinterpret_cast<char const*>(buffer.GetBasePointer()), buffer.GetActiveSize()) : "<REDACTED>");
}
}
}
std::string AbstractSocket::GetClientInfo(boost::asio::ip::address const& address, uint16 port, SessionState const* state)
{
std::string info = StringFormat("[{}:{}", address.to_string(), port);
if (state)
{
info.append(", Session Id: ");
info.append(boost::uuids::to_string(state->Id));
}
info += ']';
return info;
}
}

136
src/server/shared/Networking/Http/BaseHttpSocket.h
View File

@@ -25,13 +25,46 @@
#include "Optional.h"
#include "QueryCallback.h"
#include "Socket.h"
#include <boost/asio/buffers_iterator.hpp>
#include "SocketConnectionInitializer.h"
#include <boost/beast/core/basic_stream.hpp>
#include <boost/beast/http/parser.hpp>
#include <boost/beast/http/string_body.hpp>
#include <boost/uuid/uuid_io.hpp>
namespace Trinity::Net::Http
{
using IoContextHttpSocket = boost::beast::basic_stream<boost::asio::ip::tcp, boost::asio::io_context::executor_type, boost::beast::unlimited_rate_policy>;
namespace Impl
{
class BoostBeastSocketWrapper : public IoContextHttpSocket
{
public:
using IoContextHttpSocket::basic_stream;
void shutdown(boost::asio::socket_base::shutdown_type what, boost::system::error_code& shutdownError)
{
socket().shutdown(what, shutdownError);
}
void close(boost::system::error_code& /*error*/)
{
IoContextHttpSocket::close();
}
template<typename WaitHandlerType>
void async_wait(boost::asio::socket_base::wait_type type, WaitHandlerType&& handler)
{
socket().async_wait(type, std::forward<WaitHandlerType>(handler));
}
IoContextTcpSocket::endpoint_type remote_endpoint() const
{
return socket().remote_endpoint();
}
};
}
using RequestParser = boost::beast::http::request_parser<RequestBody>;
class TC_SHARED_API AbstractSocket
@@ -51,22 +84,59 @@ public:
virtual void SendResponse(RequestContext& context) = 0;
void LogRequestAndResponse(RequestContext const& context, MessageBuffer& buffer) const;
virtual void QueueQuery(QueryCallback&& queryCallback) = 0;
virtual std::string GetClientInfo() const = 0;
virtual Optional<boost::uuids::uuid> GetSessionId() const = 0;
static std::string GetClientInfo(boost::asio::ip::address const& address, uint16 port, SessionState const* state);
virtual SessionState* GetSessionState() const = 0;
Optional<boost::uuids::uuid> GetSessionId() const
{
if (SessionState* state = this->GetSessionState())
return state->Id;
return {};
}
virtual void Start() = 0;
virtual bool Update() = 0;
virtual boost::asio::ip::address const& GetRemoteIpAddress() const = 0;
virtual bool IsOpen() const = 0;
virtual void CloseSocket() = 0;
};
template<typename Derived, typename Stream>
class BaseSocket : public ::Socket<Derived, Stream>, public AbstractSocket
template <typename SocketImpl>
struct HttpConnectionInitializer final : SocketConnectionInitializer
{
using Base = ::Socket<Derived, Stream>;
explicit HttpConnectionInitializer(SocketImpl* socket) : _socket(socket) { }
void Start() override
{
_socket->ResetHttpParser();
if (this->next)
this->next->Start();
}
private:
SocketImpl* _socket;
};
template<typename Stream>
class BaseSocket : public Trinity::Net::Socket<Stream>, public AbstractSocket
{
using Base = Trinity::Net::Socket<Stream>;
public:
template<typename... Args>
explicit BaseSocket(boost::asio::ip::tcp::socket&& socket, Args&&... args)
: Base(std::move(socket), std::forward<Args>(args)...) { }
using Base::Base;
BaseSocket(BaseSocket const& other) = delete;
BaseSocket(BaseSocket&& other) = delete;
@@ -75,11 +145,8 @@ public:
~BaseSocket() = default;
void ReadHandler() override
SocketReadCallbackResult ReadHandler() final
{
if (!this->IsOpen())
return;
MessageBuffer& packet = this->GetReadBuffer();
while (packet.GetActiveSize() > 0)
{
@@ -92,13 +159,13 @@ public:
if (!HandleMessage(_httpParser->get()))
{
this->CloseSocket();
break;
return SocketReadCallbackResult::Stop;
}
this->ResetHttpParser();
}
this->AsyncRead();
return SocketReadCallbackResult::KeepReading;
}
bool HandleMessage(Request& request)
@@ -118,19 +185,11 @@ public:
virtual RequestHandlerResult RequestHandler(RequestContext& context) = 0;
void SendResponse(RequestContext& context) override
void SendResponse(RequestContext& context) final
{
MessageBuffer buffer = SerializeResponse(context.request, context.response);
TC_LOG_DEBUG("server.http", "{} Request {} {} done, status {}", this->GetClientInfo(), ToStdStringView(context.request.method_string()),
ToStdStringView(context.request.target()), context.response.result_int());
if (sLog->ShouldLog("server.http", LOG_LEVEL_TRACE))
{
sLog->OutMessage("server.http", LOG_LEVEL_TRACE, "{} Request: {}", this->GetClientInfo(),
CanLogRequestContent(context) ? SerializeRequest(context.request) : "<REDACTED>");
sLog->OutMessage("server.http", LOG_LEVEL_TRACE, "{} Response: {}", this->GetClientInfo(),
CanLogResponseContent(context) ? std::string_view(reinterpret_cast<char const*>(buffer.GetBasePointer()), buffer.GetActiveSize()) : "<REDACTED>");
}
this->LogRequestAndResponse(context, buffer);
this->QueuePacket(std::move(buffer));
@@ -138,11 +197,13 @@ public:
this->DelayedCloseSocket();
}
void QueueQuery(QueryCallback&& queryCallback) override
void QueueQuery(QueryCallback&& queryCallback) final
{
this->_queryProcessor.AddCallback(std::move(queryCallback));
}
void Start() override { return this->Base::Start(); }
bool Update() override
{
if (!this->Base::Update())
@@ -152,27 +213,19 @@ public:
return true;
}
boost::asio::ip::address const& GetRemoteIpAddress() const final { return this->Base::GetRemoteIpAddress(); }
bool IsOpen() const final { return this->Base::IsOpen(); }
void CloseSocket() final { return this->Base::CloseSocket(); }
std::string GetClientInfo() const override
{
std::string info;
info.reserve(500);
auto itr = StringFormatTo(std::back_inserter(info), "[{}:{}", this->GetRemoteIpAddress().to_string(), this->GetRemotePort());
if (_state)
itr = StringFormatTo(itr, ", Session Id: {}", boost::uuids::to_string(_state->Id));
StringFormatTo(itr, "]");
return info;
return AbstractSocket::GetClientInfo(this->GetRemoteIpAddress(), this->GetRemotePort(), this->_state.get());
}
Optional<boost::uuids::uuid> GetSessionId() const final
{
if (this->_state)
return this->_state->Id;
SessionState* GetSessionState() const override { return _state.get(); }
return {};
}
protected:
void ResetHttpParser()
{
this->_httpParser.reset();
@@ -180,6 +233,7 @@ protected:
this->_httpParser->eager(true);
}
protected:
virtual std::shared_ptr<SessionState> ObtainSessionState(RequestContext& context) const = 0;
QueryCallbackProcessor _queryProcessor;

2
src/server/shared/Networking/Http/HttpService.h
View File

@@ -160,7 +160,7 @@ protected:
class Thread : public NetworkThread<SessionImpl>
{
protected:
void SocketRemoved(std::shared_ptr<SessionImpl> session) override
void SocketRemoved(std::shared_ptr<SessionImpl> const& session) override
{
if (Optional<boost::uuids::uuid> id = session->GetSessionId())
_service->MarkSessionInactive(*id);

43
src/server/shared/Networking/Http/HttpSocket.h
View File

@@ -19,43 +19,16 @@
#define TRINITYCORE_HTTP_SOCKET_H
#include "BaseHttpSocket.h"
#include <boost/beast/core/tcp_stream.hpp>
#include <array>
namespace Trinity::Net::Http
{
namespace Impl
class Socket : public BaseSocket<Impl::BoostBeastSocketWrapper>
{
class BoostBeastSocketWrapper : public boost::beast::tcp_stream
{
public:
using boost::beast::tcp_stream::tcp_stream;
void shutdown(boost::asio::socket_base::shutdown_type what, boost::system::error_code& shutdownError)
{
socket().shutdown(what, shutdownError);
}
void close(boost::system::error_code& /*error*/)
{
boost::beast::tcp_stream::close();
}
boost::asio::ip::tcp::socket::endpoint_type remote_endpoint() const
{
return socket().remote_endpoint();
}
};
}
template <typename Derived>
class Socket : public BaseSocket<Derived, Impl::BoostBeastSocketWrapper>
{
using SocketBase = BaseSocket<Derived, Impl::BoostBeastSocketWrapper>;
using SocketBase = BaseSocket<Impl::BoostBeastSocketWrapper>;
public:
template<typename... Args>
explicit Socket(boost::asio::ip::tcp::socket&& socket, Args&&...)
: SocketBase(std::move(socket)) { }
using SocketBase::SocketBase;
Socket(Socket const& other) = delete;
Socket(Socket&& other) = delete;
@@ -66,9 +39,13 @@ public:
void Start() override
{
this->ResetHttpParser();
std::array<std::shared_ptr<SocketConnectionInitializer>, 2> initializers =
{ {
std::make_shared<HttpConnectionInitializer<SocketBase>>(this),
std::make_shared<ReadConnectionInitializer<SocketBase>>(this),
} };
this->AsyncRead();
SocketConnectionInitializer::SetupChain(initializers)->Start();
}
};
}

67
src/server/shared/Networking/Http/HttpSslSocket.h
View File

@@ -19,47 +19,21 @@
#define TRINITYCORE_HTTP_SSL_SOCKET_H
#include "BaseHttpSocket.h"
#include "SslSocket.h"
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/tcp_stream.hpp>
#include <boost/beast/ssl/ssl_stream.hpp>
#include "SslStream.h"
namespace Trinity::Net::Http
{
namespace Impl
class SslSocket : public BaseSocket<SslStream<Impl::BoostBeastSocketWrapper>>
{
class BoostBeastSslSocketWrapper : public ::SslSocket<boost::beast::ssl_stream<boost::beast::tcp_stream>>
{
public:
using SslSocket::SslSocket;
void shutdown(boost::asio::socket_base::shutdown_type what, boost::system::error_code& shutdownError)
{
_sslSocket.shutdown(shutdownError);
boost::beast::get_lowest_layer(_sslSocket).socket().shutdown(what, shutdownError);
}
void close(boost::system::error_code& /*error*/)
{
boost::beast::get_lowest_layer(_sslSocket).close();
}
boost::asio::ip::tcp::socket::endpoint_type remote_endpoint() const
{
return boost::beast::get_lowest_layer(_sslSocket).socket().remote_endpoint();
}
};
}
template <typename Derived>
class SslSocket : public BaseSocket<Derived, Impl::BoostBeastSslSocketWrapper>
{
using SocketBase = BaseSocket<Derived, Impl::BoostBeastSslSocketWrapper>;
using SocketBase = BaseSocket<SslStream<Impl::BoostBeastSocketWrapper>>;
public:
explicit SslSocket(boost::asio::ip::tcp::socket&& socket, boost::asio::ssl::context& sslContext)
explicit SslSocket(IoContextTcpSocket&& socket, boost::asio::ssl::context& sslContext)
: SocketBase(std::move(socket), sslContext) { }
explicit SslSocket(boost::asio::io_context& context, boost::asio::ssl::context& sslContext)
: SocketBase(context, sslContext) { }
SslSocket(SslSocket const& other) = delete;
SslSocket(SslSocket&& other) = delete;
SslSocket& operator=(SslSocket const& other) = delete;
@@ -69,27 +43,14 @@ public:
void Start() override
{
this->AsyncHandshake();
}
std::array<std::shared_ptr<SocketConnectionInitializer>, 3> initializers =
{ {
std::make_shared<SslHandshakeConnectionInitializer<SocketBase>>(this),
std::make_shared<HttpConnectionInitializer<SocketBase>>(this),
std::make_shared<ReadConnectionInitializer<SocketBase>>(this),
} };
void AsyncHandshake()
{
this->underlying_stream().async_handshake(boost::asio::ssl::stream_base::server,
[self = this->shared_from_this()](boost::system::error_code const& error) { self->HandshakeHandler(error); });
}
void HandshakeHandler(boost::system::error_code const& error)
{
if (error)
{
TC_LOG_ERROR("server.http.session.ssl", "{} SSL Handshake failed {}", this->GetClientInfo(), error.message());
this->CloseSocket();
return;
}
this->ResetHttpParser();
this->AsyncRead();
SocketConnectionInitializer::SetupChain(initializers)->Start();
}
};
}

45
src/server/shared/Networking/NetworkThread.h
View File

@@ -15,20 +15,24 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef NetworkThread_h__
#define NetworkThread_h__
#ifndef TRINITYCORE_NETWORK_THREAD_H
#define TRINITYCORE_NETWORK_THREAD_H
#include "Define.h"
#include "Containers.h"
#include "DeadlineTimer.h"
#include "Define.h"
#include "Errors.h"
#include "IoContext.h"
#include "Log.h"
#include "Socket.h"
#include <boost/asio/ip/tcp.hpp>
#include <atomic>
#include <memory>
#include <mutex>
#include <thread>
namespace Trinity::Net
{
template<class SocketType>
class NetworkThread
{
@@ -38,14 +42,16 @@ public:
{
}
NetworkThread(NetworkThread const&) = delete;
NetworkThread(NetworkThread&&) = delete;
NetworkThread& operator=(NetworkThread const&) = delete;
NetworkThread& operator=(NetworkThread&&) = delete;
virtual ~NetworkThread()
{
Stop();
if (_thread)
{
Wait();
delete _thread;
}
}
void Stop()
@@ -59,7 +65,7 @@ public:
if (_thread)
return false;
_thread = new std::thread(&NetworkThread::Run, this);
_thread = std::make_unique<std::thread>(&NetworkThread::Run, this);
return true;
}
@@ -68,7 +74,6 @@ public:
ASSERT(_thread);
_thread->join();
delete _thread;
_thread = nullptr;
}
@@ -82,15 +87,14 @@ public:
std::lock_guard<std::mutex> lock(_newSocketsLock);
++_connections;
_newSockets.push_back(sock);
SocketAdded(sock);
SocketAdded(_newSockets.emplace_back(std::move(sock)));
}
boost::asio::ip::tcp::socket* GetSocketForAccept() { return &_acceptSocket; }
Trinity::Net::IoContextTcpSocket* GetSocketForAccept() { return &_acceptSocket; }
protected:
virtual void SocketAdded(std::shared_ptr<SocketType> /*sock*/) { }
virtual void SocketRemoved(std::shared_ptr<SocketType> /*sock*/) { }
virtual void SocketAdded(std::shared_ptr<SocketType> const& /*sock*/) { }
virtual void SocketRemoved(std::shared_ptr<SocketType> const& /*sock*/) { }
void AddNewSockets()
{
@@ -99,7 +103,7 @@ protected:
if (_newSockets.empty())
return;
for (std::shared_ptr<SocketType> sock : _newSockets)
for (std::shared_ptr<SocketType>& sock : _newSockets)
{
if (!sock->IsOpen())
{
@@ -107,7 +111,7 @@ protected:
--_connections;
}
else
_sockets.push_back(sock);
_sockets.emplace_back(std::move(sock));
}
_newSockets.clear();
@@ -136,7 +140,7 @@ protected:
AddNewSockets();
_sockets.erase(std::remove_if(_sockets.begin(), _sockets.end(), [this](std::shared_ptr<SocketType> sock)
Trinity::Containers::EraseIf(_sockets, [this](std::shared_ptr<SocketType> const& sock)
{
if (!sock->Update())
{
@@ -150,7 +154,7 @@ protected:
}
return false;
}), _sockets.end());
});
}
private:
@@ -159,7 +163,7 @@ private:
std::atomic<int32> _connections;
std::atomic<bool> _stopped;
std::thread* _thread;
std::unique_ptr<std::thread> _thread;
SocketContainer _sockets;
@@ -167,8 +171,9 @@ private:
SocketContainer _newSockets;
Trinity::Asio::IoContext _ioContext;
boost::asio::ip::tcp::socket _acceptSocket;
Trinity::Net::IoContextTcpSocket _acceptSocket;
Trinity::Asio::DeadlineTimer _updateTimer;
};
}
#endif // NetworkThread_h__
#endif // TRINITYCORE_NETWORK_THREAD_H

158
src/server/shared/Networking/Socket.h
View File

@@ -15,11 +15,14 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __SOCKET_H__
#define __SOCKET_H__
#ifndef TRINITYCORE_SOCKET_H
#define TRINITYCORE_SOCKET_H
#include "Concepts.h"
#include "Log.h"
#include "MessageBuffer.h"
#include "SocketConnectionInitializer.h"
#include <boost/asio/io_context.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <atomic>
#include <memory>
@@ -31,12 +34,51 @@
#define TC_SOCKET_USE_IOCP
#endif
namespace Trinity::Net
{
using IoContextTcpSocket = boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::io_context::executor_type>;
enum class SocketReadCallbackResult
{
KeepReading,
Stop
};
template <typename Callable>
concept SocketReadCallback = Trinity::invocable_r<Callable, SocketReadCallbackResult>;
template <typename SocketType>
struct InvokeReadHandlerCallback
{
SocketReadCallbackResult operator()() const
{
return this->Socket->ReadHandler();
}
SocketType* Socket;
};
template <typename SocketType>
struct ReadConnectionInitializer final : SocketConnectionInitializer
{
explicit ReadConnectionInitializer(SocketType* socket) : ReadCallback({ .Socket = socket }) { }
void Start() override
{
ReadCallback.Socket->AsyncRead(std::move(ReadCallback));
if (this->next)
this->next->Start();
}
InvokeReadHandlerCallback<SocketType> ReadCallback;
};
/**
@class Socket
Base async socket implementation
@tparam T derived class type (CRTP)
@tparam Stream stream type used for operations on socket
Stream must implement the following methods:
@@ -53,21 +95,27 @@
template<typename ConstBufferSequence>
std::size_t write_some(ConstBufferSequence const& buffers, boost::system::error_code& error);
template<typename WaitHandlerType>
void async_wait(boost::asio::socket_base::wait_type type, WaitHandlerType&& handler);
template<typename SettableSocketOption>
void set_option(SettableSocketOption const& option, boost::system::error_code& error);
tcp::socket::endpoint_type remote_endpoint() const;
*/
template<class T, class Stream = boost::asio::ip::tcp::socket>
class Socket : public std::enable_shared_from_this<T>
template<class Stream = IoContextTcpSocket>
class Socket : public std::enable_shared_from_this<Socket<Stream>>
{
public:
template<typename... Args>
explicit Socket(boost::asio::ip::tcp::socket&& socket, Args&&... args) : _socket(std::move(socket), std::forward<Args>(args)...),
_remoteAddress(_socket.remote_endpoint().address()), _remotePort(_socket.remote_endpoint().port()),
_closed(false), _closing(false), _isWritingAsync(false)
explicit Socket(IoContextTcpSocket&& socket, Args&&... args) : _socket(std::move(socket), std::forward<Args>(args)...),
_remoteAddress(_socket.remote_endpoint().address()), _remotePort(_socket.remote_endpoint().port()), _openState(OpenState_Open)
{
}
template<typename... Args>
explicit Socket(boost::asio::io_context& context, Args&&... args) : _socket(context, std::forward<Args>(args)...), _openState(OpenState_Closed)
{
_readBuffer.Resize(READ_BLOCK_SIZE);
}
Socket(Socket const& other) = delete;
@@ -77,20 +125,20 @@ public:
virtual ~Socket()
{
_closed = true;
_openState = OpenState_Closed;
boost::system::error_code error;
_socket.close(error);
}
virtual void Start() = 0;
virtual void Start() { }
virtual bool Update()
{
if (_closed)
if (_openState == OpenState_Closed)
return false;
#ifndef TC_SOCKET_USE_IOCP
if (_isWritingAsync || (_writeQueue.empty() && !_closing))
if (_isWritingAsync || (_writeQueue.empty() && _openState == OpenState_Open))
return true;
for (; HandleQueue();)
@@ -100,7 +148,7 @@ public:
return true;
}
boost::asio::ip::address GetRemoteIpAddress() const
boost::asio::ip::address const& GetRemoteIpAddress() const
{
return _remoteAddress;
}
@@ -110,7 +158,8 @@ public:
return _remotePort;
}
void AsyncRead()
template <SocketReadCallback Callback>
void AsyncRead(Callback&& callback)
{
if (!IsOpen())
return;
@@ -118,23 +167,11 @@ public:
_readBuffer.Normalize();
_readBuffer.EnsureFreeSpace();
_socket.async_read_some(boost::asio::buffer(_readBuffer.GetWritePointer(), _readBuffer.GetRemainingSpace()),
[self = this->shared_from_this()](boost::system::error_code const& error, size_t transferredBytes)
[self = this->shared_from_this(), callback = std::forward<Callback>(callback)](boost::system::error_code const& error, size_t transferredBytes) mutable
{
self->ReadHandlerInternal(error, transferredBytes);
});
}
void AsyncReadWithCallback(void (T::*callback)(boost::system::error_code const&, std::size_t))
{
if (!IsOpen())
return;
_readBuffer.Normalize();
_readBuffer.EnsureFreeSpace();
_socket.async_read_some(boost::asio::buffer(_readBuffer.GetWritePointer(), _readBuffer.GetRemainingSpace()),
[self = this->shared_from_this(), callback](boost::system::error_code const& error, size_t transferredBytes)
{
(self.get()->*callback)(error, transferredBytes);
if (self->ReadHandlerInternal(error, transferredBytes))
if (callback() == SocketReadCallbackResult::KeepReading)
self->AsyncRead(std::forward<Callback>(callback));
});
}
@@ -147,11 +184,11 @@ public:
#endif
}
bool IsOpen() const { return !_closed && !_closing; }
bool IsOpen() const { return _openState == OpenState_Open; }
void CloseSocket()
{
if (_closed.exchange(true))
if ((_openState.fetch_or(OpenState_Closed) & OpenState_Closed) == 0)
return;
boost::system::error_code shutdownError;
@@ -160,13 +197,13 @@ public:
TC_LOG_DEBUG("network", "Socket::CloseSocket: {} errored when shutting down socket: {} ({})", GetRemoteIpAddress().to_string(),
shutdownError.value(), shutdownError.message());
OnClose();
this->OnClose();
}
/// Marks the socket for closing after write buffer becomes empty
void DelayedCloseSocket()
{
if (_closing.exchange(true))
if (_openState.fetch_or(OpenState_Closing) != 0)
return;
if (_writeQueue.empty())
@@ -175,10 +212,15 @@ public:
MessageBuffer& GetReadBuffer() { return _readBuffer; }
Stream& underlying_stream()
{
return _socket;
}
protected:
virtual void OnClose() { }
virtual void ReadHandler() = 0;
virtual SocketReadCallbackResult ReadHandler() { return SocketReadCallbackResult::KeepReading; }
bool AsyncProcessQueue()
{
@@ -195,10 +237,10 @@ protected:
self->WriteHandler(error, transferedBytes);
});
#else
_socket.async_write_some(boost::asio::null_buffers(),
[self = this->shared_from_this()](boost::system::error_code const& error, std::size_t transferedBytes)
_socket.async_wait(boost::asio::socket_base::wait_type::wait_write,
[self = this->shared_from_this()](boost::system::error_code const& error)
{
self->WriteHandlerWrapper(error, transferedBytes);
self->WriteHandlerWrapper(error);
});
#endif
@@ -214,22 +256,17 @@ protected:
GetRemoteIpAddress().to_string(), err.value(), err.message());
}
Stream& underlying_stream()
{
return _socket;
}
private:
void ReadHandlerInternal(boost::system::error_code const& error, size_t transferredBytes)
bool ReadHandlerInternal(boost::system::error_code const& error, size_t transferredBytes)
{
if (error)
{
CloseSocket();
return;
return false;
}
_readBuffer.WriteCompleted(transferredBytes);
ReadHandler();
return IsOpen();
}
#ifdef TC_SOCKET_USE_IOCP
@@ -245,7 +282,7 @@ private:
if (!_writeQueue.empty())
AsyncProcessQueue();
else if (_closing)
else if (_openState == OpenState_Closing)
CloseSocket();
}
else
@@ -254,7 +291,7 @@ private:
#else
void WriteHandlerWrapper(boost::system::error_code const& /*error*/, std::size_t /*transferedBytes*/)
void WriteHandlerWrapper(boost::system::error_code const& /*error*/)
{
_isWritingAsync = false;
HandleQueue();
@@ -278,14 +315,14 @@ private:
return AsyncProcessQueue();
_writeQueue.pop();
if (_closing && _writeQueue.empty())
if (_openState == OpenState_Closing && _writeQueue.empty())
CloseSocket();
return false;
}
else if (bytesSent == 0)
{
_writeQueue.pop();
if (_closing && _writeQueue.empty())
if (_openState == OpenState_Closing && _writeQueue.empty())
CloseSocket();
return false;
}
@@ -296,7 +333,7 @@ private:
}
_writeQueue.pop();
if (_closing && _writeQueue.empty())
if (_openState == OpenState_Closing && _writeQueue.empty())
CloseSocket();
return !_writeQueue.empty();
}
@@ -306,15 +343,20 @@ private:
Stream _socket;
boost::asio::ip::address _remoteAddress;
uint16 _remotePort;
uint16 _remotePort = 0;
MessageBuffer _readBuffer;
MessageBuffer _readBuffer = MessageBuffer(READ_BLOCK_SIZE);
std::queue<MessageBuffer> _writeQueue;
std::atomic<bool> _closed;
std::atomic<bool> _closing;
// Socket open state "enum" (not enum to enable integral std::atomic api)
static constexpr uint8 OpenState_Open = 0x0;
static constexpr uint8 OpenState_Closing = 0x1; ///< Transition to Closed state after sending all queued data
static constexpr uint8 OpenState_Closed = 0x2;
bool _isWritingAsync;
std::atomic<uint8> _openState;
bool _isWritingAsync = false;
};
}
#endif // __SOCKET_H__
#endif // TRINITYCORE_SOCKET_H

48
src/server/shared/Networking/SocketMgr.h
View File

@@ -15,32 +15,40 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SocketMgr_h__
#define SocketMgr_h__
#ifndef TRINITYCORE_SOCKET_MGR_H
#define TRINITYCORE_SOCKET_MGR_H
#include "AsyncAcceptor.h"
#include "Errors.h"
#include "NetworkThread.h"
#include "Socket.h"
#include <boost/asio/ip/tcp.hpp>
#include <memory>
namespace Trinity::Net
{
template<class SocketType>
class SocketMgr
{
public:
SocketMgr(SocketMgr const&) = delete;
SocketMgr(SocketMgr&&) = delete;
SocketMgr& operator=(SocketMgr const&) = delete;
SocketMgr& operator=(SocketMgr&&) = delete;
virtual ~SocketMgr()
{
ASSERT(!_threads && !_acceptor && !_threadCount, "StopNetwork must be called prior to SocketMgr destruction");
}
virtual bool StartNetwork(Trinity::Asio::IoContext& ioContext, std::string const& bindIp, uint16 port, int threadCount)
virtual bool StartNetwork(Asio::IoContext& ioContext, std::string const& bindIp, uint16 port, int threadCount)
{
ASSERT(threadCount > 0);
AsyncAcceptor* acceptor = nullptr;
std::unique_ptr<AsyncAcceptor> acceptor = nullptr;
try
{
acceptor = new AsyncAcceptor(ioContext, bindIp, port);
acceptor = std::make_unique<AsyncAcceptor>(ioContext, bindIp, port);
}
catch (boost::system::system_error const& err)
{
@@ -51,13 +59,12 @@ public:
if (!acceptor->Bind())
{
TC_LOG_ERROR("network", "StartNetwork failed to bind socket acceptor");
delete acceptor;
return false;
}
_acceptor = acceptor;
_acceptor = std::move(acceptor);
_threadCount = threadCount;
_threads = CreateThreads();
_threads.reset(CreateThreads());
ASSERT(_threads);
@@ -73,27 +80,23 @@ public:
{
_acceptor->Close();
if (_threadCount != 0)
for (int32 i = 0; i < _threadCount; ++i)
_threads[i].Stop();
for (int32 i = 0; i < _threadCount; ++i)
_threads[i].Stop();
Wait();
delete _acceptor;
_acceptor = nullptr;
delete[] _threads;
_threads = nullptr;
_threadCount = 0;
}
void Wait()
{
if (_threadCount != 0)
for (int32 i = 0; i < _threadCount; ++i)
_threads[i].Wait();
for (int32 i = 0; i < _threadCount; ++i)
_threads[i].Wait();
}
virtual void OnSocketOpen(boost::asio::ip::tcp::socket&& sock, uint32 threadIndex)
virtual void OnSocketOpen(IoContextTcpSocket&& sock, uint32 threadIndex)
{
try
{
@@ -121,22 +124,23 @@ public:
return min;
}
std::pair<boost::asio::ip::tcp::socket*, uint32> GetSocketForAccept()
std::pair<IoContextTcpSocket*, uint32> GetSocketForAccept()
{
uint32 threadIndex = SelectThreadWithMinConnections();
return std::make_pair(_threads[threadIndex].GetSocketForAccept(), threadIndex);
}
protected:
SocketMgr() : _acceptor(nullptr), _threads(nullptr), _threadCount(0)
SocketMgr() : _threadCount(0)
{
}
virtual NetworkThread<SocketType>* CreateThreads() const = 0;
AsyncAcceptor* _acceptor;
NetworkThread<SocketType>* _threads;
std::unique_ptr<AsyncAcceptor> _acceptor;
std::unique_ptr<NetworkThread<SocketType>[]> _threads;
int32 _threadCount;
};
}
#endif // SocketMgr_h__
#endif // TRINITYCORE_SOCKET_MGR_H

88
src/server/shared/Networking/SslSocket.h
View File

@@ -1,88 +0,0 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SslSocket_h__
#define SslSocket_h__
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl/stream.hpp>
#include <boost/system/error_code.hpp>
namespace boostssl = boost::asio::ssl;
template<class Stream = boostssl::stream<boost::asio::ip::tcp::socket>>
class SslSocket
{
public:
explicit SslSocket(boost::asio::ip::tcp::socket&& socket, boost::asio::ssl::context& sslContext) : _sslSocket(std::move(socket), sslContext)
{
_sslSocket.set_verify_mode(boostssl::verify_none);
}
// adapting tcp::socket api
void close(boost::system::error_code& error)
{
_sslSocket.lowest_layer().close(error);
}
void shutdown(boost::asio::socket_base::shutdown_type what, boost::system::error_code& shutdownError)
{
_sslSocket.shutdown(shutdownError);
_sslSocket.lowest_layer().shutdown(what, shutdownError);
}
template<typename MutableBufferSequence, typename ReadHandlerType>
void async_read_some(MutableBufferSequence const& buffers, ReadHandlerType&& handler)
{
_sslSocket.async_read_some(buffers, std::move(handler));
}
template<typename ConstBufferSequence, typename WriteHandlerType>
void async_write_some(ConstBufferSequence const& buffers, WriteHandlerType&& handler)
{
_sslSocket.async_write_some(buffers, std::move(handler));
}
template<typename ConstBufferSequence>
std::size_t write_some(ConstBufferSequence const& buffers, boost::system::error_code& error)
{
return _sslSocket.write_some(buffers, error);
}
template<typename SettableSocketOption>
void set_option(SettableSocketOption const& option, boost::system::error_code& error)
{
_sslSocket.lowest_layer().set_option(option, error);
}
boost::asio::ip::tcp::socket::endpoint_type remote_endpoint() const
{
return _sslSocket.lowest_layer().remote_endpoint();
}
// ssl api
template<typename HandshakeHandlerType>
void async_handshake(boostssl::stream_base::handshake_type type, HandshakeHandlerType&& handler)
{
_sslSocket.async_handshake(type, std::move(handler));
}
protected:
Stream _sslSocket;
};
#endif // SslSocket_h__

131
src/server/shared/Networking/SslStream.h Normal file
View File

@@ -0,0 +1,131 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TRINITYCORE_SSL_STREAM_H
#define TRINITYCORE_SSL_STREAM_H
#include "SocketConnectionInitializer.h"
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl/stream.hpp>
#include <boost/system/error_code.hpp>
namespace Trinity::Net
{
template <typename SocketImpl>
struct SslHandshakeConnectionInitializer final : SocketConnectionInitializer
{
explicit SslHandshakeConnectionInitializer(SocketImpl* socket) : _socket(socket) { }
void Start() override
{
_socket->underlying_stream().async_handshake(boost::asio::ssl::stream_base::server,
[socketRef = _socket->weak_from_this(), self = this->shared_from_this()](boost::system::error_code const& error)
{
std::shared_ptr<SocketImpl> socket = static_pointer_cast<SocketImpl>(socketRef.lock());
if (!socket)
return;
if (error)
{
TC_LOG_ERROR("session", "{} SSL Handshake failed {}", socket->GetClientInfo(), error.message());
socket->CloseSocket();
return;
}
if (self->next)
self->next->Start();
});
}
private:
SocketImpl* _socket;
};
template<class WrappedStream = IoContextTcpSocket>
class SslStream
{
public:
explicit SslStream(IoContextTcpSocket&& socket, boost::asio::ssl::context& sslContext) : _sslSocket(std::move(socket), sslContext)
{
_sslSocket.set_verify_mode(boost::asio::ssl::verify_none);
}
explicit SslStream(boost::asio::io_context& context, boost::asio::ssl::context& sslContext) : _sslSocket(context, sslContext)
{
_sslSocket.set_verify_mode(boost::asio::ssl::verify_none);
}
// adapting tcp::socket api
void close(boost::system::error_code& error)
{
_sslSocket.next_layer().close(error);
}
void shutdown(boost::asio::socket_base::shutdown_type what, boost::system::error_code& shutdownError)
{
_sslSocket.shutdown(shutdownError);
_sslSocket.next_layer().shutdown(what, shutdownError);
}
template<typename MutableBufferSequence, typename ReadHandlerType>
void async_read_some(MutableBufferSequence const& buffers, ReadHandlerType&& handler)
{
_sslSocket.async_read_some(buffers, std::forward<ReadHandlerType>(handler));
}
template<typename ConstBufferSequence, typename WriteHandlerType>
void async_write_some(ConstBufferSequence const& buffers, WriteHandlerType&& handler)
{
_sslSocket.async_write_some(buffers, std::forward<WriteHandlerType>(handler));
}
template<typename ConstBufferSequence>
std::size_t write_some(ConstBufferSequence const& buffers, boost::system::error_code& error)
{
return _sslSocket.write_some(buffers, error);
}
template<typename WaitHandlerType>
void async_wait(boost::asio::socket_base::wait_type type, WaitHandlerType&& handler)
{
_sslSocket.next_layer().async_wait(type, std::forward<WaitHandlerType>(handler));
}
template<typename SettableSocketOption>
void set_option(SettableSocketOption const& option, boost::system::error_code& error)
{
_sslSocket.next_layer().set_option(option, error);
}
IoContextTcpSocket::endpoint_type remote_endpoint() const
{
return _sslSocket.next_layer().remote_endpoint();
}
// ssl api
template<typename HandshakeHandlerType>
void async_handshake(boost::asio::ssl::stream_base::handshake_type type, HandshakeHandlerType&& handler)
{
_sslSocket.async_handshake(type, std::forward<HandshakeHandlerType>(handler));
}
protected:
boost::asio::ssl::stream<WrappedStream> _sslSocket;
};
}
#endif // TRINITYCORE_SSL_STREAM_H

22
src/server/worldserver/Main.cpp
View File

@@ -15,10 +15,6 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/// \addtogroup Trinityd Trinity Daemon
/// @{
/// \file
#include "Common.h"
#include "AppenderDB.h"
#include "AsyncAcceptor.h"
@@ -122,7 +118,7 @@ private:
};
void SignalHandler(boost::system::error_code const& error, int signalNumber);
AsyncAcceptor* StartRaSocketAcceptor(Trinity::Asio::IoContext& ioContext);
std::unique_ptr<Trinity::Net::AsyncAcceptor> StartRaSocketAcceptor(Trinity::Asio::IoContext& ioContext);
bool StartDB();
void StopDB();
void WorldUpdateLoop();
@@ -372,9 +368,9 @@ int main(int argc, char** argv)
auto battlegroundMgrHandle = Trinity::make_unique_ptr_with_deleter<&BattlegroundMgr::DeleteAllBattlegrounds>(sBattlegroundMgr);
// Start the Remote Access port (acceptor) if enabled
std::unique_ptr<AsyncAcceptor> raAcceptor;
std::unique_ptr<Trinity::Net::AsyncAcceptor> raAcceptor;
if (sConfigMgr->GetBoolDefault("Ra.Enable", false))
raAcceptor.reset(StartRaSocketAcceptor(*ioContext));
raAcceptor = StartRaSocketAcceptor(*ioContext);
// Start soap serving thread if enabled
std::unique_ptr<std::thread, ShutdownTCSoapThread> soapThread;
@@ -632,20 +628,23 @@ void FreezeDetector::Handler(std::weak_ptr<FreezeDetector> freezeDetectorRef, bo
}
}
AsyncAcceptor* StartRaSocketAcceptor(Trinity::Asio::IoContext& ioContext)
std::unique_ptr<Trinity::Net::AsyncAcceptor> StartRaSocketAcceptor(Trinity::Asio::IoContext& ioContext)
{
uint16 raPort = uint16(sConfigMgr->GetIntDefault("Ra.Port", 3443));
std::string raListener = sConfigMgr->GetStringDefault("Ra.IP", "0.0.0.0");
AsyncAcceptor* acceptor = new AsyncAcceptor(ioContext, raListener, raPort);
std::unique_ptr<Trinity::Net::AsyncAcceptor> acceptor = std::make_unique<Trinity::Net::AsyncAcceptor>(ioContext, raListener, raPort);
if (!acceptor->Bind())
{
TC_LOG_ERROR("server.worldserver", "Failed to bind RA socket acceptor");
delete acceptor;
return nullptr;
}
acceptor->AsyncAccept<RASession>();
acceptor->AsyncAccept([](Trinity::Net::IoContextTcpSocket&& sock, uint32 /*threadIndex*/)
{
std::make_shared<RASession>(std::move(sock))->Start();
});
return acceptor;
}
@@ -696,7 +695,6 @@ void ClearOnlineAccounts(uint32 realmId)
// Battleground instance ids reset at server restart
CharacterDatabase.DirectExecute("UPDATE character_battleground_data SET instanceId = 0");
}
/// @}
variables_map GetConsoleArguments(int argc, char** argv, fs::path& configFile, fs::path& configDir, [[maybe_unused]] std::string& winServiceAction)
{

4
src/server/worldserver/RemoteAccess/RASession.cpp
View File

@@ -29,9 +29,11 @@
void RASession::Start()
{
_socket.non_blocking(false);
// wait 1 second for active connections to send negotiation request
for (int counter = 0; counter < 10 && _socket.available() == 0; counter++)
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::this_thread::sleep_for(100ms);
// Check if there are bytes available, if they are, then the client is requesting the negotiation
if (_socket.available() > 0)

9
src/server/worldserver/RemoteAccess/RASession.h
View File

@@ -15,10 +15,11 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __RASESSION_H__
#define __RASESSION_H__
#ifndef TRINITYCORE_RA_SESSION_H
#define TRINITYCORE_RA_SESSION_H
#include "Define.h"
#include "Socket.h"
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/streambuf.hpp>
#include <future>
@@ -29,7 +30,7 @@ const size_t bufferSize = 4096;
class RASession : public std::enable_shared_from_this <RASession>
{
public:
RASession(boost::asio::ip::tcp::socket&& socket) : _socket(std::move(socket)), _commandExecuting(nullptr)
RASession(Trinity::Net::IoContextTcpSocket&& socket) : _socket(std::move(socket)), _commandExecuting(nullptr)
{
}
@@ -47,7 +48,7 @@ private:
static void CommandPrint(void* callbackArg, std::string_view text);
static void CommandFinished(void* callbackArg, bool);
boost::asio::ip::tcp::socket _socket;
Trinity::Net::IoContextTcpSocket _socket;
boost::asio::streambuf _readBuffer;
boost::asio::streambuf _writeBuffer;
std::promise<void>* _commandExecuting;