Adding metadata

12 files changed, 1256 insertions, 0 deletions

diff --git a/dev-cpp/cpprestsdk/Manifest b/dev-cpp/cpprestsdk/Manifest
new file mode 100644
index 000000000000..625524b0cd63
--- /dev/null
+++ b/dev-cpp/cpprestsdk/Manifest
@@ -0,0 +1 @@
+DIST cpprestsdk-2.10.19.tar.gz 1749647 BLAKE2B 4f6863c490df083c39e7e4fdb714ca380b1f28636bb8c446e9627bb31259160d2d30f00fb474caffb0d06f0d7f8c86db3f6eac959bfa738318dfabf52def8339 SHA512 2d8fa213f492236e2fd912349bf81951c1e618dd8eab4f665f909d75b5aeeda18b8f70dce3a4db50d67bdb3e372888132481701163de6c27716dfd750bff9781
diff --git a/dev-cpp/cpprestsdk/cpprestsdk-2.10.19-r6.ebuild b/dev-cpp/cpprestsdk/cpprestsdk-2.10.19-r6.ebuild
new file mode 100644
index 000000000000..46e0509a749d
--- /dev/null
+++ b/dev-cpp/cpprestsdk/cpprestsdk-2.10.19-r6.ebuild
@@ -0,0 +1,41 @@
+# Copyright 1999-2025 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+
+EAPI=8
+
+inherit cmake
+
+DESCRIPTION="A Microsoft project for cloud-based client-server communication."
+HOMEPAGE="https://github.com/microsoft/cpprestsdk"
+SRC_URI="https://github.com/microsoft/cpprestsdk/archive/refs/tags/v${PV}.tar.gz -> ${P}.tar.gz"
+LICENSE="MIT"
+SLOT="0"
+KEYWORDS="~amd64 ~x86"
+
+RDEPEND=">=dev-libs/openssl-1.1.1q
+		>=dev-libs/boost-1.80.0-r1:=
+		>=virtual/zlib-1.2.13-r1:="
+
+DEPEND="${RDEPEND}"
+
+BDEPEND="
+		app-alternatives/ninja
+		>=sys-devel/gcc-11.3.0
+		>=virtual/pkgconfig-2-r1
+		>=dev-cpp/websocketpp-0.8.2
+"
+
+PATCHES=(
+	"${FILESDIR}"/cpprestsdk-${PV}-warnings.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-disabl-int-tests.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-disable-werror-default.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-boost-1.87-compat.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-cmake-4.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-llvm-char-traits-patch.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-llvm-json-unique-ptr.patch
+)
+
+src_configure() {
+	local mycmakeargs=( -DCMAKE_BUILD_TYPE=Release )
+	cmake_src_configure
+}
diff --git a/dev-cpp/cpprestsdk/cpprestsdk-2.10.19-r8.ebuild b/dev-cpp/cpprestsdk/cpprestsdk-2.10.19-r8.ebuild
new file mode 100644
index 000000000000..5901f059e868
--- /dev/null
+++ b/dev-cpp/cpprestsdk/cpprestsdk-2.10.19-r8.ebuild
@@ -0,0 +1,42 @@
+# Copyright 1999-2025 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+
+EAPI=8
+
+inherit cmake
+
+DESCRIPTION="A Microsoft project for cloud-based client-server communication."
+HOMEPAGE="https://github.com/microsoft/cpprestsdk"
+SRC_URI="https://github.com/microsoft/cpprestsdk/archive/refs/tags/v${PV}.tar.gz -> ${P}.tar.gz"
+LICENSE="MIT"
+SLOT="0"
+KEYWORDS="~amd64 ~x86"
+
+RDEPEND=">=dev-libs/openssl-1.1.1q
+		>=dev-libs/boost-1.80.0-r1:=
+		>=virtual/zlib-1.2.13-r1:="
+
+DEPEND="${RDEPEND}"
+
+BDEPEND="
+		app-alternatives/ninja
+		>=sys-devel/gcc-11.3.0
+		>=virtual/pkgconfig-2-r1
+		>=dev-cpp/websocketpp-0.8.2
+"
+
+PATCHES=(
+	"${FILESDIR}"/cpprestsdk-${PV}-warnings.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-disabl-int-tests.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-disable-werror-default.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-boost-1.87-compat.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-cmake-4.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-llvm-char-traits-patch.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-llvm-json-unique-ptr.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-boost-1.89-system-and-timer.patch
+)
+
+src_configure() {
+	local mycmakeargs=( -DCMAKE_BUILD_TYPE=Release )
+	cmake_src_configure
+}
diff --git a/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-boost-1.87-compat.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-boost-1.87-compat.patch
new file mode 100644
index 000000000000..e0e8a75d77af
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-boost-1.87-compat.patch
@@ -0,0 +1,359 @@
+--- a/Release/src/http/listener/http_server_asio.cpp
++++ b/Release/src/http/listener/http_server_asio.cpp
+@@ -520,17 +520,14 @@
+     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 @@
+     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 @@
+     {
+         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 @@
+     }
+     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 @@
+                 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 @@
+         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
+--- a/Release/src/http/client/http_client_asio.cpp
++++ b/Release/src/http/client/http_client_asio.cpp
+@@ -146,7 +146,7 @@
+     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 @@
+ 
+             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 @@
+         }
+ 
+     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 @@
+             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 @@
+                                                                  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 @@
+                                                        boost::bind(&ssl_proxy_tunnel::handle_tcp_connect,
+                                                                    shared_from_this(),
+                                                                    boost::asio::placeholders::error,
+-                                                                   ++endpoints));
++                                                                   ++endpoints, endpoints_end));
+             }
+         }
+ 
+@@ -885,8 +884,7 @@
+                 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 @@
+         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 @@
+         {
+             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 @@
+             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 @@
+         }
+ #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 @@
+ 
+         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 @@
+         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 @@
+                     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 @@
+                 }
+                 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 @@
+                 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 @@
+             }
+             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 @@
+             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 @@
+         {
+             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);
+--- a/Release/src/pplx/threadpool.cpp
++++ b/Release/src/pplx/threadpool.cpp
+@@ -37,7 +37,7 @@
+ 
+ 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 @@
+     }
+ 
+     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)
+--- a/Release/src/websockets/client/ws_client_wspp.cpp
++++ b/Release/src/websockets/client/ws_client_wspp.cpp
+@@ -225,7 +225,7 @@
+                             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);
+                 });
+ 
+--- a/Release/src/pplx/pplxlinux.cpp
++++ b/Release/src/pplx/pplxlinux.cpp
+@@ -35,7 +35,7 @@
+ 
+ _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
+--- a/Release/include/pplx/threadpool.h
++++ b/Release/include/pplx/threadpool.h
+@@ -69,15 +69,15 @@
+     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
+--- a/Release/tests/functional/pplx/pplx_test/pplx_op_test.cpp
++++ b/Release/tests/functional/pplx/pplx_test/pplx_op_test.cpp
+@@ -57,7 +57,7 @@
+     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/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-boost-1.89-system-and-timer.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-boost-1.89-system-and-timer.patch
new file mode 100644
index 000000000000..ded9111fe0df
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-boost-1.89-system-and-timer.patch
@@ -0,0 +1,74 @@
+https://github.com/microsoft/cpprestsdk/pull/1838
+--- a/Release/cmake/cpprestsdk-config.in.cmake.orig
++++ b/Release/cmake/cpprestsdk-config.in.cmake
+@@ -17,7 +17,7 @@ if(@CPPREST_USES_BOOST@)
+ 
+ if(@CPPREST_USES_BOOST@)
+   if(UNIX)
+-    find_dependency(Boost COMPONENTS random system thread filesystem chrono atomic date_time regex)
++    find_dependency(Boost COMPONENTS random thread filesystem chrono atomic date_time regex)
+   else()
+     find_dependency(Boost COMPONENTS system date_time regex)
+   endif()
+
+--- a/Release/cmake/cpprest_find_boost.cmake
++++ b/Release/cmake/cpprest_find_boost.cmake
+@@ -44,11 +44,11 @@ function(cpprest_find_boost)
+       set(BOOST_LIBRARYDIR "${CMAKE_BINARY_DIR}/../Boost-for-Android/build/out/x86/lib" CACHE INTERNAL "")
+       set(Boost_ARCHITECTURE "-x32" CACHE INTERNAL "")
+     endif()
+-    cpprestsdk_find_boost_android_package(Boost ${BOOST_VERSION} EXACT REQUIRED COMPONENTS random system thread filesystem chrono atomic)
++    cpprestsdk_find_boost_android_package(Boost ${BOOST_VERSION} EXACT REQUIRED COMPONENTS random thread filesystem chrono atomic)
+   elseif(UNIX)
+-    find_package(Boost REQUIRED COMPONENTS random system thread filesystem chrono atomic date_time regex)
++    find_package(Boost REQUIRED COMPONENTS random thread filesystem chrono atomic date_time regex)
+   else()
+-    find_package(Boost REQUIRED COMPONENTS system date_time regex)
++    find_package(Boost REQUIRED COMPONENTS date_time regex)
+   endif()
+ 
+   add_library(cpprestsdk_boost_internal INTERFACE)
+@@ -78,7 +78,6 @@ function(cpprest_find_boost)
+       target_link_libraries(cpprestsdk_boost_internal INTERFACE
+         Boost::boost
+         Boost::random
+-        Boost::system
+         Boost::thread
+         Boost::filesystem
+         Boost::chrono
+@@ -88,7 +87,6 @@ function(cpprest_find_boost)
+       target_link_libraries(cpprestsdk_boost_internal INTERFACE
+         Boost::boost
+         Boost::random
+-        Boost::system
+         Boost::thread
+         Boost::filesystem
+         Boost::chrono
+@@ -99,7 +97,6 @@ function(cpprest_find_boost)
+     else()
+       target_link_libraries(cpprestsdk_boost_internal INTERFACE
+         Boost::boost
+-        Boost::system
+         Boost::date_time
+         Boost::regex
+       )
+--- a/Release/src/http/client/http_client_asio.cpp
++++ b/Release/src/http/client/http_client_asio.cpp
+@@ -429,7 +429,7 @@ private:
+         auto& self = *pool;
+         std::weak_ptr<asio_connection_pool> weak_pool = pool;
+ 
+-        self.m_pool_epoch_timer.expires_from_now(boost::posix_time::seconds(30));
++        self.m_pool_epoch_timer.expires_after(std::chrono::seconds(30));
+         self.m_pool_epoch_timer.async_wait([weak_pool](const boost::system::error_code& ec) {
+             if (ec)
+             {
+@@ -467,7 +467,7 @@ private:
+     std::mutex m_lock;
+     std::map<std::string, connection_pool_stack<asio_connection>> m_connections;
+     bool m_is_timer_running;
+-    boost::asio::deadline_timer m_pool_epoch_timer;
++    boost::asio::steady_timer m_pool_epoch_timer;
+ };
+ 
+ class asio_client final : public _http_client_communicator
diff --git a/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-cmake-4.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-cmake-4.patch
new file mode 100644
index 000000000000..32a337978bc5
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-cmake-4.patch
@@ -0,0 +1,26 @@
+--- a/Build_iOS/CMakeLists.txt
++++ b/Build_iOS/CMakeLists.txt
+@@ -1,5 +1,5 @@
+ project(casablanca-ios NONE)
+-cmake_minimum_required(VERSION 3.9)
++cmake_minimum_required(VERSION 3.10)
+ 
+ enable_testing()
+ 
+--- a/Release/CMakeLists.txt
++++ b/Release/CMakeLists.txt
+@@ -1,5 +1,5 @@
+ set(CMAKE_LEGACY_CYGWIN_WIN32 0)
+-cmake_minimum_required(VERSION 3.9)
++cmake_minimum_required(VERSION 3.10)
+ if(POLICY CMP0042)
+   cmake_policy(SET CMP0042 NEW) # use MACOSX_RPATH
+ endif()
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -1,4 +1,4 @@
+-cmake_minimum_required(VERSION 3.9)

++cmake_minimum_required(VERSION 3.10)

+ project(cpprestsdk-root NONE)

+ enable_testing()

+ add_subdirectory(Release)

diff --git a/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-disabl-int-tests.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-disabl-int-tests.patch
new file mode 100644
index 000000000000..6ae6e3759c6a
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-disabl-int-tests.patch
@@ -0,0 +1,25 @@
+--- a/Release/tests/functional/http/CMakeLists.txt
++++ b/Release/tests/functional/http/CMakeLists.txt
+@@ -1,3 +1,3 @@
+ add_subdirectory(utilities)
+-add_subdirectory(client)
+-add_subdirectory(listener)
++#add_subdirectory(client)
++#add_subdirectory(listener)
+--- a/Release/tests/functional/websockets/CMakeLists.txt
++++ b/Release/tests/functional/websockets/CMakeLists.txt
+@@ -27,9 +27,9 @@ if (NOT CPPREST_EXCLUDE_WEBSOCKETS)
+     client/stdafx.cpp
+   )
+ 
+-  add_casablanca_test(websocketsclient_test SOURCES)
+-  if(NOT TEST_LIBRARY_TARGET_TYPE STREQUAL "OBJECT")
+-    target_link_libraries(websocketsclient_test PRIVATE websockettest_utilities)
+-  endif()
+-  target_include_directories(websocketsclient_test PRIVATE utilities)
++#  add_casablanca_test(websocketsclient_test SOURCES)
++#  if(NOT TEST_LIBRARY_TARGET_TYPE STREQUAL "OBJECT")
++#    target_link_libraries(websocketsclient_test PRIVATE websockettest_utilities)
++#  endif()
++#  target_include_directories(websocketsclient_test PRIVATE utilities)
+ endif()
diff --git a/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-disable-werror-default.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-disable-werror-default.patch
new file mode 100644
index 000000000000..44e56d108ce6
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-disable-werror-default.patch
@@ -0,0 +1,11 @@
+--- a/Release/CMakeLists.txt
++++ b/Release/CMakeLists.txt
+@@ -15,7 +15,7 @@ set(CPPREST_VERSION_REVISION 19)
+ 
+ enable_testing()
+ 
+-set(WERROR ON CACHE BOOL "Treat Warnings as Errors.")
++set(WERROR OFF CACHE BOOL "Treat Warnings as Errors.")
+ set(CPPREST_EXCLUDE_WEBSOCKETS OFF CACHE BOOL "Exclude websockets functionality.")
+ set(CPPREST_EXCLUDE_COMPRESSION OFF CACHE BOOL "Exclude compression functionality.")
+ set(CPPREST_EXCLUDE_BROTLI ON CACHE BOOL "Exclude Brotli compression functionality.")
diff --git a/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-char-traits-patch.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-char-traits-patch.patch
new file mode 100644
index 000000000000..d2a3ef900944
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-char-traits-patch.patch
@@ -0,0 +1,436 @@
+Also submitted upstream https://github.com/microsoft/cpprestsdk/pull/1829
+Cpprestsdk is using a lot of unsigned types like uint8_t with C++ streams, this
+seems to be fine with msvc/win32 and at least for now with gcc. This patch will
+provide a char_traits type to the streams types other than std::char_traits if
+needed. This is detected via template specialisations. Google & AIs will probably
+suggest adding a std::char_traits<unsingned char> implementation, but I think that
+is very innappropriate in a library for use by applications.
+--- a/Release/include/cpprest/streams.h	(revision 0b1ce318a757bbfb89bdb0fffb61ca4e38dc3b33)
++++ b/Release/include/cpprest/streams.h	(revision 32b322b564e5e540ff02393ffe3bd3bade8d299c)
+@@ -16,6 +16,7 @@
+ #define CASA_STREAMS_H
+ 
+ #include "cpprest/astreambuf.h"
++#include "cpprest/details/char_traits.h"
+ #include <iosfwd>
+ #include <cstdio>
+ 
+@@ -60,30 +61,95 @@
+     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;
++        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<class Traits, typename T>
++struct Value2StringFormatterUint8Format
++{
++    std::basic_string<uint8_t, Traits> operator () (const T& val)
++    {
++        std::basic_ostringstream<char> ss;
+         ss << val;
+-        return ss.str();
++        return reinterpret_cast<const uint8_t*>(ss.str().c_str());
++    }
++};
++
++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>
+-    static std::basic_string<uint8_t> format(const T& val)
++    template <typename T, class Traits = typename utility::CanUseStdCharTraits<uint8_t>::TraitsType>
++    static std::basic_string<uint8_t, Traits> format(const T& val)
+     {
+-        std::basic_ostringstream<char> ss;
+-        ss << val;
+-        return reinterpret_cast<const uint8_t*>(ss.str().c_str());
++        Value2StringFormatterUint8Format<Traits, T> format;
++        return format(val);
+     }
+ 
+-    static std::basic_string<uint8_t> format(const utf16string& 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 @@
+     /// 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 @@
+         }
+         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 @@
+         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>
+--- a/Release/include/cpprest/astreambuf.h	(revision d17f091b5a753b33fb455e92b590fc9f4e921119)
++++ b/Release/include/cpprest/astreambuf.h	(revision 4188ad89b2cf2e8de3cc3513adcf400fbfdc5ce7)
+@@ -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 @@
+ /// <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
+new file mode 100644
+--- /dev/null	(revision 4188ad89b2cf2e8de3cc3513adcf400fbfdc5ce7)
++++ b/Release/include/cpprest/details/char_traits.h	(revision 4188ad89b2cf2e8de3cc3513adcf400fbfdc5ce7)
+@@ -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
+--- a/Release/tests/functional/streams/memstream_tests.cpp	(revision d17f091b5a753b33fb455e92b590fc9f4e921119)
++++ b/Release/tests/functional/streams/memstream_tests.cpp	(revision 6df13a8c0417ef700c0f164bcd0686ad46f66fd9)
+@@ -8,6 +8,7 @@
+  *
+  * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+  ****/
++#include "cpprest/details/char_traits.h"
+ #include "stdafx.h"
+ #if defined(__cplusplus_winrt)
+ #include <wrl.h>
+@@ -32,7 +33,7 @@
+ {
+     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 @@
+ {
+     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 @@
+ 
+     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 @@
+     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 @@
+     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 @@
+     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 @@
+     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);
+--- a/Release/tests/functional/streams/stdstream_tests.cpp	(revision d17f091b5a753b33fb455e92b590fc9f4e921119)
++++ b/Release/tests/functional/streams/stdstream_tests.cpp	(revision 6df13a8c0417ef700c0f164bcd0686ad46f66fd9)
+@@ -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 @@
+ 
+         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 @@
+ 
+         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;
diff --git a/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-json-unique-ptr.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-json-unique-ptr.patch
new file mode 100644
index 000000000000..ce7f03741b0b
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-json-unique-ptr.patch
@@ -0,0 +1,221 @@
+This patch moves the implementations of certain json-methods to the cpp-file-implementations.
+This is needed because llvm needs sizeof(T) to be valid for a lot more methods on containers
+and std::unique_ptr, so these methods can't be header only on llvm. This patch is developed 
+by me and I cannot right now find an upstream bug-report on this just yet. I uploaded a similar 
+patch to FreeBSD ports a while ago. 
+--- a/Release/include/cpprest/json.h
++++ b/Release/include/cpprest/json.h
+@@ -737,12 +737,10 @@
+     _ASYNCRTIMP void format(std::basic_string<char>& string) const;
+ 
+ #ifdef ENABLE_JSON_VALUE_VISUALIZER
+-    explicit value(std::unique_ptr<details::_Value> v, value_type kind) : m_value(std::move(v)), m_kind(kind)
++    explicit value(std::unique_ptr<details::_Value> v, value_type kind);
+ #else
+-    explicit value(std::unique_ptr<details::_Value> v) : m_value(std::move(v))
++    explicit value(std::unique_ptr<details::_Value> v);
+ #endif
+-    {
+-    }
+ 
+     std::unique_ptr<details::_Value> m_value;
+ #ifdef ENABLE_JSON_VALUE_VISUALIZER
+@@ -831,9 +829,9 @@
+     typedef storage_type::size_type size_type;
+ 
+ private:
+-    array() : m_elements() {}
+-    array(size_type size) : m_elements(size) {}
+-    array(storage_type elements) : m_elements(std::move(elements)) {}
++    array();
++    array(size_type size);
++    array(storage_type elements);
+ 
+ public:
+     /// <summary>
+@@ -915,20 +913,13 @@
+     /// <returns>Iterator to the new location of the element following the erased element.</returns>
+     /// <remarks>GCC doesn't support erase with const_iterator on vector yet. In the future this should be
+     /// changed.</remarks>
+-    iterator erase(iterator position) { return m_elements.erase(position); }
++    iterator erase(iterator position);
+ 
+     /// <summary>
+     /// Deletes the element at an index of the JSON array.
+     /// </summary>
+     /// <param name="index">The index of the element to delete.</param>
+-    void erase(size_type index)
+-    {
+-        if (index >= m_elements.size())
+-        {
+-            throw json_exception("index out of bounds");
+-        }
+-        m_elements.erase(m_elements.begin() + index);
+-    }
++    void erase(size_type index);
+ 
+     /// <summary>
+     /// Accesses an element of a JSON array. Throws when index out of bounds.
+@@ -959,15 +950,7 @@
+     /// </summary>
+     /// <param name="index">The index of an element in the JSON array.</param>
+     /// <returns>A reference to the value kept in the field.</returns>
+-    json::value& operator[](size_type index)
+-    {
+-        msl::safeint3::SafeInt<size_type> nMinSize(index);
+-        nMinSize += 1;
+-        msl::safeint3::SafeInt<size_type> nlastSize(m_elements.size());
+-        if (nlastSize < nMinSize) m_elements.resize((size_type)nMinSize);
+-
+-        return m_elements[index];
+-    }
++    json::value& operator[](size_type index);
+ 
+     /// <summary>
+     /// Gets the number of elements of the array.
+@@ -998,14 +981,8 @@
+     typedef storage_type::size_type size_type;
+ 
+ private:
+-    object(bool keep_order = false) : m_elements(), m_keep_order(keep_order) {}
+-    object(storage_type elements, bool keep_order = false) : m_elements(std::move(elements)), m_keep_order(keep_order)
+-    {
+-        if (!keep_order)
+-        {
+-            sort(m_elements.begin(), m_elements.end(), compare_pairs);
+-        }
+-    }
++    object(bool keep_order = false);
++    object(storage_type elements, bool keep_order = false);
+ 
+ public:
+     /// <summary>
+@@ -1087,22 +1064,13 @@
+     /// <returns>Iterator to the new location of the element following the erased element.</returns>
+     /// <remarks>GCC doesn't support erase with const_iterator on vector yet. In the future this should be
+     /// changed.</remarks>
+-    iterator erase(iterator position) { return m_elements.erase(position); }
++    iterator erase(iterator position);
+ 
+     /// <summary>
+     /// Deletes an element of the JSON object. If the key doesn't exist, this method throws.
+     /// </summary>
+     /// <param name="key">The key of an element in the JSON object.</param>
+-    void erase(const utility::string_t& key)
+-    {
+-        auto iter = find_by_key(key);
+-        if (iter == m_elements.end())
+-        {
+-            throw web::json::json_exception("Key not found");
+-        }
+-
+-        m_elements.erase(iter);
+-    }
++    void erase(const utility::string_t& key);
+ 
+     /// <summary>
+     /// Accesses an element of a JSON object. If the key doesn't exist, this method throws.
+@@ -1142,17 +1110,7 @@
+     /// <param name="key">The key of an element in the JSON object.</param>
+     /// <returns>If the key exists, a reference to the value kept in the field, otherwise a newly created null value
+     /// that will be stored for the given key.</returns>
+-    json::value& operator[](const utility::string_t& key)
+-    {
+-        auto iter = find_insert_location(key);
+-
+-        if (iter == m_elements.end() || key != iter->first)
+-        {
+-            return m_elements.insert(iter, std::pair<utility::string_t, value>(key, value()))->second;
+-        }
+-
+-        return iter->second;
+-    }
++    json::value& operator[](const utility::string_t& key);
+ 
+     /// <summary>
+     /// Gets an iterator to an element of a JSON object.
+--- a/Release/src/json/json.cpp
++++ b/Release/src/json/json.cpp
+@@ -135,6 +135,14 @@
+ {
+ }
+ 
++#ifdef ENABLE_JSON_VALUE_VISUALIZER
++web::json::value::value(std::unique_ptr<details::_Value> v, value_type kind) : m_value(std::move(v)), m_kind(kind)
++#else
++web::json::value::value(std::unique_ptr<details::_Value> v) : m_value(std::move(v))
++#endif
++{
++}
++
+ web::json::value::value(const value& other)
+     : m_value(other.m_value->_copy_value())
+ #ifdef ENABLE_JSON_VALUE_VISUALIZER
+@@ -495,3 +503,67 @@
+ #endif
+     return instance;
+ }
++
++web::json::array::array() : m_elements() {}
++web::json::array::array(size_type size) : m_elements(size) {}
++web::json::array::array(storage_type elements) : m_elements(std::move(elements)) {}
++
++web::json::array::iterator web::json::array::erase(web::json::array::iterator position)
++{
++    return m_elements.erase(position);
++}
++
++void web::json::array::erase(web::json::array::size_type index)
++{
++    if (index >= m_elements.size())
++    {
++        throw json_exception("index out of bounds");
++    }
++    m_elements.erase(m_elements.begin() + index);
++}
++
++json::value& web::json::array::operator[](web::json::array::size_type index)
++{
++    msl::safeint3::SafeInt<size_type> nMinSize(index);
++    nMinSize += 1;
++    msl::safeint3::SafeInt<size_type> nlastSize(m_elements.size());
++    if (nlastSize < nMinSize) m_elements.resize((size_type)nMinSize);
++
++    return m_elements[index];
++}
++
++web::json::object::object(bool keep_order) : m_elements(), m_keep_order(keep_order) {}
++web::json::object::object(storage_type elements, bool keep_order) : m_elements(std::move(elements)), m_keep_order(keep_order)
++{
++    if (!keep_order)
++    {
++        sort(m_elements.begin(), m_elements.end(), compare_pairs);
++    }
++}
++web::json::object::iterator web::json::object::erase(iterator position)
++{
++    return m_elements.erase(position);
++}
++
++void web::json::object::erase(const utility::string_t& key)
++{
++    auto iter = find_by_key(key);
++    if (iter == m_elements.end())
++    {
++        throw web::json::json_exception("Key not found");
++    }
++
++    m_elements.erase(iter);
++}
++
++json::value& web::json::object::operator[](const utility::string_t& key)
++{
++    auto iter = find_insert_location(key);
++
++    if (iter == m_elements.end() || key != iter->first)
++    {
++        return m_elements.insert(iter, std::pair<utility::string_t, value>(key, value()))->second;
++    }
++
++    return iter->second;
++}
diff --git a/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-warnings.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-warnings.patch
new file mode 100644
index 000000000000..dc663ec0c77e
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-warnings.patch
@@ -0,0 +1,11 @@
+--- a/Release/src/http/common/http_helpers.cpp	2021-02-02 05:03:00.000000000 +0100
++++ b/Release/src/http/common/http_helpers.cpp	2022-12-08 08:42:47.321677974 +0100
+@@ -84,7 +84,7 @@
+     }
+     else
+     {
+-        char buffer[9];
++        char buffer[17];
+ #ifdef _WIN32
+         sprintf_s(buffer, sizeof(buffer), "%8IX", bytes_read);
+ #else
diff --git a/dev-cpp/cpprestsdk/metadata.xml b/dev-cpp/cpprestsdk/metadata.xml
new file mode 100644
index 000000000000..8d2ae765321d
--- /dev/null
+++ b/dev-cpp/cpprestsdk/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "https://docs.baldeagleos.com/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer type="person">
+    <email>sigsegv@radiotube.org</email>
+    <description>Jan-Espen Oversand</description>
+  </maintainer>
+  <origin>baldeagleos-repo</origin>
+</pkgmetadata>