diff options
Diffstat (limited to 'devel/cpprestsdk/files')
12 files changed, 788 insertions, 0 deletions
diff --git a/devel/cpprestsdk/files/patch-include_cpprest_astreambuf.h b/devel/cpprestsdk/files/patch-include_cpprest_astreambuf.h new file mode 100644 index 000000000000..3daacb5a460c --- /dev/null +++ b/devel/cpprestsdk/files/patch-include_cpprest_astreambuf.h @@ -0,0 +1,77 @@ +--- include/cpprest/astreambuf.h.orig 2023-12-05 04:23:31 UTC ++++ include/cpprest/astreambuf.h +@@ -15,6 +15,7 @@ + + #include "cpprest/asyncrt_utils.h" + #include "cpprest/details/basic_types.h" ++#include "cpprest/details/char_traits.h" + #include "pplx/pplxtasks.h" + #include <atomic> + #include <cstring> +@@ -56,55 +57,28 @@ namespace streams + /// <typeparam name="_CharType"> + /// The data type of the basic element of the stream. + /// </typeparam> ++namespace detail ++{ + template<typename _CharType> +-struct char_traits : std::char_traits<_CharType> ++struct char_traits : utility::CanUseStdCharTraits<_CharType>::TraitsType + { + /// <summary> + /// Some synchronous functions will return this value if the operation + /// requires an asynchronous call in a given situation. + /// </summary> + /// <returns>An <c>int_type</c> value which implies that an asynchronous call is required.</returns> +- static typename std::char_traits<_CharType>::int_type requires_async() ++ static typename utility::CanUseStdCharTraits<_CharType>::TraitsType::int_type requires_async() + { +- return std::char_traits<_CharType>::eof() - 1; ++ return utility::CanUseStdCharTraits<_CharType>::TraitsType::eof() - 1; + } + }; ++} ++template<typename _CharType> struct char_traits : detail::char_traits<_CharType> { ++}; + #if !defined(_WIN32) +-template<> +-struct char_traits<unsigned char> : private std::char_traits<char> +-{ +-public: +- typedef unsigned char char_type; +- +- using std::char_traits<char>::eof; +- using std::char_traits<char>::int_type; +- using std::char_traits<char>::off_type; +- using std::char_traits<char>::pos_type; +- +- static size_t length(const unsigned char* str) +- { +- return std::char_traits<char>::length(reinterpret_cast<const char*>(str)); +- } +- +- static void assign(unsigned char& left, const unsigned char& right) { left = right; } +- static unsigned char* assign(unsigned char* left, size_t n, unsigned char value) +- { +- return reinterpret_cast<unsigned char*>( +- std::char_traits<char>::assign(reinterpret_cast<char*>(left), n, static_cast<char>(value))); +- } +- +- static unsigned char* copy(unsigned char* left, const unsigned char* right, size_t n) +- { +- return reinterpret_cast<unsigned char*>( +- std::char_traits<char>::copy(reinterpret_cast<char*>(left), reinterpret_cast<const char*>(right), n)); +- } +- +- static unsigned char* move(unsigned char* left, const unsigned char* right, size_t n) +- { +- return reinterpret_cast<unsigned char*>( +- std::char_traits<char>::move(reinterpret_cast<char*>(left), reinterpret_cast<const char*>(right), n)); +- } +- ++template <> struct char_traits<unsigned char> : detail::char_traits<unsigned char> { ++ typedef typename std::char_traits<char>::int_type int_type; ++ static int_type eof() { return std::char_traits<char>::eof(); } + static int_type requires_async() { return eof() - 1; } + }; + #endif diff --git a/devel/cpprestsdk/files/patch-include_cpprest_details_char__traits.h b/devel/cpprestsdk/files/patch-include_cpprest_details_char__traits.h new file mode 100644 index 000000000000..6ccf51639de7 --- /dev/null +++ b/devel/cpprestsdk/files/patch-include_cpprest_details_char__traits.h @@ -0,0 +1,105 @@ +--- include/cpprest/details/char_traits.h.orig 2025-07-02 14:23:43 UTC ++++ include/cpprest/details/char_traits.h +@@ -0,0 +1,102 @@ ++// ++// Created by sigsegv on 6/28/25. ++// ++ ++#ifndef CPPRESTSDK_ROOT_CHAR_TRAITS_H ++#define CPPRESTSDK_ROOT_CHAR_TRAITS_H ++ ++#include <type_traits> ++#include <string> ++ ++namespace utility { ++ ++namespace detail { ++ ++template <typename T> struct IntTypeFor { ++ typedef typename std::conditional<std::is_unsigned<T>::value, unsigned long long int, long long int>::type type; ++}; ++template <> struct IntTypeFor<char> { ++ typedef typename std::char_traits<char>::int_type type; ++}; ++template <> struct IntTypeFor<unsigned char> { ++ typedef typename std::make_unsigned<typename std::char_traits<char>::int_type>::type type; ++}; ++ ++template <typename T> class DetailCharTraits ++{ ++public: ++ using char_type = T; ++ using int_type = typename IntTypeFor<T>::type; ++ using off_type = std::streamoff; ++ using pos_type = std::streampos; ++ using state_type = mbstate_t; ++ ++ static void assign(char_type& r, const char_type& a) noexcept { r = a; } ++ static char_type to_char_type(int_type c) noexcept { return char_type(c); } ++ static int_type to_int_type(char_type c) noexcept { return c; } ++ static bool eq(char_type a, char_type b) noexcept { return a == b; } ++ static bool lt(char_type a, char_type b) noexcept { return a < b; } ++ static int compare(const char_type* s1,const char_type* s2,size_t n){ ++ for (; n--; ++s1, ++s2) { ++ if (!eq(*s1, *s2)) ++ return lt(*s1,*s2)?-1:1; ++ } ++ return 0; ++ } ++ static size_t length(const char_type* s){ ++ const char_type* p = s; ++ while (*p) ++ ++p; ++ return size_t(p - s); ++ } ++ static const char_type* find(const char_type* s,size_t n,const char_type& a){ ++ for (; n--; ++s) ++ { ++ if (eq(*s, a)) ++ return s; ++ return nullptr; ++ } ++ } ++ static char_type* move (char_type* r,const char_type* s,size_t n){ ++ return (char_type*)memmove(r, s, n * sizeof(char_type)); ++ } ++ static char_type* copy (char_type* r,const char_type* s,size_t n){ ++ return (char_type*)memcpy (r, s, n * sizeof(char_type)); ++ } ++ static char_type* assign(char_type* r,size_t n,char_type a){ ++ if (sizeof(char_type) == 1) ++ { ++ return (char_type*)memset(r, a, n); ++ } ++ else ++ { ++ for (char_type *s = r; n--; ++s) ++ { ++ *s = a; ++ } ++ } ++ } ++ static int_type eof() noexcept { return ~0u; } ++ static int_type not_eof(int_type c) noexcept { return c == eof() ? 0 : c; } ++}; ++ ++template <typename T, typename = bool> struct CanUseStdCharTraits : public std::false_type ++{ ++public: ++ typedef DetailCharTraits<T> TraitsType; ++}; ++ ++template <typename T> struct CanUseStdCharTraits<T, decltype(std::char_traits<T>::eq(std::declval<T>(), std::declval<T>()))> : public std::true_type ++{ ++public: ++ typedef std::char_traits<T> TraitsType; ++}; ++ ++} ++ ++template <typename T> struct CanUseStdCharTraits : detail::CanUseStdCharTraits<typename std::remove_const<typename std::remove_reference<T>::type>::type> { ++}; ++ ++} ++ ++#endif // CPPRESTSDK_ROOT_CHAR_TRAITS_H diff --git a/devel/cpprestsdk/files/patch-include_cpprest_streams.h b/devel/cpprestsdk/files/patch-include_cpprest_streams.h new file mode 100644 index 000000000000..c1e1a5ba5b7e --- /dev/null +++ b/devel/cpprestsdk/files/patch-include_cpprest_streams.h @@ -0,0 +1,144 @@ +--- include/cpprest/streams.h.orig 2023-12-05 04:23:31 UTC ++++ include/cpprest/streams.h +@@ -16,6 +16,7 @@ + #define CASA_STREAMS_H + + #include "cpprest/astreambuf.h" ++#include "cpprest/details/char_traits.h" + #include <iosfwd> + #include <cstdio> + +@@ -60,31 +61,96 @@ class basic_istream_helper (private) + concurrency::streams::streambuf<CharType> m_buffer; + }; + +-template<typename CharType> ++template<typename CharType, class Traits = typename utility::CanUseStdCharTraits<CharType>::TraitsType> + struct Value2StringFormatter + { ++ struct SanitizeInput ++ { ++ const std::basic_string<char> &operator () (const std::basic_string<char> &input) ++ { ++ return input; ++ } ++ template <class InputTraits> std::basic_string<char> operator () (const std::basic_string<unsigned char, InputTraits> &input) ++ { ++ return {reinterpret_cast<const char *>(input.c_str()), input.size()}; ++ } ++ const char *operator () (const char *input) { ++ return input; ++ } ++ const char *operator () (const unsigned char *input) ++ { ++ return reinterpret_cast<const char *>(input); ++ } ++ template <class T> T operator () (T input) ++ { ++ return input; ++ } ++ }; ++ struct GenerateFormatOutput ++ { ++ std::basic_string<CharType,Traits> &&operator() (std::basic_string<CharType,Traits> &&result) ++ { ++ return std::move(result); ++ } ++ std::basic_string<CharType,Traits> operator() (const std::basic_string<char> &intermediate) ++ { ++ return {reinterpret_cast<const CharType *>(intermediate.c_str()), intermediate.size()}; ++ } ++ }; + template<typename T> +- static std::basic_string<CharType> format(const T& val) ++ static std::basic_string<CharType, Traits> format(const T& val) + { +- std::basic_ostringstream<CharType> ss; +- ss << val; +- return ss.str(); ++ typename std::conditional< ++ sizeof(CharType) == 1, ++ std::basic_ostringstream<char>, ++ std::basic_ostringstream<typename std::make_signed<CharType>::type> ++ >::type ss; ++ SanitizeInput sanitizer; ++ ss << sanitizer(val); ++ typename std::conditional< ++ sizeof(CharType) == 1, ++ std::basic_string<char>, ++ std::basic_string<typename std::make_signed<CharType>::type> ++ >::type str = ss.str(); ++ GenerateFormatOutput generateFormatOutput; ++ return generateFormatOutput(std::move(str)); + } + }; + +-template<> +-struct Value2StringFormatter<uint8_t> ++template<class Traits, typename T> ++struct Value2StringFormatterUint8Format + { +- template<typename T> +- static std::basic_string<uint8_t> format(const T& val) ++ std::basic_string<uint8_t, Traits> operator () (const T& val) + { + std::basic_ostringstream<char> ss; + ss << val; + return reinterpret_cast<const uint8_t*>(ss.str().c_str()); + } ++}; + +- static std::basic_string<uint8_t> format(const utf16string& val) ++template <class Traits> ++struct Value2StringFormatterUint8Format<Traits, std::basic_string<uint8_t,Traits>> ++{ ++ std::basic_string<uint8_t, Traits> operator () ( ++ const std::basic_string<uint8_t, typename utility::CanUseStdCharTraits<uint8_t>::TraitsType>& val) + { ++ Value2StringFormatterUint8Format<Traits,std::basic_string<char>> format; ++ return format(reinterpret_cast<const std::basic_string<char>&>(val)); ++ } ++}; ++ ++template<> ++struct Value2StringFormatter<uint8_t> ++{ ++ template <typename T, class Traits = typename utility::CanUseStdCharTraits<uint8_t>::TraitsType> ++ static std::basic_string<uint8_t, Traits> format(const T& val) ++ { ++ Value2StringFormatterUint8Format<Traits, T> format; ++ return format(val); ++ } ++ ++ static std::basic_string<uint8_t, typename utility::CanUseStdCharTraits<uint8_t>::TraitsType> format(const utf16string& val) ++ { + return format(utility::conversions::utf16_to_utf8(val)); + } + }; +@@ -262,7 +328,7 @@ class basic_ostream (public) + /// Write the specified string to the output stream. + /// </summary> + /// <param name="str">Input string.</param> +- pplx::task<size_t> print(const std::basic_string<CharType>& str) const ++ pplx::task<size_t> print(const std::basic_string<CharType,traits>& str) const + { + pplx::task<size_t> result; + if (!_verify_and_return_task(details::_out_stream_msg, result)) return result; +@@ -273,7 +339,7 @@ class basic_ostream (public) + } + else + { +- auto sharedStr = std::make_shared<std::basic_string<CharType>>(str); ++ auto sharedStr = std::make_shared<std::basic_string<CharType,traits>>(str); + return helper()->m_buffer.putn_nocopy(sharedStr->c_str(), sharedStr->size()).then([sharedStr](size_t size) { + return size; + }); +@@ -294,7 +360,7 @@ class basic_ostream (public) + if (!_verify_and_return_task(details::_out_stream_msg, result)) return result; + // TODO in the future this could be improved to have Value2StringFormatter avoid another unnecessary copy + // by putting the string on the heap before calling the print string overload. +- return print(details::Value2StringFormatter<CharType>::format(val)); ++ return print(details::Value2StringFormatter<CharType, traits>::format(val)); + } + + /// <summary> diff --git a/devel/cpprestsdk/files/patch-include_pplx_threadpool.h b/devel/cpprestsdk/files/patch-include_pplx_threadpool.h new file mode 100644 index 000000000000..e6a05d26b0d3 --- /dev/null +++ b/devel/cpprestsdk/files/patch-include_pplx_threadpool.h @@ -0,0 +1,21 @@ +--- include/pplx/threadpool.h.orig 2023-12-05 04:23:31 UTC ++++ include/pplx/threadpool.h +@@ -69,15 +69,15 @@ class threadpool (public) + CASABLANCA_DEPRECATED("Use `.service().post(task)` directly.") + void schedule(T task) + { +- service().post(task); ++ boost::asio::post(service(), task); + } + +- boost::asio::io_service& service() { return m_service; } ++ boost::asio::io_context& service() { return m_service; } + + protected: + threadpool(size_t num_threads) : m_service(static_cast<int>(num_threads)) {} + +- boost::asio::io_service m_service; ++ boost::asio::io_context m_service; + }; + + } // namespace crossplat diff --git a/devel/cpprestsdk/files/patch-src_http_client_http__client__asio.cpp b/devel/cpprestsdk/files/patch-src_http_client_http__client__asio.cpp new file mode 100644 index 000000000000..7b4d1af0d422 --- /dev/null +++ b/devel/cpprestsdk/files/patch-src_http_client_http__client__asio.cpp @@ -0,0 +1,218 @@ +--- src/http/client/http_client_asio.cpp.orig 2023-12-05 04:23:31 UTC ++++ src/http/client/http_client_asio.cpp +@@ -146,7 +146,7 @@ class asio_connection (public) + friend class asio_client; + + public: +- asio_connection(boost::asio::io_service& io_service) ++ asio_connection(boost::asio::io_context& io_service) + : m_socket_lock() + , m_socket(io_service) + , m_ssl_stream() +@@ -581,10 +581,8 @@ class asio_context final : public request_context, pub + + m_context->m_timer.start(); + +- tcp::resolver::query query(utility::conversions::to_utf8string(proxy_host), to_string(proxy_port)); +- + auto client = std::static_pointer_cast<asio_client>(m_context->m_http_client); +- m_context->m_resolver.async_resolve(query, ++ m_context->m_resolver.async_resolve(utility::conversions::to_utf8string(proxy_host), to_string(proxy_port), + boost::bind(&ssl_proxy_tunnel::handle_resolve, + shared_from_this(), + boost::asio::placeholders::error, +@@ -592,8 +590,9 @@ class asio_context final : public request_context, pub + } + + private: +- void handle_resolve(const boost::system::error_code& ec, tcp::resolver::iterator endpoints) ++ void handle_resolve(const boost::system::error_code& ec, tcp::resolver::results_type results) + { ++ auto iterator = results.begin(); + if (ec) + { + m_context->report_error("Error resolving proxy address", ec, httpclient_errorcode_context::connect); +@@ -601,16 +600,16 @@ class asio_context final : public request_context, pub + else + { + m_context->m_timer.reset(); +- auto endpoint = *endpoints; ++ auto endpoint = *iterator; + m_context->m_connection->async_connect(endpoint, + boost::bind(&ssl_proxy_tunnel::handle_tcp_connect, + shared_from_this(), + boost::asio::placeholders::error, +- ++endpoints)); ++ ++iterator, results.end())); + } + } + +- void handle_tcp_connect(const boost::system::error_code& ec, tcp::resolver::iterator endpoints) ++ void handle_tcp_connect(const boost::system::error_code& ec, tcp::resolver::results_type::iterator endpoints, tcp::resolver::results_type::iterator endpoints_end) + { + if (!ec) + { +@@ -621,7 +620,7 @@ class asio_context final : public request_context, pub + shared_from_this(), + boost::asio::placeholders::error)); + } +- else if (endpoints == tcp::resolver::iterator()) ++ else if (endpoints == endpoints_end) + { + m_context->report_error( + "Failed to connect to any resolved proxy endpoint", ec, httpclient_errorcode_context::connect); +@@ -646,7 +645,7 @@ class asio_context final : public request_context, pub + boost::bind(&ssl_proxy_tunnel::handle_tcp_connect, + shared_from_this(), + boost::asio::placeholders::error, +- ++endpoints)); ++ ++endpoints, endpoints_end)); + } + } + +@@ -885,8 +884,7 @@ class asio_context final : public request_context, pub + auto tcp_host = proxy_type == http_proxy_type::http ? proxy_host : host; + auto tcp_port = proxy_type == http_proxy_type::http ? proxy_port : port; + +- tcp::resolver::query query(tcp_host, to_string(tcp_port)); +- ctx->m_resolver.async_resolve(query, ++ ctx->m_resolver.async_resolve(tcp_host, to_string(tcp_port), + boost::bind(&asio_context::handle_resolve, + ctx, + boost::asio::placeholders::error, +@@ -1006,7 +1004,7 @@ class asio_context final : public request_context, pub + request_context::report_error(errorcodeValue, message); + } + +- void handle_connect(const boost::system::error_code& ec, tcp::resolver::iterator endpoints) ++ void handle_connect(const boost::system::error_code& ec, tcp::resolver::results_type::iterator endpoints, tcp::resolver::results_type::iterator endpoints_end) + { + m_timer.reset(); + if (!ec) +@@ -1019,7 +1017,7 @@ class asio_context final : public request_context, pub + { + report_error("Request canceled by user.", ec, httpclient_errorcode_context::connect); + } +- else if (endpoints == tcp::resolver::iterator()) ++ else if (endpoints == endpoints_end) + { + report_error("Failed to connect to any resolved endpoint", ec, httpclient_errorcode_context::connect); + } +@@ -1041,28 +1039,29 @@ class asio_context final : public request_context, pub + m_connection->async_connect( + endpoint, + boost::bind( +- &asio_context::handle_connect, shared_from_this(), boost::asio::placeholders::error, ++endpoints)); ++ &asio_context::handle_connect, shared_from_this(), boost::asio::placeholders::error, ++endpoints, endpoints_end)); + } + } + +- void handle_resolve(const boost::system::error_code& ec, tcp::resolver::iterator endpoints) ++ void handle_resolve(const boost::system::error_code& ec, tcp::resolver::results_type results) + { + if (ec) + { + report_error("Error resolving address", ec, httpclient_errorcode_context::connect); + } +- else if (endpoints == tcp::resolver::iterator()) ++ else if (results.empty()) + { + report_error("Failed to resolve address", ec, httpclient_errorcode_context::connect); + } + else + { + m_timer.reset(); +- auto endpoint = *endpoints; ++ auto iterator = results.begin(); ++ auto endpoint = *iterator; + m_connection->async_connect( + endpoint, + boost::bind( +- &asio_context::handle_connect, shared_from_this(), boost::asio::placeholders::error, ++endpoints)); ++ &asio_context::handle_connect, shared_from_this(), boost::asio::placeholders::error, ++iterator, results.end())); + } + } + +@@ -1134,7 +1133,7 @@ class asio_context final : public request_context, pub + } + #endif // CPPREST_PLATFORM_ASIO_CERT_VERIFICATION_AVAILABLE + +- boost::asio::ssl::rfc2818_verification rfc2818(m_connection->cn_hostname()); ++ boost::asio::ssl::host_name_verification rfc2818(m_connection->cn_hostname()); + return rfc2818(preverified, verifyCtx); + } + +@@ -1182,8 +1181,8 @@ class asio_context final : public request_context, pub + + const auto& chunkSize = m_http_client->client_config().chunksize(); + auto readbuf = _get_readbuffer(); +- uint8_t* buf = boost::asio::buffer_cast<uint8_t*>( +- m_body_buf.prepare(chunkSize + http::details::chunked_encoding::additional_encoding_space)); ++ auto bodyBuf = m_body_buf.prepare(chunkSize + http::details::chunked_encoding::additional_encoding_space); ++ uint8_t* buf = static_cast<uint8_t *>(bodyBuf.data()); + const auto this_request = shared_from_this(); + readbuf.getn(buf + http::details::chunked_encoding::data_offset, chunkSize) + .then([this_request, buf, chunkSize AND_CAPTURE_MEMBER_FUNCTION_POINTERS](pplx::task<size_t> op) { +@@ -1247,7 +1246,7 @@ class asio_context final : public request_context, pub + const auto readSize = static_cast<size_t>((std::min)( + static_cast<uint64_t>(m_http_client->client_config().chunksize()), m_content_length - m_uploaded)); + auto readbuf = _get_readbuffer(); +- readbuf.getn(boost::asio::buffer_cast<uint8_t*>(m_body_buf.prepare(readSize)), readSize) ++ readbuf.getn(static_cast<uint8_t*>(m_body_buf.prepare(readSize).data()), readSize) + .then([this_request AND_CAPTURE_MEMBER_FUNCTION_POINTERS](pplx::task<size_t> op) { + try + { +@@ -1639,7 +1638,7 @@ class asio_context final : public request_context, pub + std::vector<uint8_t> decompressed; + + bool boo = +- decompress(boost::asio::buffer_cast<const uint8_t*>(m_body_buf.data()), to_read, decompressed); ++ decompress(static_cast<const uint8_t*>(m_body_buf.data().data()), to_read, decompressed); + if (!boo) + { + report_exception(std::runtime_error("Failed to decompress the response body")); +@@ -1687,7 +1686,7 @@ class asio_context final : public request_context, pub + } + else + { +- writeBuffer.putn_nocopy(boost::asio::buffer_cast<const uint8_t*>(m_body_buf.data()), to_read) ++ writeBuffer.putn_nocopy(static_cast<const uint8_t*>(m_body_buf.data().data()), to_read) + .then([this_request, to_read AND_CAPTURE_MEMBER_FUNCTION_POINTERS](pplx::task<size_t> op) { + try + { +@@ -1759,7 +1758,7 @@ class asio_context final : public request_context, pub + std::vector<uint8_t> decompressed; + + bool boo = +- decompress(boost::asio::buffer_cast<const uint8_t*>(m_body_buf.data()), read_size, decompressed); ++ decompress(static_cast<const uint8_t*>(m_body_buf.data().data()), read_size, decompressed); + if (!boo) + { + this_request->report_exception(std::runtime_error("Failed to decompress the response body")); +@@ -1821,7 +1820,7 @@ class asio_context final : public request_context, pub + } + else + { +- writeBuffer.putn_nocopy(boost::asio::buffer_cast<const uint8_t*>(m_body_buf.data()), read_size) ++ writeBuffer.putn_nocopy(static_cast<const uint8_t*>(m_body_buf.data().data()), read_size) + .then([this_request AND_CAPTURE_MEMBER_FUNCTION_POINTERS](pplx::task<size_t> op) { + size_t writtenSize = 0; + try +@@ -1870,7 +1869,7 @@ class asio_context final : public request_context, pub + assert(!m_ctx.expired()); + m_state = started; + +- m_timer.expires_from_now(m_duration); ++ m_timer.expires_after(m_duration); + auto ctx = m_ctx; + m_timer.async_wait([ctx AND_CAPTURE_MEMBER_FUNCTION_POINTERS](const boost::system::error_code& ec) { + handle_timeout(ec, ctx); +@@ -1881,7 +1880,7 @@ class asio_context final : public request_context, pub + { + assert(m_state == started || m_state == timedout); + assert(!m_ctx.expired()); +- if (m_timer.expires_from_now(m_duration) > 0) ++ if (m_timer.expires_after(m_duration) > 0) + { + // The existing handler was canceled so schedule a new one. + assert(m_state == started); diff --git a/devel/cpprestsdk/files/patch-src_http_listener_http__server__asio.cpp b/devel/cpprestsdk/files/patch-src_http_listener_http__server__asio.cpp new file mode 100644 index 000000000000..21cd36ec493d --- /dev/null +++ b/devel/cpprestsdk/files/patch-src_http_listener_http__server__asio.cpp @@ -0,0 +1,67 @@ +--- src/http/listener/http_server_asio.cpp.orig 2023-12-05 04:23:31 UTC ++++ src/http/listener/http_server_asio.cpp +@@ -520,17 +520,14 @@ void hostport_listener::start() + auto& service = crossplat::threadpool::shared_instance().service(); + tcp::resolver resolver(service); + // #446: boost resolver does not recognize "+" as a host wildchar +- tcp::resolver::query query = +- ("+" == m_host) ? tcp::resolver::query(m_port, boost::asio::ip::resolver_query_base::flags()) +- : tcp::resolver::query(m_host, m_port, boost::asio::ip::resolver_query_base::flags()); + +- tcp::endpoint endpoint = *resolver.resolve(query); ++ tcp::endpoint endpoint = (("+" == m_host) ? *(resolver.resolve("", m_port).begin()) : *(resolver.resolve(m_host, m_port).begin())); + + m_acceptor.reset(new tcp::acceptor(service)); + m_acceptor->open(endpoint.protocol()); + m_acceptor->set_option(socket_base::reuse_address(true)); + m_acceptor->bind(endpoint); +- m_acceptor->listen(0 != m_backlog ? m_backlog : socket_base::max_connections); ++ m_acceptor->listen(0 != m_backlog ? m_backlog : socket_base::max_listen_connections); + + auto socket = new ip::tcp::socket(service); + std::unique_ptr<ip::tcp::socket> usocket(socket); +@@ -881,7 +878,7 @@ will_deref_t asio_server_connection::handle_chunked_bo + else + { + auto writebuf = requestImpl->outstream().streambuf(); +- writebuf.putn_nocopy(buffer_cast<const uint8_t*>(m_request_buf.data()), toWrite) ++ writebuf.putn_nocopy(static_cast<const uint8_t*>(m_request_buf.data().data()), toWrite) + .then([=](pplx::task<size_t> writeChunkTask) -> will_deref_t { + try + { +@@ -913,7 +910,7 @@ will_deref_t asio_server_connection::handle_body(const + { + auto writebuf = requestImpl->outstream().streambuf(); + writebuf +- .putn_nocopy(boost::asio::buffer_cast<const uint8_t*>(m_request_buf.data()), ++ .putn_nocopy(static_cast<const uint8_t*>(m_request_buf.data().data()), + (std::min)(m_request_buf.size(), m_read_size - m_read)) + .then([this](pplx::task<size_t> writtenSizeTask) -> will_deref_t { + size_t writtenSize = 0; +@@ -1134,7 +1131,7 @@ will_deref_and_erase_t asio_server_connection::handle_ + } + auto membuf = m_response_buf.prepare(ChunkSize + chunked_encoding::additional_encoding_space); + +- readbuf.getn(buffer_cast<uint8_t*>(membuf) + chunked_encoding::data_offset, ChunkSize) ++ readbuf.getn(static_cast<uint8_t*>(membuf.data()) + chunked_encoding::data_offset, ChunkSize) + .then([=](pplx::task<size_t> actualSizeTask) -> will_deref_and_erase_t { + size_t actualSize = 0; + try +@@ -1146,7 +1143,7 @@ will_deref_and_erase_t asio_server_connection::handle_ + return cancel_sending_response_with_error(response, std::current_exception()); + } + size_t offset = chunked_encoding::add_chunked_delimiters( +- buffer_cast<uint8_t*>(membuf), ChunkSize + chunked_encoding::additional_encoding_space, actualSize); ++ static_cast<uint8_t*>(membuf.data()), ChunkSize + chunked_encoding::additional_encoding_space, actualSize); + m_response_buf.commit(actualSize + chunked_encoding::additional_encoding_space); + m_response_buf.consume(offset); + if (actualSize == 0) +@@ -1167,7 +1164,7 @@ will_deref_and_erase_t asio_server_connection::handle_ + return cancel_sending_response_with_error( + response, std::make_exception_ptr(http_exception("Response stream close early!"))); + size_t readBytes = (std::min)(ChunkSize, m_write_size - m_write); +- readbuf.getn(buffer_cast<uint8_t*>(m_response_buf.prepare(readBytes)), readBytes) ++ readbuf.getn(static_cast<uint8_t*>(m_response_buf.prepare(readBytes).data()), readBytes) + .then([=](pplx::task<size_t> actualSizeTask) -> will_deref_and_erase_t { + size_t actualSize = 0; + try diff --git a/devel/cpprestsdk/files/patch-src_pplx_pplxlinux.cpp b/devel/cpprestsdk/files/patch-src_pplx_pplxlinux.cpp new file mode 100644 index 000000000000..51af71ecc2a3 --- /dev/null +++ b/devel/cpprestsdk/files/patch-src_pplx_pplxlinux.cpp @@ -0,0 +1,11 @@ +--- src/pplx/pplxlinux.cpp.orig 2023-12-05 04:23:31 UTC ++++ src/pplx/pplxlinux.cpp +@@ -35,7 +35,7 @@ _PPLXIMP void linux_scheduler::schedule(TaskProc_t pro + + _PPLXIMP void linux_scheduler::schedule(TaskProc_t proc, void* param) + { +- crossplat::threadpool::shared_instance().service().post(boost::bind(proc, param)); ++ boost::asio::post(crossplat::threadpool::shared_instance().service(), boost::bind(proc, param)); + } + + } // namespace details diff --git a/devel/cpprestsdk/files/patch-src_pplx_threadpool.cpp b/devel/cpprestsdk/files/patch-src_pplx_threadpool.cpp new file mode 100644 index 000000000000..f52ce704684e --- /dev/null +++ b/devel/cpprestsdk/files/patch-src_pplx_threadpool.cpp @@ -0,0 +1,20 @@ +--- src/pplx/threadpool.cpp.orig 2023-12-05 04:23:31 UTC ++++ src/pplx/threadpool.cpp +@@ -37,7 +37,7 @@ struct threadpool_impl final : crossplat::threadpool + + struct threadpool_impl final : crossplat::threadpool + { +- threadpool_impl(size_t n) : crossplat::threadpool(n), m_work(m_service) ++ threadpool_impl(size_t n) : crossplat::threadpool(n), m_work(boost::asio::make_work_guard(m_service)) + { + for (size_t i = 0; i < n; i++) + add_thread(); +@@ -84,7 +84,7 @@ struct threadpool_impl final : crossplat::threadpool + } + + std::vector<std::unique_ptr<boost::asio::detail::thread>> m_threads; +- boost::asio::io_service::work m_work; ++ boost::asio::executor_work_guard<boost::asio::io_context::executor_type > m_work; + }; + + #if defined(_WIN32) diff --git a/devel/cpprestsdk/files/patch-src_websockets_client_ws__client__wspp.cpp b/devel/cpprestsdk/files/patch-src_websockets_client_ws__client__wspp.cpp new file mode 100644 index 000000000000..d576a97084ac --- /dev/null +++ b/devel/cpprestsdk/files/patch-src_websockets_client_ws__client__wspp.cpp @@ -0,0 +1,11 @@ +--- src/websockets/client/ws_client_wspp.cpp.orig 2023-12-05 04:23:31 UTC ++++ src/websockets/client/ws_client_wspp.cpp +@@ -225,7 +225,7 @@ class wspp_callback_client : public websocket_client_c + verifyCtx, utility::conversions::to_utf8string(m_uri.host())); + } + #endif +- boost::asio::ssl::rfc2818_verification rfc2818(utility::conversions::to_utf8string(m_uri.host())); ++ boost::asio::ssl::host_name_verification rfc2818(utility::conversions::to_utf8string(m_uri.host())); + return rfc2818(preverified, verifyCtx); + }); + diff --git a/devel/cpprestsdk/files/patch-tests_functional_pplx_pplx__test_pplx__op__test.cpp b/devel/cpprestsdk/files/patch-tests_functional_pplx_pplx__test_pplx__op__test.cpp new file mode 100644 index 000000000000..356a5d7bb902 --- /dev/null +++ b/devel/cpprestsdk/files/patch-tests_functional_pplx_pplx__test_pplx__op__test.cpp @@ -0,0 +1,11 @@ +--- tests/functional/pplx/pplx_test/pplx_op_test.cpp.orig 2023-12-05 04:23:31 UTC ++++ tests/functional/pplx/pplx_test/pplx_op_test.cpp +@@ -57,7 +57,7 @@ class pplx_dflt_scheduler : public pplx::scheduler_int + virtual void schedule(pplx::TaskProc_t proc, void* param) + { + pplx::details::atomic_increment(s_flag); +- m_pool->service().post([=]() -> void { proc(param); }); ++ boost::asio::post(m_pool->service(), [=]() -> void { proc(param); }); + } + + public: diff --git a/devel/cpprestsdk/files/patch-tests_functional_streams_memstream__tests.cpp b/devel/cpprestsdk/files/patch-tests_functional_streams_memstream__tests.cpp new file mode 100644 index 000000000000..e2b7e2e67e7e --- /dev/null +++ b/devel/cpprestsdk/files/patch-tests_functional_streams_memstream__tests.cpp @@ -0,0 +1,73 @@ +--- tests/functional/streams/memstream_tests.cpp.orig 2023-12-05 04:23:31 UTC ++++ tests/functional/streams/memstream_tests.cpp +@@ -8,6 +8,7 @@ + * + * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- + ****/ ++#include "cpprest/details/char_traits.h" + #include "stdafx.h" + #if defined(__cplusplus_winrt) + #include <wrl.h> +@@ -32,7 +33,7 @@ void streambuf_putc(StreamBufferType& wbuf) + { + VERIFY_IS_TRUE(wbuf.can_write()); + +- std::basic_string<typename StreamBufferType::char_type> s; ++ std::basic_string<typename StreamBufferType::char_type,typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s; + s.push_back((typename StreamBufferType::char_type)0); + s.push_back((typename StreamBufferType::char_type)1); + s.push_back((typename StreamBufferType::char_type)2); +@@ -137,7 +138,7 @@ void streambuf_putn(StreamBufferType& wbuf) + { + VERIFY_IS_TRUE(wbuf.can_write()); + +- std::basic_string<typename StreamBufferType::char_type> s; ++ std::basic_string<typename StreamBufferType::char_type,typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s; + s.push_back((typename StreamBufferType::char_type)0); + s.push_back((typename StreamBufferType::char_type)1); + s.push_back((typename StreamBufferType::char_type)2); +@@ -169,7 +170,7 @@ void streambuf_putn(concurrency::streams::rawptr_buffe + + typedef concurrency::streams::rawptr_buffer<CharType> StreamBufferType; + +- std::basic_string<CharType> s; ++ std::basic_string<CharType,typename CanUseStdCharTraits<CharType>::TraitsType> s; + s.push_back((CharType)0); + s.push_back((CharType)1); + s.push_back((CharType)2); +@@ -198,7 +199,7 @@ void streambuf_putn(concurrency::streams::container_bu + typedef concurrency::streams::container_buffer<CollectionType> StreamBufferType; + typedef typename concurrency::streams::container_buffer<CollectionType>::char_type CharType; + +- std::basic_string<CharType> s; ++ std::basic_string<CharType, typename utility::CanUseStdCharTraits<CharType>::TraitsType> s; + s.push_back((CharType)0); + s.push_back((CharType)1); + s.push_back((CharType)2); +@@ -553,7 +554,7 @@ void streambuf_putn_getn(StreamBufferType& rwbuf) + VERIFY_IS_TRUE(rwbuf.can_read()); + VERIFY_IS_TRUE(rwbuf.can_write()); + VERIFY_IS_FALSE(rwbuf.is_eof()); +- std::basic_string<typename StreamBufferType::char_type> s; ++ std::basic_string<typename StreamBufferType::char_type, typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s; + s.push_back((typename StreamBufferType::char_type)0); + s.push_back((typename StreamBufferType::char_type)1); + s.push_back((typename StreamBufferType::char_type)2); +@@ -684,7 +685,7 @@ void streambuf_close_read_with_pending_read(StreamBuff + VERIFY_IS_TRUE(rwbuf.can_write()); + + // Write 4 characters +- std::basic_string<typename StreamBufferType::char_type> s; ++ std::basic_string<typename StreamBufferType::char_type, typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s; + s.push_back((typename StreamBufferType::char_type)0); + s.push_back((typename StreamBufferType::char_type)1); + s.push_back((typename StreamBufferType::char_type)2); +@@ -726,7 +727,7 @@ void streambuf_close_write_with_pending_read(StreamBuf + VERIFY_IS_TRUE(rwbuf.can_write()); + + // Write 4 characters +- std::basic_string<typename StreamBufferType::char_type> s; ++ std::basic_string<typename StreamBufferType::char_type, typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s; + s.push_back((typename StreamBufferType::char_type)0); + s.push_back((typename StreamBufferType::char_type)1); + s.push_back((typename StreamBufferType::char_type)2); diff --git a/devel/cpprestsdk/files/patch-tests_functional_streams_stdstream__tests.cpp b/devel/cpprestsdk/files/patch-tests_functional_streams_stdstream__tests.cpp new file mode 100644 index 000000000000..4ec6c6af21de --- /dev/null +++ b/devel/cpprestsdk/files/patch-tests_functional_streams_stdstream__tests.cpp @@ -0,0 +1,30 @@ +--- tests/functional/streams/stdstream_tests.cpp.orig 2023-12-05 04:23:31 UTC ++++ tests/functional/streams/stdstream_tests.cpp +@@ -13,6 +13,7 @@ + #include "cpprest/filestream.h" + #include "cpprest/producerconsumerstream.h" + #include "cpprest/rawptrstream.h" ++#include "cpprest/details/char_traits.h" + + #if (!defined(_WIN32) || !defined(CPPREST_EXCLUDE_WEBSOCKETS)) && !defined(__cplusplus_winrt) + #include <boost/interprocess/streams/bufferstream.hpp> +@@ -303,7 +304,8 @@ SUITE(stdstreambuf_tests) + + const std::streamsize iterations = 100; + +- const std::string the_alphabet("abcdefghijklmnopqrstuvwxyz"); ++ const char *the_alphabet_characters = "abcdefghijklmnopqrstuvwxyz"; ++ const std::basic_string<uint8_t,typename utility::CanUseStdCharTraits<uint8_t>::TraitsType> the_alphabet(reinterpret_cast<const uint8_t *>(the_alphabet_characters)); + + auto writer = pplx::create_task([ostream, iterations, the_alphabet]() { + auto os = ostream; +@@ -341,7 +343,8 @@ SUITE(stdstreambuf_tests) + + const std::streamsize iterations = 100; + +- const std::string the_alphabet("abcdefghijklmnopqrstuvwxyz"); ++ const char *the_alphabet_chars = "abcdefghijklmnopqrstuvwxyz"; ++ const std::basic_string<uint8_t,typename CanUseStdCharTraits<uint8_t>::TraitsType> the_alphabet(reinterpret_cast<const uint8_t *>(the_alphabet_chars)); + + auto writer = pplx::create_task([ostream, iterations, the_alphabet]() { + auto os = ostream; |