Dep/Boost: Partial support for boost 1.74 - asio

Ref #25470

(cherry picked from commit 155e37831e9c581c6a8ebba34fe70d3459301d0a)

6 files changed, 43 insertions, 67 deletions

diff --git a/src/common/Asio/AsioHacksFwd.h b/src/common/Asio/AsioHacksFwd.h
index 4f245ee9ae7..6030436d39d 100644
--- a/src/common/Asio/AsioHacksFwd.h
+++ b/src/common/Asio/AsioHacksFwd.h
@@ -46,36 +46,6 @@ namespace boost
 
             typedef basic_endpoint<tcp> tcp_endpoint;
         }
-#if BOOST_VERSION >= 107000
-        class executor;
-
-        namespace ip
-        {
-            template <typename InternetProtocol, typename Executor>
-            class basic_resolver;
-
-            typedef basic_resolver<tcp, executor> tcp_resolver;
-        }
-#elif BOOST_VERSION >= 106600
-        namespace ip
-        {
-            template <typename InternetProtocol>
-            class basic_resolver;
-
-            typedef basic_resolver<tcp> tcp_resolver;
-        }
-#else
-        namespace ip
-        {
-            template <typename InternetProtocol>
-            class resolver_service;
-
-            template <typename InternetProtocol, typename ResolverService>
-            class basic_resolver;
-
-            typedef basic_resolver<tcp, resolver_service<tcp>> tcp_resolver;
-        }
-#endif
     }
 }
 
@@ -83,6 +53,9 @@ namespace Trinity
 {
     namespace Asio
     {
+        class DeadlineTimer;
+        class IoContext;
+        class Resolver;
         class Strand;
     }
 }
diff --git a/src/common/Asio/Resolver.h b/src/common/Asio/Resolver.h
index 3a123b47cb9..b63747b139e 100644
--- a/src/common/Asio/Resolver.h
+++ b/src/common/Asio/Resolver.h
@@ -18,34 +18,48 @@
 #ifndef Resolver_h__
 #define Resolver_h__
 
+#include "IoContext.h"
 #include "Optional.h"
 #include <boost/asio/ip/tcp.hpp>
 #include <string>
 
 namespace Trinity
 {
-    namespace Net
+    namespace Asio
     {
-        inline Optional<boost::asio::ip::tcp::endpoint> Resolve(boost::asio::ip::tcp::resolver& resolver, boost::asio::ip::tcp const& protocol,
-            std::string const& host, std::string const& service)
+        /**
+          Hack to make it possible to forward declare resolver (one of its template arguments is a typedef to something super long and using nested classes)
+        */
+        class Resolver
         {
-            boost::system::error_code ec;
+        public:
+            explicit Resolver(IoContext& ioContext) : _impl(ioContext) { }
+
+            Optional<boost::asio::ip::tcp::endpoint> Resolve(boost::asio::ip::tcp const& protocol, std::string const& host, std::string const& service)
+            {
+                boost::system::error_code ec;
 #if BOOST_VERSION >= 106600
-            boost::asio::ip::tcp::resolver::results_type results = resolver.resolve(protocol, host, service, ec);
-            if (results.empty() || ec)
-                return {};
+                boost::asio::ip::resolver_base::flags flagsResolver = boost::asio::ip::resolver_base::all_matching;
+                boost::asio::ip::tcp::resolver::results_type results = _impl.resolve(protocol, host, service, flagsResolver, ec);
+                if (results.begin() == results.end() || ec)
+                    return {};
 
-            return results.begin()->endpoint();
+                return results.begin()->endpoint();
 #else
-            boost::asio::ip::tcp::resolver::query query(std::move(protocol), std::move(host), std::move(service));
-            boost::asio::ip::tcp::resolver::iterator itr = resolver.resolve(query, ec);
-            boost::asio::ip::tcp::resolver::iterator end;
-            if (itr == end || ec)
-                return {};
+                boost::asio::ip::resolver_query_base::flags flagsQuery = boost::asio::ip::tcp::resolver::query::all_matching;
+                boost::asio::ip::tcp::resolver::query query(std::move(protocol), std::move(host), std::move(service), flagsQuery);
+                boost::asio::ip::tcp::resolver::iterator itr = _impl.resolve(query, ec);
+                boost::asio::ip::tcp::resolver::iterator end;
+                if (itr == end || ec)
+                    return {};
 
-            return itr->endpoint();
+                return itr->endpoint();
 #endif
-        }
+            }
+
+        private:
+            boost::asio::ip::tcp::resolver _impl;
+        };
     }
 }
 
diff --git a/src/server/bnetserver/REST/LoginRESTService.cpp b/src/server/bnetserver/REST/LoginRESTService.cpp
index 16ce194b190..4463438f6e2 100644
--- a/src/server/bnetserver/REST/LoginRESTService.cpp
+++ b/src/server/bnetserver/REST/LoginRESTService.cpp
@@ -82,10 +82,10 @@ bool LoginRESTService::Start(Trinity::Asio::IoContext* ioContext)
         _port = 8081;
     }
 
-    boost::asio::ip::tcp::resolver resolver(*ioContext);
+    Trinity::Asio::Resolver resolver(*ioContext);
 
     std::string configuredAddress = sConfigMgr->GetStringDefault("LoginREST.ExternalAddress", "127.0.0.1");
-    Optional<boost::asio::ip::tcp::endpoint> externalAddress = Trinity::Net::Resolve(resolver, boost::asio::ip::tcp::v4(), configuredAddress, std::to_string(_port));
+    Optional<boost::asio::ip::tcp::endpoint> externalAddress = resolver.Resolve(boost::asio::ip::tcp::v4(), configuredAddress, std::to_string(_port));
     if (!externalAddress)
     {
         TC_LOG_ERROR("server.rest", "Could not resolve LoginREST.ExternalAddress %s", configuredAddress.c_str());
@@ -95,7 +95,7 @@ bool LoginRESTService::Start(Trinity::Asio::IoContext* ioContext)
     _externalAddress = *externalAddress;
 
     configuredAddress = sConfigMgr->GetStringDefault("LoginREST.LocalAddress", "127.0.0.1");
-    Optional<boost::asio::ip::tcp::endpoint> localAddress = Trinity::Net::Resolve(resolver, boost::asio::ip::tcp::v4(), configuredAddress, std::to_string(_port));
+    Optional<boost::asio::ip::tcp::endpoint> localAddress = resolver.Resolve(boost::asio::ip::tcp::v4(), configuredAddress, std::to_string(_port));
     if (!localAddress)
     {
         TC_LOG_ERROR("server.rest", "Could not resolve LoginREST.LocalAddress %s", configuredAddress.c_str());
diff --git a/src/server/shared/Realm/RealmList.cpp b/src/server/shared/Realm/RealmList.cpp
index 9baf4d35615..094982d001c 100644
--- a/src/server/shared/Realm/RealmList.cpp
+++ b/src/server/shared/Realm/RealmList.cpp
@@ -38,9 +38,7 @@ RealmList::RealmList() : _updateInterval(0)
     _realmsMutex = std::make_unique<boost::shared_mutex>();
 }
 
-RealmList::~RealmList()
-{
-}
+RealmList::~RealmList() = default;
 
 RealmList* RealmList::Instance()
 {
@@ -53,7 +51,7 @@ void RealmList::Initialize(Trinity::Asio::IoContext& ioContext, uint32 updateInt
 {
     _updateInterval = updateInterval;
     _updateTimer = std::make_unique<Trinity::Asio::DeadlineTimer>(ioContext);
-    _resolver = std::make_unique<boost::asio::ip::tcp::resolver>(ioContext);
+    _resolver = std::make_unique<Trinity::Asio::Resolver>(ioContext);
 
     LoadBuildInfo();
     // Get the content of the realmlist table in the database
@@ -151,21 +149,21 @@ void RealmList::UpdateRealms(boost::system::error_code const& error)
                 std::string localAddressString = fields[3].GetString();
                 std::string localSubmaskString = fields[4].GetString();
 
-                Optional<boost::asio::ip::tcp::endpoint> externalAddress = Trinity::Net::Resolve(*_resolver, boost::asio::ip::tcp::v4(), externalAddressString, "");
+                Optional<boost::asio::ip::tcp::endpoint> externalAddress = _resolver->Resolve(boost::asio::ip::tcp::v4(), externalAddressString, "");
                 if (!externalAddress)
                 {
                     TC_LOG_ERROR("realmlist", "Could not resolve address %s for realm \"%s\" id %u", externalAddressString.c_str(), name.c_str(), realmId);
                     continue;
                 }
 
-                Optional<boost::asio::ip::tcp::endpoint> localAddress = Trinity::Net::Resolve(*_resolver, boost::asio::ip::tcp::v4(), localAddressString, "");
+                Optional<boost::asio::ip::tcp::endpoint> localAddress = _resolver->Resolve(boost::asio::ip::tcp::v4(), localAddressString, "");
                 if (!localAddress)
                 {
                     TC_LOG_ERROR("realmlist", "Could not resolve localAddress %s for realm \"%s\" id %u", localAddressString.c_str(), name.c_str(), realmId);
                     continue;
                 }
 
-                Optional<boost::asio::ip::tcp::endpoint> localSubmask = Trinity::Net::Resolve(*_resolver, boost::asio::ip::tcp::v4(), localSubmaskString, "");
+                Optional<boost::asio::ip::tcp::endpoint> localSubmask = _resolver->Resolve(boost::asio::ip::tcp::v4(), localSubmaskString, "");
                 if (!localSubmask)
                 {
                     TC_LOG_ERROR("realmlist", "Could not resolve localSubnetMask %s for realm \"%s\" id %u", localSubmaskString.c_str(), name.c_str(), realmId);
diff --git a/src/server/shared/Realm/RealmList.h b/src/server/shared/Realm/RealmList.h
index 7475a4b0dc7..bd7270e73a3 100644
--- a/src/server/shared/Realm/RealmList.h
+++ b/src/server/shared/Realm/RealmList.h
@@ -69,15 +69,6 @@ namespace JSON
     }
 }
 
-namespace Trinity
-{
-    namespace Asio
-    {
-        class IoContext;
-        class DeadlineTimer;
-    }
-}
-
 /// Storage object for the list of realms on the server
 class TC_SHARED_API RealmList
 {
@@ -116,7 +107,7 @@ private:
     std::unordered_set<std::string> _subRegions;
     uint32 _updateInterval;
     std::unique_ptr<Trinity::Asio::DeadlineTimer> _updateTimer;
-    std::unique_ptr<boost::asio::ip::tcp_resolver> _resolver;
+    std::unique_ptr<Trinity::Asio::Resolver> _resolver;
 };
 
 #define sRealmList RealmList::Instance()
diff --git a/src/tools/extractor_common/CascHandles.cpp b/src/tools/extractor_common/CascHandles.cpp
index c4ff0db19db..49c7e261705 100644
--- a/src/tools/extractor_common/CascHandles.cpp
+++ b/src/tools/extractor_common/CascHandles.cpp
@@ -64,9 +64,9 @@ namespace
         sslContext.set_options(boost::asio::ssl::context::no_tlsv1_1, error);
         sslContext.set_default_verify_paths(error);
 
-        boost::asio::ip::tcp::resolver resolver(ioContext);
+        Trinity::Asio::Resolver resolver(ioContext);
 
-        Optional<boost::asio::ip::tcp::endpoint> endpoint = Trinity::Net::Resolve(resolver, boost::asio::ip::tcp::v4(), serverName, std::to_string(port));
+        Optional<boost::asio::ip::tcp::endpoint> endpoint = resolver.Resolve(boost::asio::ip::tcp::v4(), serverName, std::to_string(port));
         if (!endpoint)
             return {};