Update Boost library version to 1.87

ig15 · ig15 · commit 7cb3478c26d0 · 2025-01-22T09:38:16.000Z
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -92,7 +92,7 @@ endif(BUILD_TESTS)
 set(Boost_USE_STATIC_LIBS ON)
 set(Boost_USE_DEBUG_RUNTIME OFF)
 #set_property(GLOBAL PROPERTY Boost_USE_MULTITHREADED ON)
-set(BOOST_PKG_VERSION "1.81.0" CACHE STRING "")
+set(BOOST_PKG_VERSION "1.87.0" CACHE STRING "")
 find_package(Boost ${BOOST_PKG_VERSION} REQUIRED COMPONENTS system log log_setup thread program_options date_time filesystem chrono)
 include_directories(${Boost_INCLUDE_DIRS})
 foreach(BOOST_LIB ${Boost_LIBRARIES})
diff --git a/README.md b/README.md
@@ -112,7 +112,7 @@ and you can add ` -p <port_number>` to expose a port from the docker container.
 * C++ 14 compiler
 * CMake 3.6+
 * Development libraries required:
-    * Boost 1.81
+    * Boost 1.87
     * Protobuf 3.17.x
     * zlib 1.12.13+
     * OpenSSL 1.0+ OR OpenSSL 3
@@ -141,9 +141,9 @@ Fedora example:
 
 #### 2. Download and install Boost dependency
 
-    wget https://boostorg.jfrog.io/artifactory/main/release/1.81.0/source/boost_1_81_0.tar.gz -O /tmp/boost.tar.gz
-    tar xzvf /tmp/boost.tar.gz
-    cd boost_1_81_0
+    wget https://sourceforge.net/projects/boost/files/boost/1.87.0/boost_1_87_0.tar.gz/download -O /tmp/boost_1_87_0.tar.gz
+    tar xzvf /tmp/boost_1_87_0.tar.gz
+    cd boost_1_87_0
     ./bootstrap.sh
     sudo ./b2 install link=static
 
diff --git a/src/LocalproxyConfig.h b/src/LocalproxyConfig.h
@@ -17,7 +17,7 @@
 #include <boost/beast/websocket.hpp>
 #include <boost/beast/websocket/ssl.hpp>
 #include <boost/asio.hpp>
-#include <boost/asio/ssl/rfc2818_verification.hpp>
+#include <boost/asio/ssl/host_name_verification.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/format.hpp>
 #include <boost/property_tree/ptree.hpp>
diff --git a/src/TcpAdapterProxy.cpp b/src/TcpAdapterProxy.cpp
@@ -6,7 +6,7 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/asio.hpp>
-#include <boost/asio/ssl/rfc2818_verification.hpp>
+#include <boost/asio/ssl/host_name_verification.hpp>
 #include <boost/beast/websocket.hpp>
 #include <boost/beast/core/flat_buffer.hpp>
 #include <boost/endian/conversion.hpp>
@@ -923,7 +923,7 @@ namespace aws { namespace iot { namespace securedtunneling {
                 if (!localproxy_config.no_ssl_host_verify)
                 {
                     tac.wss->set_ssl_verify_mode(boost::asio::ssl::verify_peer | boost::asio::ssl::verify_fail_if_no_peer_cert);
-                    tac.wss->set_verify_callback(boost::asio::ssl::rfc2818_verification(tac.adapter_config.proxy_host));
+                    tac.wss->set_verify_callback(boost::asio::ssl::host_name_verification(tac.adapter_config.proxy_host));
                 }
                 else
                 {
@@ -974,7 +974,7 @@ namespace aws { namespace iot { namespace securedtunneling {
             }
             else
             {
-                BOOST_LOG_SEV(log, debug) << "Resolved proxy server IP: " << results->endpoint().address();
+                BOOST_LOG_SEV(log, debug) << "Resolved proxy server IP: " << results.begin()->endpoint().address();
                 //next connect tcp
                 tac.wss->lowest_layer().async_connect(*results.begin(), on_tcp_connect);
             }
@@ -986,8 +986,8 @@ namespace aws { namespace iot { namespace securedtunneling {
                 BOOST_LOG_SEV(log, error) << (boost::format("Could not resolve DNS hostname of Web proxy: %1% - %2%") % tac.adapter_config.web_proxy_host % ec.message()).str();
                 basic_retry_execute(log, retry_config, [&]() { std::bind(&tcp_adapter_proxy::web_socket_close_and_stop, this, std::ref(tac)); });
             } else {
-                BOOST_LOG_SEV(log, debug) << "Resolved Web proxy IP: " << results->endpoint().address();
-                web_proxy_adapter.async_connect(on_tcp_connect, tac.wss, results->endpoint());
+                BOOST_LOG_SEV(log, debug) << "Resolved Web proxy IP: " << results.begin()->endpoint().address();
+                web_proxy_adapter.async_connect(on_tcp_connect, tac.wss, results.begin()->endpoint());
             }
         };
 
@@ -1935,17 +1935,17 @@ namespace aws { namespace iot { namespace securedtunneling {
                 }
                 else
                 {
-                    BOOST_LOG_SEV(log, debug) << "Resolved bind IP: " << results->endpoint().address().to_string();
+                    BOOST_LOG_SEV(log, debug) << "Resolved bind IP: " << results.begin()->endpoint().address().to_string();
                     boost::system::error_code bind_ec;
-                    server->acceptor_.open(results->endpoint().protocol());
+                    server->acceptor_.open(results.begin()->endpoint().protocol());
                     if (port_to_connect)
                     {   //if data port is 0 (means pick an empheral port), then don't set this option
                         server->acceptor_.set_option(reuse_addr_option);
                     }
-                    server->acceptor_.bind(results->endpoint(), bind_ec);
+                    server->acceptor_.bind(results.begin()->endpoint(), bind_ec);
                     if (bind_ec)
                     {
-                        BOOST_LOG_SEV(log, error) << (boost::format("Could not bind to address: %1%:%2% -- %3%") % results->endpoint().address().to_string() % results->endpoint().port() % bind_ec.message()).str();
+                        BOOST_LOG_SEV(log, error) << (boost::format("Could not bind to address: %1%:%2% -- %3%") % results.begin()->endpoint().address().to_string() % results.begin()->endpoint().port() % bind_ec.message()).str();
                         basic_retry_execute(log, retry_config,
                             []() { throw proxy_exception(SOURCE_LOCAL_PROXY_PORT_BIND_EXCEPTION); });
                     }
@@ -1958,7 +1958,7 @@ namespace aws { namespace iot { namespace securedtunneling {
                         if (listen_ec)
                         {
                             BOOST_LOG_SEV(log, error) << (boost::format("Could not listen on bind address: %1%:%2% -- %3%")
-                                % results->endpoint().address().to_string() % local_port % listen_ec.message()).str();
+                                % results.begin()->endpoint().address().to_string() % local_port % listen_ec.message()).str();
                             basic_retry_execute(log, retry_config,
                                 []() { throw proxy_exception(SOURCE_LOCAL_PROXY_PORT_BIND_EXCEPTION); });
                         }
@@ -2057,8 +2057,8 @@ namespace aws { namespace iot { namespace securedtunneling {
         }
         else {
             tcp_client::pointer client = tac.serviceId_to_tcp_client_map[service_id];
-            std::string dst_host = results->endpoint().address().to_string();
-            unsigned short dst_port = results->endpoint().port();
+            std::string dst_host = results.begin()->endpoint().address().to_string();
+            unsigned short dst_port = results.begin()->endpoint().port();
             BOOST_LOG_SEV(log, debug) << "Resolved destination host to IP: " << dst_host << ", connecting ...";
 
             boost::system::error_code connect_ec;
@@ -2137,7 +2137,7 @@ namespace aws { namespace iot { namespace securedtunneling {
             }
             else
             {
-                BOOST_LOG_SEV(log, debug) << "Resolved bind IP: " << results->endpoint().address().to_string();
+                BOOST_LOG_SEV(log, debug) << "Resolved bind IP: " << results.begin()->endpoint().address().to_string();
 
                 tuple<string, string> endpoint_to_connect = tcp_adapter_proxy::get_host_and_port(endpoint, tac.adapter_config.bind_address.get());
                 std::string dst_host = std::get<0>(endpoint_to_connect);
diff --git a/src/TcpAdapterProxy.h b/src/TcpAdapterProxy.h
@@ -16,7 +16,7 @@
 #include <boost/beast/websocket.hpp>
 #include <boost/beast/websocket/ssl.hpp>
 #include <boost/asio.hpp>
-#include <boost/asio/ssl/rfc2818_verification.hpp>
+#include <boost/asio/ssl/host_name_verification.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/format.hpp>
 #include <boost/property_tree/ptree.hpp>
diff --git a/src/WebProxyAdapter.cpp b/src/WebProxyAdapter.cpp
@@ -52,7 +52,7 @@ namespace aws {
             void WebProxyAdapter::async_ssl_handshake() {
                 if (!localproxy_config.no_ssl_host_verify) {
                     websocket_stream->get_web_proxy_ssl_stream()->set_verify_mode(ssl::verify_peer | ssl::verify_fail_if_no_peer_cert);
-                    websocket_stream->get_web_proxy_ssl_stream()->set_verify_callback(boost::asio::ssl::rfc2818_verification(localproxy_config.web_proxy_host));
+                    websocket_stream->get_web_proxy_ssl_stream()->set_verify_callback(boost::asio::ssl::host_name_verification(localproxy_config.web_proxy_host));
                 }
                 websocket_stream->get_web_proxy_ssl_stream()->async_handshake(ssl::stream_base::client, [this](error_code const &ec) {
                     if (ec) {
diff --git a/src/WebSocketStream.cpp b/src/WebSocketStream.cpp
@@ -163,7 +163,7 @@ namespace aws {
                 }
             }
 
-            void WebSocketStream::set_verify_callback(const ssl::rfc2818_verification &callback) {
+            void WebSocketStream::set_verify_callback(const ssl::host_name_verification &callback) {
                 if (localproxyConfig.is_web_proxy_using_tls) {
                     BOOST_LOG_SEV(*log, trace) << "Calling set_verify_callback with type: double_ssl_stream";
                     return double_ssl_stream->set_verify_callback(callback);
diff --git a/src/WebSocketStream.h b/src/WebSocketStream.h
@@ -142,7 +142,7 @@ namespace aws {
                  * proxy server and the localproxy.
                  * @param callback the SSL callback.
                  */
-                void set_verify_callback(const ssl::rfc2818_verification &callback);
+                void set_verify_callback(const ssl::host_name_verification &callback);
 
                 /**
                  * Performs the SSL handshake between the localproxy and the proxy server asynchronously.

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`#include <boost/algorithm/string.hpp>`
`7`	`7`	`#include <boost/lexical_cast.hpp>`
`8`	`8`	`#include <boost/asio.hpp>`
`9`		`-#include <boost/asio/ssl/rfc2818_verification.hpp>`
	`9`	`+#include <boost/asio/ssl/host_name_verification.hpp>`
`10`	`10`	`#include <boost/beast/websocket.hpp>`
`11`	`11`	`#include <boost/beast/core/flat_buffer.hpp>`
`12`	`12`	`#include <boost/endian/conversion.hpp>`
`@@ -923,7 +923,7 @@ namespace aws { namespace iot { namespace securedtunneling {`
`923`	`923`	`if (!localproxy_config.no_ssl_host_verify)`
`924`	`924`	`{`
`925`	`925`	`tac.wss->set_ssl_verify_mode(boost::asio::ssl::verify_peer \| boost::asio::ssl::verify_fail_if_no_peer_cert);`
`926`		`- tac.wss->set_verify_callback(boost::asio::ssl::rfc2818_verification(tac.adapter_config.proxy_host));`
	`926`	`+ tac.wss->set_verify_callback(boost::asio::ssl::host_name_verification(tac.adapter_config.proxy_host));`
`927`	`927`	`}`
`928`	`928`	`else`
`929`	`929`	`{`
`@@ -974,7 +974,7 @@ namespace aws { namespace iot { namespace securedtunneling {`
`974`	`974`	`}`
`975`	`975`	`else`
`976`	`976`	`{`
`977`		`- BOOST_LOG_SEV(log, debug) << "Resolved proxy server IP: " << results->endpoint().address();`
	`977`	`+ BOOST_LOG_SEV(log, debug) << "Resolved proxy server IP: " << results.begin()->endpoint().address();`
`978`	`978`	`//next connect tcp`
`979`	`979`	`tac.wss->lowest_layer().async_connect(*results.begin(), on_tcp_connect);`
`980`	`980`	`}`
`@@ -986,8 +986,8 @@ namespace aws { namespace iot { namespace securedtunneling {`
`986`	`986`	`BOOST_LOG_SEV(log, error) << (boost::format("Could not resolve DNS hostname of Web proxy: %1% - %2%") % tac.adapter_config.web_proxy_host % ec.message()).str();`
`987`	`987`	`basic_retry_execute(log, retry_config, [&]() { std::bind(&tcp_adapter_proxy::web_socket_close_and_stop, this, std::ref(tac)); });`
`988`	`988`	`} else {`
`989`		`- BOOST_LOG_SEV(log, debug) << "Resolved Web proxy IP: " << results->endpoint().address();`
`990`		`- web_proxy_adapter.async_connect(on_tcp_connect, tac.wss, results->endpoint());`
	`989`	`+ BOOST_LOG_SEV(log, debug) << "Resolved Web proxy IP: " << results.begin()->endpoint().address();`
	`990`	`+ web_proxy_adapter.async_connect(on_tcp_connect, tac.wss, results.begin()->endpoint());`
`991`	`991`	`}`
`992`	`992`	`};`
`993`	`993`
`@@ -1935,17 +1935,17 @@ namespace aws { namespace iot { namespace securedtunneling {`
`1935`	`1935`	`}`
`1936`	`1936`	`else`
`1937`	`1937`	`{`
`1938`		`- BOOST_LOG_SEV(log, debug) << "Resolved bind IP: " << results->endpoint().address().to_string();`
	`1938`	`+ BOOST_LOG_SEV(log, debug) << "Resolved bind IP: " << results.begin()->endpoint().address().to_string();`
`1939`	`1939`	`boost::system::error_code bind_ec;`
`1940`		`- server->acceptor_.open(results->endpoint().protocol());`
	`1940`	`+ server->acceptor_.open(results.begin()->endpoint().protocol());`
`1941`	`1941`	`if (port_to_connect)`
`1942`	`1942`	`{ //if data port is 0 (means pick an empheral port), then don't set this option`
`1943`	`1943`	`server->acceptor_.set_option(reuse_addr_option);`
`1944`	`1944`	`}`
`1945`		`- server->acceptor_.bind(results->endpoint(), bind_ec);`
	`1945`	`+ server->acceptor_.bind(results.begin()->endpoint(), bind_ec);`
`1946`	`1946`	`if (bind_ec)`
`1947`	`1947`	`{`
`1948`		`- BOOST_LOG_SEV(log, error) << (boost::format("Could not bind to address: %1%:%2% -- %3%") % results->endpoint().address().to_string() % results->endpoint().port() % bind_ec.message()).str();`
	`1948`	`+ BOOST_LOG_SEV(log, error) << (boost::format("Could not bind to address: %1%:%2% -- %3%") % results.begin()->endpoint().address().to_string() % results.begin()->endpoint().port() % bind_ec.message()).str();`
`1949`	`1949`	`basic_retry_execute(log, retry_config,`
`1950`	`1950`	`[]() { throw proxy_exception(SOURCE_LOCAL_PROXY_PORT_BIND_EXCEPTION); });`
`1951`	`1951`	`}`
`@@ -1958,7 +1958,7 @@ namespace aws { namespace iot { namespace securedtunneling {`
`1958`	`1958`	`if (listen_ec)`
`1959`	`1959`	`{`
`1960`	`1960`	`BOOST_LOG_SEV(log, error) << (boost::format("Could not listen on bind address: %1%:%2% -- %3%")`
`1961`		`- % results->endpoint().address().to_string() % local_port % listen_ec.message()).str();`
	`1961`	`+ % results.begin()->endpoint().address().to_string() % local_port % listen_ec.message()).str();`
`1962`	`1962`	`basic_retry_execute(log, retry_config,`
`1963`	`1963`	`[]() { throw proxy_exception(SOURCE_LOCAL_PROXY_PORT_BIND_EXCEPTION); });`
`1964`	`1964`	`}`
`@@ -2057,8 +2057,8 @@ namespace aws { namespace iot { namespace securedtunneling {`
`2057`	`2057`	`}`
`2058`	`2058`	`else {`
`2059`	`2059`	`tcp_client::pointer client = tac.serviceId_to_tcp_client_map[service_id];`
`2060`		`- std::string dst_host = results->endpoint().address().to_string();`
`2061`		`- unsigned short dst_port = results->endpoint().port();`
	`2060`	`+ std::string dst_host = results.begin()->endpoint().address().to_string();`
	`2061`	`+ unsigned short dst_port = results.begin()->endpoint().port();`
`2062`	`2062`	`BOOST_LOG_SEV(log, debug) << "Resolved destination host to IP: " << dst_host << ", connecting ...";`
`2063`	`2063`
`2064`	`2064`	`boost::system::error_code connect_ec;`
`@@ -2137,7 +2137,7 @@ namespace aws { namespace iot { namespace securedtunneling {`
`2137`	`2137`	`}`
`2138`	`2138`	`else`
`2139`	`2139`	`{`
`2140`		`- BOOST_LOG_SEV(log, debug) << "Resolved bind IP: " << results->endpoint().address().to_string();`
	`2140`	`+ BOOST_LOG_SEV(log, debug) << "Resolved bind IP: " << results.begin()->endpoint().address().to_string();`
`2141`	`2141`
`2142`	`2142`	`tuple<string, string> endpoint_to_connect = tcp_adapter_proxy::get_host_and_port(endpoint, tac.adapter_config.bind_address.get());`
`2143`	`2143`	`std::string dst_host = std::get<0>(endpoint_to_connect);`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ namespace aws {`
`52`	`52`	`void WebProxyAdapter::async_ssl_handshake() {`
`53`	`53`	`if (!localproxy_config.no_ssl_host_verify) {`
`54`	`54`	`websocket_stream->get_web_proxy_ssl_stream()->set_verify_mode(ssl::verify_peer \| ssl::verify_fail_if_no_peer_cert);`
`55`		`- websocket_stream->get_web_proxy_ssl_stream()->set_verify_callback(boost::asio::ssl::rfc2818_verification(localproxy_config.web_proxy_host));`
	`55`	`+ websocket_stream->get_web_proxy_ssl_stream()->set_verify_callback(boost::asio::ssl::host_name_verification(localproxy_config.web_proxy_host));`
`56`	`56`	`}`
`57`	`57`	`websocket_stream->get_web_proxy_ssl_stream()->async_handshake(ssl::stream_base::client, [this](error_code const &ec) {`
`58`	`58`	`if (ec) {`
Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ namespace aws {`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
`166`		`- void WebSocketStream::set_verify_callback(const ssl::rfc2818_verification &callback) {`
	`166`	`+ void WebSocketStream::set_verify_callback(const ssl::host_name_verification &callback) {`
`167`	`167`	`if (localproxyConfig.is_web_proxy_using_tls) {`
`168`	`168`	`BOOST_LOG_SEV(*log, trace) << "Calling set_verify_callback with type: double_ssl_stream";`
`169`	`169`	`return double_ssl_stream->set_verify_callback(callback);`