Update WIP discord and some vendors.

CPR has features disabled and PCRE is fully disabled until updated to new code.
2025-09-15 16:57:19 +02:00 · 2023-08-05 21:31:33 +03:00
parent e0761bf3b9
commit 9298065cef
1562 changed files with 55070 additions and 76299 deletions
--- a/vendor/CPR/include/cpr/accept_encoding.h
+++ b/vendor/CPR/include/cpr/accept_encoding.h
@@ -0,0 +1,41 @@
+#ifndef CPR_ACCEPT_ENCODING_H
+#define CPR_ACCEPT_ENCODING_H
+
+#include <curl/curlver.h>
+#include <initializer_list>
+#include <map>
+#include <string>
+#include <unordered_set>
+
+namespace cpr {
+
+enum class AcceptEncodingMethods {
+    identity,
+    deflate,
+    zlib,
+    gzip,
+    disabled,
+};
+
+// NOLINTNEXTLINE(cert-err58-cpp)
+static const std::map<AcceptEncodingMethods, std::string> AcceptEncodingMethodsStringMap{{AcceptEncodingMethods::identity, "identity"}, {AcceptEncodingMethods::deflate, "deflate"}, {AcceptEncodingMethods::zlib, "zlib"}, {AcceptEncodingMethods::gzip, "gzip"}, {AcceptEncodingMethods::disabled, "disabled"}};
+
+class AcceptEncoding {
+  public:
+    AcceptEncoding() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    AcceptEncoding(const std::initializer_list<AcceptEncodingMethods>& methods);
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    AcceptEncoding(const std::initializer_list<std::string>& methods);
+
+    [[nodiscard]] bool empty() const noexcept;
+    [[nodiscard]] const std::string getString() const;
+    [[nodiscard]] bool disabled() const;
+
+  private:
+    std::unordered_set<std::string> methods_;
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/api.h
+++ b/vendor/CPR/include/cpr/api.h
@@ -7,27 +7,108 @@
 #include <string>
 #include <utility>

+#include "cpr/async.h"
+#include "cpr/async_wrapper.h"
 #include "cpr/auth.h"
 #include "cpr/bearer.h"
 #include "cpr/cprtypes.h"
-#include "cpr/digest.h"
 #include "cpr/multipart.h"
-#include "cpr/ntlm.h"
+#include "cpr/multiperform.h"
 #include "cpr/payload.h"
 #include "cpr/response.h"
 #include "cpr/session.h"
-#include <utility>
+#include <cpr/filesystem.h>

 namespace cpr {

-using AsyncResponse = std::future<Response>;
+using AsyncResponse = AsyncWrapper<Response>;

 namespace priv {

+template <bool processed_header, typename CurrentType>
+void set_option_internal(Session& session, CurrentType&& current_option) {
+    session.SetOption(std::forward<CurrentType>(current_option));
+}
+
+template <>
+inline void set_option_internal<true, Header>(Session& session, Header&& current_option) {
+    // Header option was already provided -> Update previous header
+    session.UpdateHeader(std::forward<Header>(current_option));
+}
+
+template <bool processed_header, typename CurrentType, typename... Ts>
+void set_option_internal(Session& session, CurrentType&& current_option, Ts&&... ts) {
+    set_option_internal<processed_header, CurrentType>(session, std::forward<CurrentType>(current_option));
+
+    if (std::is_same<CurrentType, Header>::value) {
+        set_option_internal<true, Ts...>(session, std::forward<Ts>(ts)...);
+    } else {
+        set_option_internal<processed_header, Ts...>(session, std::forward<Ts>(ts)...);
+    }
+}
+
 template <typename... Ts>
 void set_option(Session& session, Ts&&... ts) {
-    std::initializer_list<int> ignore = { (session.SetOption(std::forward<Ts>(ts)), 0)... };
-    (void)ignore;
+    set_option_internal<false, Ts...>(session, std::forward<Ts>(ts)...);
+}
+
+// Idea: https://stackoverflow.com/a/19060157
+template <typename Tuple, std::size_t... I>
+void apply_set_option_internal(Session& session, Tuple&& t, std::index_sequence<I...>) {
+    set_option(session, std::get<I>(std::forward<Tuple>(t))...);
+}
+
+// Idea: https://stackoverflow.com/a/19060157
+template <typename Tuple>
+void apply_set_option(Session& session, Tuple&& t) {
+    using Indices = std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>;
+    apply_set_option_internal(session, std::forward<Tuple>(t), Indices());
+}
+
+template <typename T>
+void setup_multiperform_internal(MultiPerform& multiperform, T&& t) {
+    std::shared_ptr<Session> session = std::make_shared<Session>();
+    apply_set_option(*session, t);
+    multiperform.AddSession(session);
+}
+
+template <typename T, typename... Ts>
+void setup_multiperform_internal(MultiPerform& multiperform, T&& t, Ts&&... ts) {
+    std::shared_ptr<Session> session = std::make_shared<Session>();
+    apply_set_option(*session, t);
+    multiperform.AddSession(session);
+    setup_multiperform_internal<Ts...>(multiperform, std::forward<Ts>(ts)...);
+}
+
+template <typename... Ts>
+void setup_multiperform(MultiPerform& multiperform, Ts&&... ts) {
+    setup_multiperform_internal<Ts...>(multiperform, std::forward<Ts>(ts)...);
+}
+
+using session_action_t = cpr::Response (cpr::Session::*)();
+
+template <session_action_t SessionAction, typename T>
+void setup_multiasync(std::vector<AsyncWrapper<Response, true>>& responses, T&& parameters) {
+    std::shared_ptr<std::atomic_bool> cancellation_state = std::make_shared<std::atomic_bool>(false);
+
+    std::function<Response(T)> execFn{[cancellation_state](T params) {
+        if (cancellation_state->load()) {
+            return Response{};
+        }
+        cpr::Session s{};
+        s.SetCancellationParam(cancellation_state);
+        apply_set_option(s, std::forward<T>(params));
+        return std::invoke(SessionAction, s);
+    }};
+    responses.emplace_back(GlobalThreadPool::GetInstance()->Submit(std::move(execFn), std::forward<T>(parameters)), std::move(cancellation_state));
+}
+
+template <session_action_t SessionAction, typename T, typename... Ts>
+void setup_multiasync(std::vector<AsyncWrapper<Response, true>>& responses, T&& head, Ts&&... tail) {
+    setup_multiasync<SessionAction>(responses, std::forward<T>(head));
+    if constexpr (sizeof...(Ts) > 0) {
+        setup_multiasync<SessionAction>(responses, std::forward<Ts>(tail)...);
+    }
 }

 } // namespace priv
@@ -43,17 +124,14 @@ Response Get(Ts&&... ts) {
 // Get async methods
 template <typename... Ts>
 AsyncResponse GetAsync(Ts... ts) {
-    return std::async(
-            std::launch::async, [](Ts... ts_inner) { return Get(std::move(ts_inner)...); }, std::move(ts)...);
+    return cpr::async([](Ts... ts_inner) { return Get(std::move(ts_inner)...); }, std::move(ts)...);
 }

 // Get callback methods
 template <typename Then, typename... Ts>
 // NOLINTNEXTLINE(fuchsia-trailing-return)
-auto GetCallback(Then then, Ts... ts) -> std::future<decltype(then(Get(std::move(ts)...)))> {
-    return std::async(
-            std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Get(std::move(ts_inner)...)); },
-            std::move(then), std::move(ts)...);
+auto GetCallback(Then then, Ts... ts) {
+    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Get(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
 }

 // Post methods
@@ -67,17 +145,14 @@ Response Post(Ts&&... ts) {
 // Post async methods
 template <typename... Ts>
 AsyncResponse PostAsync(Ts... ts) {
-    return std::async(
-            std::launch::async, [](Ts... ts_inner) { return Post(std::move(ts_inner)...); }, std::move(ts)...);
+    return cpr::async([](Ts... ts_inner) { return Post(std::move(ts_inner)...); }, std::move(ts)...);
 }

 // Post callback methods
 template <typename Then, typename... Ts>
 // NOLINTNEXTLINE(fuchsia-trailing-return)
-auto PostCallback(Then then, Ts... ts) -> std::future<decltype(then(Post(std::move(ts)...)))> {
-    return std::async(
-            std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Post(std::move(ts_inner)...)); },
-            std::move(then), std::move(ts)...);
+auto PostCallback(Then then, Ts... ts) {
+    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Post(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
 }

 // Put methods
@@ -91,17 +166,14 @@ Response Put(Ts&&... ts) {
 // Put async methods
 template <typename... Ts>
 AsyncResponse PutAsync(Ts... ts) {
-    return std::async(
-            std::launch::async, [](Ts... ts_inner) { return Put(std::move(ts_inner)...); }, std::move(ts)...);
+    return cpr::async([](Ts... ts_inner) { return Put(std::move(ts_inner)...); }, std::move(ts)...);
 }

 // Put callback methods
 template <typename Then, typename... Ts>
 // NOLINTNEXTLINE(fuchsia-trailing-return)
-auto PutCallback(Then then, Ts... ts) -> std::future<decltype(then(Put(std::move(ts)...)))> {
-    return std::async(
-            std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Put(std::move(ts_inner)...)); },
-            std::move(then), std::move(ts)...);
+auto PutCallback(Then then, Ts... ts) {
+    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Put(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
 }

 // Head methods
@@ -115,17 +187,14 @@ Response Head(Ts&&... ts) {
 // Head async methods
 template <typename... Ts>
 AsyncResponse HeadAsync(Ts... ts) {
-    return std::async(
-            std::launch::async, [](Ts... ts_inner) { return Head(std::move(ts_inner)...); }, std::move(ts)...);
+    return cpr::async([](Ts... ts_inner) { return Head(std::move(ts_inner)...); }, std::move(ts)...);
 }

 // Head callback methods
 template <typename Then, typename... Ts>
 // NOLINTNEXTLINE(fuchsia-trailing-return)
-auto HeadCallback(Then then, Ts... ts) -> std::future<decltype(then(Head(std::move(ts)...)))> {
-    return std::async(
-            std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Head(std::move(ts_inner)...)); },
-            std::move(then), std::move(ts)...);
+auto HeadCallback(Then then, Ts... ts) {
+    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Head(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
 }

 // Delete methods
@@ -139,18 +208,14 @@ Response Delete(Ts&&... ts) {
 // Delete async methods
 template <typename... Ts>
 AsyncResponse DeleteAsync(Ts... ts) {
-    return std::async(
-            std::launch::async, [](Ts... ts_inner) { return Delete(std::move(ts_inner)...); },
-            std::move(ts)...);
+    return cpr::async([](Ts... ts_inner) { return Delete(std::move(ts_inner)...); }, std::move(ts)...);
 }

 // Delete callback methods
 template <typename Then, typename... Ts>
 // NOLINTNEXTLINE(fuchsia-trailing-return)
-auto DeleteCallback(Then then, Ts... ts) -> std::future<decltype(then(Delete(std::move(ts)...)))> {
-    return std::async(
-            std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Delete(std::move(ts_inner)...)); },
-            std::move(then), std::move(ts)...);
+auto DeleteCallback(Then then, Ts... ts) {
+    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Delete(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
 }

 // Options methods
@@ -164,19 +229,14 @@ Response Options(Ts&&... ts) {
 // Options async methods
 template <typename... Ts>
 AsyncResponse OptionsAsync(Ts... ts) {
-    return std::async(
-            std::launch::async, [](Ts... ts_inner) { return Options(std::move(ts_inner)...); },
-            std::move(ts)...);
+    return cpr::async([](Ts... ts_inner) { return Options(std::move(ts_inner)...); }, std::move(ts)...);
 }

 // Options callback methods
 template <typename Then, typename... Ts>
 // NOLINTNEXTLINE(fuchsia-trailing-return)
-auto OptionsCallback(Then then, Ts... ts)
-        -> std::future<decltype(then(Options(std::move(ts)...)))> {
-    return std::async(
-            std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Options(std::move(ts_inner)...)); },
-            std::move(then), std::move(ts)...);
+auto OptionsCallback(Then then, Ts... ts) {
+    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Options(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
 }

 // Patch methods
@@ -190,17 +250,14 @@ Response Patch(Ts&&... ts) {
 // Patch async methods
 template <typename... Ts>
 AsyncResponse PatchAsync(Ts... ts) {
-    return std::async(
-            std::launch::async, [](Ts... ts_inner) { return Patch(std::move(ts_inner)...); }, std::move(ts)...);
+    return cpr::async([](Ts... ts_inner) { return Patch(std::move(ts_inner)...); }, std::move(ts)...);
 }

 // Patch callback methods
 template <typename Then, typename... Ts>
 // NOLINTNEXTLINE(fuchsia-trailing-return)
-auto PatchCallback(Then then, Ts... ts) -> std::future<decltype(then(Patch(std::move(ts)...)))> {
-    return std::async(
-            std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Patch(std::move(ts_inner)...)); },
-            std::move(then), std::move(ts)...);
+auto PatchCallback(Then then, Ts... ts) {
+    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Patch(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
 }

 // Download methods
@@ -211,6 +268,18 @@ Response Download(std::ofstream& file, Ts&&... ts) {
    return session.Download(file);
 }

+// Download async method
+template <typename... Ts>
+AsyncResponse DownloadAsync(fs::path local_path, Ts... ts) {
+    return AsyncWrapper{std::async(
+            std::launch::async,
+            [](fs::path local_path_, Ts... ts_) {
+                std::ofstream f(local_path_.c_str());
+                return Download(f, std::move(ts_)...);
+            },
+            std::move(local_path), std::move(ts)...)};
+}
+
 // Download with user callback
 template <typename... Ts>
 Response Download(const WriteCallback& write, Ts&&... ts) {
@@ -219,6 +288,105 @@ Response Download(const WriteCallback& write, Ts&&... ts) {
    return session.Download(write);
 }

+// Multi requests
+template <typename... Ts>
+std::vector<Response> MultiGet(Ts&&... ts) {
+    MultiPerform multiperform;
+    priv::setup_multiperform<Ts...>(multiperform, std::forward<Ts>(ts)...);
+    return multiperform.Get();
+}
+
+template <typename... Ts>
+std::vector<Response> MultiDelete(Ts&&... ts) {
+    MultiPerform multiperform;
+    priv::setup_multiperform<Ts...>(multiperform, std::forward<Ts>(ts)...);
+    return multiperform.Delete();
+}
+
+template <typename... Ts>
+std::vector<Response> MultiPut(Ts&&... ts) {
+    MultiPerform multiperform;
+    priv::setup_multiperform<Ts...>(multiperform, std::forward<Ts>(ts)...);
+    return multiperform.Put();
+}
+
+template <typename... Ts>
+std::vector<Response> MultiHead(Ts&&... ts) {
+    MultiPerform multiperform;
+    priv::setup_multiperform<Ts...>(multiperform, std::forward<Ts>(ts)...);
+    return multiperform.Head();
+}
+
+template <typename... Ts>
+std::vector<Response> MultiOptions(Ts&&... ts) {
+    MultiPerform multiperform;
+    priv::setup_multiperform<Ts...>(multiperform, std::forward<Ts>(ts)...);
+    return multiperform.Options();
+}
+
+template <typename... Ts>
+std::vector<Response> MultiPatch(Ts&&... ts) {
+    MultiPerform multiperform;
+    priv::setup_multiperform<Ts...>(multiperform, std::forward<Ts>(ts)...);
+    return multiperform.Patch();
+}
+
+template <typename... Ts>
+std::vector<Response> MultiPost(Ts&&... ts) {
+    MultiPerform multiperform;
+    priv::setup_multiperform<Ts...>(multiperform, std::forward<Ts>(ts)...);
+    return multiperform.Post();
+}
+
+template <typename... Ts>
+std::vector<AsyncWrapper<Response, true>> MultiGetAsync(Ts&&... ts) {
+    std::vector<AsyncWrapper<Response, true>> ret{};
+    priv::setup_multiasync<&cpr::Session::Get>(ret, std::forward<Ts>(ts)...);
+    return ret;
+}
+
+template <typename... Ts>
+std::vector<AsyncWrapper<Response, true>> MultiDeleteAsync(Ts&&... ts) {
+    std::vector<AsyncWrapper<Response, true>> ret{};
+    priv::setup_multiasync<&cpr::Session::Delete>(ret, std::forward<Ts>(ts)...);
+    return ret;
+}
+
+template <typename... Ts>
+std::vector<AsyncWrapper<Response, true>> MultiHeadAsync(Ts&&... ts) {
+    std::vector<AsyncWrapper<Response, true>> ret{};
+    priv::setup_multiasync<&cpr::Session::Head>(ret, std::forward<Ts>(ts)...);
+    return ret;
+}
+template <typename... Ts>
+std::vector<AsyncWrapper<Response, true>> MultiOptionsAsync(Ts&&... ts) {
+    std::vector<AsyncWrapper<Response, true>> ret{};
+    priv::setup_multiasync<&cpr::Session::Options>(ret, std::forward<Ts>(ts)...);
+    return ret;
+}
+
+template <typename... Ts>
+std::vector<AsyncWrapper<Response, true>> MultiPatchAsync(Ts&&... ts) {
+    std::vector<AsyncWrapper<Response, true>> ret{};
+    priv::setup_multiasync<&cpr::Session::Patch>(ret, std::forward<Ts>(ts)...);
+    return ret;
+}
+
+template <typename... Ts>
+std::vector<AsyncWrapper<Response, true>> MultiPostAsync(Ts&&... ts) {
+    std::vector<AsyncWrapper<Response, true>> ret{};
+    priv::setup_multiasync<&cpr::Session::Post>(ret, std::forward<Ts>(ts)...);
+    return ret;
+}
+
+template <typename... Ts>
+std::vector<AsyncWrapper<Response, true>> MultiPutAsync(Ts&&... ts) {
+    std::vector<AsyncWrapper<Response, true>> ret{};
+    priv::setup_multiasync<&cpr::Session::Put>(ret, std::forward<Ts>(ts)...);
+    return ret;
+}
+
+
 } // namespace cpr

 #endif
--- a/vendor/CPR/include/cpr/async.h
+++ b/vendor/CPR/include/cpr/async.h
@@ -0,0 +1,50 @@
+#ifndef CPR_ASYNC_H
+#define CPR_ASYNC_H
+
+#include "async_wrapper.h"
+#include "singleton.h"
+#include "threadpool.h"
+
+namespace cpr {
+
+class GlobalThreadPool : public ThreadPool {
+    CPR_SINGLETON_DECL(GlobalThreadPool)
+  protected:
+    GlobalThreadPool() = default;
+
+  public:
+    ~GlobalThreadPool() override = default;
+};
+
+/**
+ * Return a wrapper for a future, calling future.get() will wait until the task is done and return RetType.
+ * async(fn, args...)
+ * async(std::bind(&Class::mem_fn, &obj))
+ * async(std::mem_fn(&Class::mem_fn, &obj))
+ **/
+template <class Fn, class... Args>
+auto async(Fn&& fn, Args&&... args) {
+    return AsyncWrapper{GlobalThreadPool::GetInstance()->Submit(std::forward<Fn>(fn), std::forward<Args>(args)...)};
+}
+
+class async {
+  public:
+    static void startup(size_t min_threads = CPR_DEFAULT_THREAD_POOL_MIN_THREAD_NUM, size_t max_threads = CPR_DEFAULT_THREAD_POOL_MAX_THREAD_NUM, std::chrono::milliseconds max_idle_ms = CPR_DEFAULT_THREAD_POOL_MAX_IDLE_TIME) {
+        GlobalThreadPool* gtp = GlobalThreadPool::GetInstance();
+        if (gtp->IsStarted()) {
+            return;
+        }
+        gtp->SetMinThreadNum(min_threads);
+        gtp->SetMaxThreadNum(max_threads);
+        gtp->SetMaxIdleTime(max_idle_ms);
+        gtp->Start();
+    }
+
+    static void cleanup() {
+        GlobalThreadPool::ExitInstance();
+    }
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/async_wrapper.h
+++ b/vendor/CPR/include/cpr/async_wrapper.h
@@ -0,0 +1,140 @@
+#ifndef CPR_ASYNC_WRAPPER_H
+#define CPR_ASYNC_WRAPPER_H
+
+#include <atomic>
+#include <future>
+#include <memory>
+
+#include "cpr/response.h"
+
+namespace cpr {
+enum class [[nodiscard]] CancellationResult { failure, success, invalid_operation };
+
+/**
+ * A class template intended to wrap results of async operations (instances of std::future<T>)
+ * and also provide extended capablilities relaed to these requests, for example cancellation.
+ *
+ * The RAII semantics are the same as std::future<T> - moveable, not copyable.
+ */
+template <typename T, bool isCancellable = false>
+class AsyncWrapper {
+  private:
+    std::future<T> future;
+    std::shared_ptr<std::atomic_bool> is_cancelled;
+
+  public:
+    // Constructors
+    explicit AsyncWrapper(std::future<T>&& f) : future{std::move(f)} {}
+    AsyncWrapper(std::future<T>&& f, std::shared_ptr<std::atomic_bool>&& cancelledState) : future{std::move(f)}, is_cancelled{std::move(cancelledState)} {}
+
+    // Copy Semantics
+    AsyncWrapper(const AsyncWrapper&) = delete;
+    AsyncWrapper& operator=(const AsyncWrapper&) = delete;
+
+    // Move Semantics
+    AsyncWrapper(AsyncWrapper&&) noexcept = default;
+    AsyncWrapper& operator=(AsyncWrapper&&) noexcept = default;
+
+    // Destructor
+    ~AsyncWrapper() {
+        if constexpr (isCancellable) {
+            if(is_cancelled) {
+                is_cancelled->store(true);
+            }
+        }
+    }
+    // These methods replicate the behaviour of std::future<T>
+    [[nodiscard]] T get() {
+        if constexpr (isCancellable) {
+            if (IsCancelled()) {
+                throw std::logic_error{"Calling AsyncWrapper::get on a cancelled request!"};
+            }
+        }
+        if (!future.valid()) {
+            throw std::logic_error{"Calling AsyncWrapper::get when the associated future instance is invalid!"};
+        }
+        return future.get();
+    }
+
+    [[nodiscard]] bool valid() const noexcept {
+        if constexpr (isCancellable) {
+            return !is_cancelled->load() && future.valid();
+        } else {
+            return future.valid();
+        }
+    }
+
+    void wait() const {
+        if constexpr (isCancellable) {
+            if (is_cancelled->load()) {
+                throw std::logic_error{"Calling AsyncWrapper::wait when the associated future is invalid or cancelled!"};
+            }
+        }
+        if (!future.valid()) {
+            throw std::logic_error{"Calling AsyncWrapper::wait_until when the associated future is invalid!"};
+        }
+        future.wait();
+    }
+
+    template <class Rep, class Period>
+    std::future_status wait_for(const std::chrono::duration<Rep, Period>& timeout_duration) const {
+        if constexpr (isCancellable) {
+            if (IsCancelled()) {
+                throw std::logic_error{"Calling AsyncWrapper::wait_for when the associated future is cancelled!"};
+            }
+        }
+        if (!future.valid()) {
+            throw std::logic_error{"Calling AsyncWrapper::wait_until when the associated future is invalid!"};
+        }
+        return future.wait_for(timeout_duration);
+    }
+
+    template <class Clock, class Duration>
+    std::future_status wait_until(const std::chrono::time_point<Clock, Duration>& timeout_time) const {
+        if constexpr (isCancellable) {
+            if (IsCancelled()) {
+                throw std::logic_error{"Calling AsyncWrapper::wait_until when the associated future is cancelled!"};
+            }
+        }
+        if (!future.valid()) {
+            throw std::logic_error{"Calling AsyncWrapper::wait_until when the associated future is invalid!"};
+        }
+        return future.wait_until(timeout_time);
+    }
+
+    std::shared_future<T> share() noexcept {
+        return future.share();
+    }
+
+    // Cancellation-related methods
+    CancellationResult Cancel() {
+        if constexpr (!isCancellable) {
+            return CancellationResult::invalid_operation;
+        }
+        if (!future.valid() || is_cancelled->load()) {
+            return CancellationResult::invalid_operation;
+        }
+        is_cancelled->store(true);
+        return CancellationResult::success;
+    }
+
+    [[nodiscard]] bool IsCancelled() const {
+        if constexpr (isCancellable) {
+            return is_cancelled->load();
+        } else {
+            return false;
+        }
+    }
+};
+
+// Deduction guides
+template <typename T>
+AsyncWrapper(std::future<T>&&) -> AsyncWrapper<T, false>;
+
+template <typename T>
+AsyncWrapper(std::future<T>&&, std::shared_ptr<std::atomic_bool>&&) -> AsyncWrapper<T, true>;
+
+} // namespace cpr
+
+
+#endif
--- a/vendor/CPR/include/cpr/auth.h
+++ b/vendor/CPR/include/cpr/auth.h
@@ -7,23 +7,24 @@

 namespace cpr {

+enum class AuthMode { BASIC, DIGEST, NTLM };
+
 class Authentication {
  public:
-    Authentication(const std::string& username, const std::string& password)
-            : auth_string_{username + ":" + password} {}
-    Authentication(std::string&& username, std::string&& password)
-            : auth_string_{std::move(username) + ":" + std::move(password)} {}
+    Authentication(std::string username, std::string password, AuthMode auth_mode) : auth_string_{std::move(username) + ":" + std::move(password)}, auth_mode_{std::move(auth_mode)} {}
    Authentication(const Authentication& other) = default;
    Authentication(Authentication&& old) noexcept = default;
-    virtual ~Authentication() noexcept = default;
+    ~Authentication() noexcept;

    Authentication& operator=(Authentication&& old) noexcept = default;
    Authentication& operator=(const Authentication& other) = default;

-    virtual const char* GetAuthString() const noexcept;
+    const char* GetAuthString() const noexcept;
+    AuthMode GetAuthMode() const noexcept;

-  protected:
+  private:
    std::string auth_string_;
+    AuthMode auth_mode_;
 };

 } // namespace cpr
--- a/vendor/CPR/include/cpr/bearer.h
+++ b/vendor/CPR/include/cpr/bearer.h
@@ -1,8 +1,8 @@
 #ifndef CPR_BEARER_H
 #define CPR_BEARER_H

-#include <string>
 #include <curl/curlver.h>
+#include <string>

 #include <utility>

@@ -14,12 +14,10 @@ namespace cpr {
 class Bearer {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Bearer(const std::string& token) : token_string_{token} {}
-    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Bearer(std::string&& token) : token_string_{std::move(token)} {}
+    Bearer(std::string token) : token_string_{std::move(token)} {}
    Bearer(const Bearer& other) = default;
    Bearer(Bearer&& old) noexcept = default;
-    virtual ~Bearer() noexcept = default;
+    virtual ~Bearer() noexcept;

    Bearer& operator=(Bearer&& old) noexcept = default;
    Bearer& operator=(const Bearer& other) = default;
--- a/vendor/CPR/include/cpr/body.h
+++ b/vendor/CPR/include/cpr/body.h
@@ -1,24 +1,46 @@
 #ifndef CPR_BODY_H
 #define CPR_BODY_H

+#include <exception>
+#include <fstream>
 #include <initializer_list>
 #include <string>
+#include <vector>

+#include "cpr/buffer.h"
 #include "cpr/cprtypes.h"
+#include "cpr/file.h"

 namespace cpr {

 class Body : public StringHolder<Body> {
  public:
-    Body() : StringHolder<Body>() {}
+    Body() = default;
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Body(const std::string& body) : StringHolder<Body>(body) {}
+    Body(std::string body) : StringHolder<Body>(std::move(body)) {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Body(std::string&& body) : StringHolder<Body>(std::move(body)) {}
+    Body(std::string_view body) : StringHolder<Body>(body) {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    Body(const char* body) : StringHolder<Body>(body) {}
    Body(const char* str, size_t len) : StringHolder<Body>(str, len) {}
    Body(const std::initializer_list<std::string> args) : StringHolder<Body>(args) {}
+    // NOLINTNEXTLINE(google-explicit-constructor, cppcoreguidelines-pro-type-reinterpret-cast)
+    Body(const Buffer& buffer) : StringHolder<Body>(reinterpret_cast<const char*>(buffer.data), static_cast<size_t>(buffer.datalen)) {}
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    Body(const File& file) {
+        std::ifstream is(file.filepath, std::ifstream::binary);
+        if (!is) {
+            throw std::invalid_argument("Can't open the file for HTTP request body!");
+        }
+
+        is.seekg(0, std::ios::end);
+        const std::streampos length = is.tellg();
+        is.seekg(0, std::ios::beg);
+        std::string buffer;
+        buffer.resize(static_cast<size_t>(length));
+        is.read(buffer.data(), length);
+        str_ = std::move(buffer);
+    }
    Body(const Body& other) = default;
    Body(Body&& old) noexcept = default;
    ~Body() override = default;
--- a/vendor/CPR/include/cpr/buffer.h
+++ b/vendor/CPR/include/cpr/buffer.h
@@ -0,0 +1,33 @@
+#ifndef CPR_BUFFER_H
+#define CPR_BUFFER_H
+
+#include <string>
+
+#include <cpr/filesystem.h>
+
+namespace cpr {
+
+struct Buffer {
+    using data_t = const char*;
+
+    template <typename Iterator>
+    Buffer(Iterator begin, Iterator end, fs::path&& p_filename)
+            // Ignored here since libcurl reqires a long.
+            // There is also no way around the reinterpret_cast.
+            // NOLINTNEXTLINE(google-runtime-int, cppcoreguidelines-pro-type-reinterpret-cast)
+            : data{reinterpret_cast<data_t>(&(*begin))}, datalen{static_cast<size_t>(std::distance(begin, end))}, filename(std::move(p_filename)) {
+        is_random_access_iterator(begin, end);
+        static_assert(sizeof(*begin) == 1, "Only byte buffers can be used");
+    }
+
+    template <typename Iterator>
+    typename std::enable_if<std::is_same<typename std::iterator_traits<Iterator>::iterator_category, std::random_access_iterator_tag>::value>::type is_random_access_iterator(Iterator /* begin */, Iterator /* end */) {}
+
+    data_t data;
+    size_t datalen;
+    const fs::path filename;
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/callback.h
+++ b/vendor/CPR/include/cpr/callback.h
@@ -3,7 +3,9 @@

 #include "cprtypes.h"

+#include <atomic>
 #include <functional>
+#include <optional>
 #include <utility>

 namespace cpr {
@@ -14,11 +16,11 @@ class ReadCallback {
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    ReadCallback(std::function<bool(char* buffer, size_t& size, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), size{-1}, callback{std::move(p_callback)} {}
    ReadCallback(cpr_off_t p_size, std::function<bool(char* buffer, size_t& size, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), size{p_size}, callback{std::move(p_callback)} {}
-    bool operator()(char* buffer, size_t& size) const {
-        return callback(buffer, size, userdata);
+    bool operator()(char* buffer, size_t& buffer_size) const {
+        return callback(buffer, buffer_size, userdata);
    }

-    intptr_t userdata;
+    intptr_t userdata{};
    cpr_off_t size{};
    std::function<bool(char* buffer, size_t& size, intptr_t userdata)> callback;
 };
@@ -32,7 +34,7 @@ class HeaderCallback {
        return callback(std::move(header), userdata);
    }

-    intptr_t userdata;
+    intptr_t userdata{};
    std::function<bool(std::string header, intptr_t userdata)> callback;
 };

@@ -45,7 +47,7 @@ class WriteCallback {
        return callback(std::move(data), userdata);
    }

-    intptr_t userdata;
+    intptr_t userdata{};
    std::function<bool(std::string data, intptr_t userdata)> callback;
 };

@@ -53,13 +55,13 @@ class ProgressCallback {
  public:
    ProgressCallback() = default;
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    ProgressCallback(std::function<bool(cpr_off_t downloadTotal, cpr_off_t downloadNow, cpr_off_t uploadTotal, cpr_off_t uploadNow, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), callback(std::move(p_callback)) {}
-    bool operator()(cpr_off_t downloadTotal, cpr_off_t downloadNow, cpr_off_t uploadTotal, cpr_off_t uploadNow) const {
+    ProgressCallback(std::function<bool(cpr_pf_arg_t downloadTotal, cpr_pf_arg_t downloadNow, cpr_pf_arg_t uploadTotal, cpr_pf_arg_t uploadNow, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), callback(std::move(p_callback)) {}
+    bool operator()(cpr_pf_arg_t downloadTotal, cpr_pf_arg_t downloadNow, cpr_pf_arg_t uploadTotal, cpr_pf_arg_t uploadNow) const {
        return callback(downloadTotal, downloadNow, uploadTotal, uploadNow, userdata);
    }

-    intptr_t userdata;
-    std::function<bool(size_t downloadTotal, size_t downloadNow, size_t uploadTotal, size_t uploadNow, intptr_t userdata)> callback;
+    intptr_t userdata{};
+    std::function<bool(cpr_pf_arg_t downloadTotal, cpr_pf_arg_t downloadNow, cpr_pf_arg_t uploadTotal, cpr_pf_arg_t uploadNow, intptr_t userdata)> callback;
 };

 class DebugCallback {
@@ -80,10 +82,30 @@ class DebugCallback {
        callback(type, std::move(data), userdata);
    }

-    intptr_t userdata;
+    intptr_t userdata{};
    std::function<void(InfoType type, std::string data, intptr_t userdata)> callback;
 };

+/**
+ * Functor class for progress functions that will be used in cancellable requests.
+ */
+class CancellationCallback {
+  public:
+    CancellationCallback() = default;
+    explicit CancellationCallback(std::shared_ptr<std::atomic_bool>&& cs) : cancellation_state{std::move(cs)} {}
+
+    CancellationCallback(std::shared_ptr<std::atomic_bool>&& cs, ProgressCallback& u_cb) : cancellation_state{std::move(cs)}, user_cb{std::reference_wrapper{u_cb}} {}
+
+    bool operator()(cpr_pf_arg_t dltotal, cpr_pf_arg_t dlnow, cpr_pf_arg_t ultotal, cpr_pf_arg_t ulnow) const;
+
+    void SetProgressCallback(ProgressCallback& u_cb);
+
+  private:
+    std::shared_ptr<std::atomic_bool> cancellation_state;
+    std::optional<std::reference_wrapper<ProgressCallback>> user_cb;
+};
+
+
 } // namespace cpr

 #endif
--- a/vendor/CPR/include/cpr/cert_info.h
+++ b/vendor/CPR/include/cpr/cert_info.h
@@ -0,0 +1,37 @@
+#ifndef CPR_CERT_INFO_H
+#define CPR_CERT_INFO_H
+
+#include <initializer_list>
+#include <string>
+#include <vector>
+
+namespace cpr {
+
+class CertInfo {
+  private:
+    std::vector<std::string> cert_info_;
+
+  public:
+    CertInfo() = default;
+    CertInfo(const CertInfo& other) = default;
+    CertInfo(CertInfo&& old) = default;
+    CertInfo(const std::initializer_list<std::string>& entry) : cert_info_{entry} {}
+    ~CertInfo() noexcept = default;
+
+    using iterator = std::vector<std::string>::iterator;
+    using const_iterator = std::vector<std::string>::const_iterator;
+
+    std::string& operator[](const size_t& pos);
+    iterator begin();
+    iterator end();
+    const_iterator begin() const;
+    const_iterator end() const;
+    const_iterator cbegin() const;
+    const_iterator cend() const;
+    void emplace_back(const std::string& str);
+    void push_back(const std::string& str);
+    void pop_back();
+};
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/cookies.h
+++ b/vendor/CPR/include/cpr/cookies.h
@@ -2,12 +2,49 @@
 #define CPR_COOKIES_H

 #include "cpr/curlholder.h"
+#include <chrono>
 #include <initializer_list>
-#include <map>
 #include <sstream>
 #include <string>
+#include <vector>

 namespace cpr {
+/**
+ * EXPIRES_STRING_SIZE is an explicitly static and const variable that could be only accessed within the same namespace and is immutable.
+ * To be used for "std::array", the expression must have a constant value, so EXPIRES_STRING_SIZE must be a const value.
+ **/
+static const std::size_t EXPIRES_STRING_SIZE = 100;
+
+class Cookie {
+  public:
+    Cookie() = default;
+    /**
+     * Some notes for the default value used by expires:
+     * std::chrono::system_clock::time_point::min() won't work on Windows due to the min, max clash there.
+     * So we fall back to std::chrono::system_clock::from_time_t(0) for the minimum value here.
+     **/
+    Cookie(const std::string& name, const std::string& value, const std::string& domain = "", bool p_isIncludingSubdomains = false, const std::string& path = "/", bool p_isHttpsOnly = false, std::chrono::system_clock::time_point expires = std::chrono::system_clock::from_time_t(0)) : name_{name}, value_{value}, domain_{domain}, includeSubdomains_{p_isIncludingSubdomains}, path_{path}, httpsOnly_{p_isHttpsOnly}, expires_{expires} {}
+    const std::string GetDomain() const;
+    bool IsIncludingSubdomains() const;
+    const std::string GetPath() const;
+    bool IsHttpsOnly() const;
+    const std::chrono::system_clock::time_point GetExpires() const;
+    const std::string GetExpiresString() const;
+    const std::string GetName() const;
+    const std::string GetValue() const;
+
+  private:
+    std::string name_;
+    std::string value_;
+    std::string domain_;
+    bool includeSubdomains_{};
+    std::string path_;
+    bool httpsOnly_{};
+    /**
+     * TODO: Update the implementation using `std::chrono::utc_clock` of C++20
+     **/
+    std::chrono::system_clock::time_point expires_{};
+};

 class Cookies {
  public:
@@ -25,19 +62,16 @@ class Cookies {
    bool encode{true};

    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Cookies(bool p_encode = true) : encode(p_encode) {}
-    Cookies(const std::initializer_list<std::pair<const std::string, std::string>>& pairs,
-            bool p_encode = true)
-            : encode(p_encode), map_{pairs} {}
+    Cookies(bool p_encode = true) : encode{p_encode} {}
+    Cookies(const std::initializer_list<cpr::Cookie>& cookies, bool p_encode = true) : encode{p_encode}, cookies_{cookies} {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Cookies(const std::map<std::string, std::string>& map, bool p_encode = true)
-            : encode(p_encode), map_{map} {}
+    Cookies(const cpr::Cookie& cookie, bool p_encode = true) : encode{p_encode}, cookies_{cookie} {}

-    std::string& operator[](const std::string& key);
-    std::string GetEncoded(const CurlHolder& holder) const;
+    cpr::Cookie& operator[](size_t pos);
+    const std::string GetEncoded(const CurlHolder& holder) const;

-    using iterator = std::map<std::string, std::string>::iterator;
-    using const_iterator = std::map<std::string, std::string>::const_iterator;
+    using iterator = std::vector<cpr::Cookie>::iterator;
+    using const_iterator = std::vector<cpr::Cookie>::const_iterator;

    iterator begin();
    iterator end();
@@ -45,9 +79,12 @@ class Cookies {
    const_iterator end() const;
    const_iterator cbegin() const;
    const_iterator cend() const;
+    void emplace_back(const Cookie& str);
+    void push_back(const Cookie& str);
+    void pop_back();

  protected:
-    std::map<std::string, std::string> map_;
+    std::vector<cpr::Cookie> cookies_;
 };

 } // namespace cpr
--- a/vendor/CPR/include/cpr/cpr.h
+++ b/vendor/CPR/include/cpr/cpr.h
@@ -3,12 +3,43 @@

 #include "cpr/api.h"
 #include "cpr/auth.h"
+#include "cpr/bearer.h"
+#include "cpr/callback.h"
+#include "cpr/cert_info.h"
+#include "cpr/connect_timeout.h"
+#include "cpr/cookies.h"
 #include "cpr/cprtypes.h"
+#include "cpr/cprver.h"
+#include "cpr/curl_container.h"
+#include "cpr/curlholder.h"
+#include "cpr/error.h"
+#include "cpr/http_version.h"
+#include "cpr/interceptor.h"
 #include "cpr/interface.h"
+#include "cpr/limit_rate.h"
+#include "cpr/local_port.h"
+#include "cpr/local_port_range.h"
+#include "cpr/low_speed.h"
+#include "cpr/multipart.h"
+#include "cpr/multiperform.h"
+#include "cpr/parameters.h"
+#include "cpr/payload.h"
+#include "cpr/proxies.h"
+#include "cpr/proxyauth.h"
+#include "cpr/range.h"
 #include "cpr/redirect.h"
+#include "cpr/reserve_size.h"
+#include "cpr/resolve.h"
 #include "cpr/response.h"
 #include "cpr/session.h"
+#include "cpr/ssl_ctx.h"
+#include "cpr/ssl_options.h"
 #include "cpr/status_codes.h"
+#include "cpr/timeout.h"
+#include "cpr/unix_socket.h"
+#include "cpr/user_agent.h"
+#include "cpr/util.h"
+#include "cpr/verbose.h"

 #define CPR_LIBCURL_VERSION_NUM LIBCURL_VERSION_NUM

--- a/vendor/CPR/include/cpr/cprtypes.h
+++ b/vendor/CPR/include/cpr/cprtypes.h
@@ -2,11 +2,13 @@
 #define CPR_CPR_TYPES_H

 #include <curl/curl.h>
+#include <curl/system.h>
 #include <initializer_list>
 #include <map>
 #include <memory>
 #include <numeric>
 #include <string>
+#include <string_view>

 namespace cpr {

@@ -15,12 +17,21 @@ namespace cpr {
 **/
 using cpr_off_t = curl_off_t;

+/**
+ * The argument type for progress functions, dependent on libcurl version
+ **/
+#if LIBCURL_VERSION_NUM < 0x072000
+using cpr_pf_arg_t = double;
+#else
+using cpr_pf_arg_t = cpr_off_t;
+#endif
+
 template <class T>
 class StringHolder {
  public:
    StringHolder() = default;
-    explicit StringHolder(const std::string& str) : str_(str) {}
-    explicit StringHolder(std::string&& str) : str_(std::move(str)) {}
+    explicit StringHolder(std::string str) : str_(std::move(str)) {}
+    explicit StringHolder(std::string_view str) : str_(str) {}
    explicit StringHolder(const char* str) : str_(str) {}
    StringHolder(const char* str, size_t len) : str_(str, len) {}
    StringHolder(const std::initializer_list<std::string> args) {
@@ -107,9 +118,9 @@ class Url : public StringHolder<Url> {
  public:
    Url() = default;
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Url(const std::string& url) : StringHolder<Url>(url) {}
+    Url(std::string url) : StringHolder<Url>(std::move(url)) {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Url(std::string&& url) : StringHolder<Url>(std::move(url)) {}
+    Url(std::string_view url) : StringHolder<Url>(url) {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    Url(const char* url) : StringHolder<Url>(url) {}
    Url(const char* str, size_t len) : StringHolder<Url>(std::string(str, len)) {}
--- a/vendor/CPR/include/cpr/cprver.h
+++ b/vendor/CPR/include/cpr/cprver.h
@@ -0,0 +1,30 @@
+#ifndef CPR_CPRVER_H
+#define CPR_CPRVER_H
+
+/**
+ * CPR version as a string.
+ **/
+#define CPR_VERSION "1.10.4"
+
+/**
+ * CPR version split up into parts.
+ **/
+#define CPR_VERSION_MAJOR 1
+#define CPR_VERSION_MINOR 10
+#define CPR_VERSION_PATCH 4
+
+/**
+ * CPR version as a single hex digit.
+ * it can be split up into three parts:
+ * 0xAABBCC
+ * AA: The current CPR major version number in a hex format.
+ * BB: The current CPR minor version number in a hex format.
+ * CC: The current CPR patch version number in a hex format.
+ *
+ * Examples:
+ * '0x010702' -> 01.07.02 -> CPR_VERSION: 1.7.2
+ * '0xA13722' -> A1.37.22 -> CPR_VERSION: 161.55.34
+ **/
+#define CPR_VERSION_NUM 0x011004
+
+#endif
--- a/vendor/CPR/include/cpr/curl_container.h
+++ b/vendor/CPR/include/cpr/curl_container.h
@@ -12,18 +12,14 @@
 namespace cpr {

 struct Parameter {
-    Parameter(const std::string& p_key, const std::string& p_value) : key{p_key}, value{p_value} {}
-    Parameter(std::string&& p_key, std::string&& p_value)
-            : key{std::move(p_key)}, value{std::move(p_value)} {}
+    Parameter(std::string p_key, std::string p_value) : key{std::move(p_key)}, value{std::move(p_value)} {}

    std::string key;
    std::string value;
 };

 struct Pair {
-    Pair(const std::string& p_key, const std::string& p_value) : key(p_key), value(p_value) {}
-    Pair(std::string&& p_key, std::string&& p_value)
-            : key(std::move(p_key)), value(std::move(p_value)) {}
+    Pair(std::string p_key, std::string p_value) : key(std::move(p_key)), value(std::move(p_value)) {}

    std::string key;
    std::string value;
--- a/vendor/CPR/include/cpr/curlholder.h
+++ b/vendor/CPR/include/cpr/curlholder.h
@@ -17,14 +17,18 @@ struct CurlHolder {
     * https://curl.haxx.se/libcurl/c/curl_easy_init.html
     * https://curl.haxx.se/libcurl/c/threadsafe.html
     **/
-    // It does not make sense to make a std::mutex const.
-    // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)    
-    static std::mutex curl_easy_init_mutex_;
+
+    // Avoids initalization order problems in a static build
+    static std::mutex& curl_easy_init_mutex_() {
+        static std::mutex curl_easy_init_mutex_;
+        return curl_easy_init_mutex_;
+    }

  public:
    CURL* handle{nullptr};
    struct curl_slist* chunk{nullptr};
-    struct curl_httppost* formpost{nullptr};
+    struct curl_slist* resolveCurlList{nullptr};
+    curl_mime* multipart{nullptr};
    std::array<char, CURL_ERROR_SIZE> error{};

    CurlHolder();
--- a/vendor/CPR/include/cpr/curlmultiholder.h
+++ b/vendor/CPR/include/cpr/curlmultiholder.h
@@ -0,0 +1,18 @@
+#ifndef CPR_CURLMULTIHOLDER_H
+#define CPR_CURLMULTIHOLDER_H
+
+#include <curl/curl.h>
+
+namespace cpr {
+
+class CurlMultiHolder {
+  public:
+    CurlMultiHolder();
+    ~CurlMultiHolder();
+
+    CURLM* handle{nullptr};
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/digest.h
+++ b/vendor/CPR/include/cpr/digest.h
@@ -1,15 +0,0 @@
-#ifndef CPR_DIGEST_H
-#define CPR_DIGEST_H
-
-#include "cpr/auth.h"
-
-namespace cpr {
-class Digest : public Authentication {
-  public:
-    Digest(const std::string& username, const std::string& password)
-            : Authentication{username, password} {}
-};
-
-} // namespace cpr
-
-#endif
--- a/vendor/CPR/include/cpr/error.h
+++ b/vendor/CPR/include/cpr/error.h
@@ -27,6 +27,7 @@ enum class ErrorCode {
    GENERIC_SSL_ERROR,
    UNSUPPORTED_PROTOCOL,
    REQUEST_CANCELLED,
+    TOO_MANY_REDIRECTS,
    UNKNOWN_ERROR = 1000,
 };

@@ -37,9 +38,7 @@ class Error {

    Error() = default;

-    Error(const std::int32_t& curl_code, std::string&& p_error_message)
-            : code{getErrorCodeForCurlError(curl_code)},
-              message(std::move(p_error_message)) {}
+    Error(const std::int32_t& curl_code, std::string&& p_error_message) : code{getErrorCodeForCurlError(curl_code)}, message(std::move(p_error_message)) {}

    explicit operator bool() const {
        return code != ErrorCode::OK;
--- a/vendor/CPR/include/cpr/file.h
+++ b/vendor/CPR/include/cpr/file.h
@@ -0,0 +1,59 @@
+#ifndef CPR_FILE_H
+#define CPR_FILE_H
+
+#include <initializer_list>
+#include <string>
+#include <vector>
+
+#include <cpr/filesystem.h>
+
+namespace cpr {
+
+struct File {
+    explicit File(std::string p_filepath, const std::string& p_overriden_filename = {}) : filepath(std::move(p_filepath)), overriden_filename(p_overriden_filename) {}
+
+    std::string filepath;
+    std::string overriden_filename;
+
+    [[nodiscard]] bool hasOverridenFilename() const noexcept {
+        return !overriden_filename.empty();
+    }
+};
+
+class Files {
+  public:
+    Files() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    Files(const File& p_file) : files{p_file} {}
+
+    Files(const Files& other) = default;
+    Files(Files&& old) noexcept = default;
+
+    Files(const std::initializer_list<File>& p_files) : files{p_files} {}
+    Files(const std::initializer_list<std::string>& p_filepaths);
+
+    ~Files() noexcept = default;
+
+    Files& operator=(const Files& other);
+    Files& operator=(Files&& old) noexcept;
+
+    using iterator = std::vector<File>::iterator;
+    using const_iterator = std::vector<File>::const_iterator;
+
+    iterator begin();
+    iterator end();
+    [[nodiscard]] const_iterator begin() const;
+    [[nodiscard]] const_iterator end() const;
+    [[nodiscard]] const_iterator cbegin() const;
+    [[nodiscard]] const_iterator cend() const;
+    void emplace_back(const File& file);
+    void push_back(const File& file);
+    void pop_back();
+
+  private:
+    std::vector<File> files;
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/filesystem.h
+++ b/vendor/CPR/include/cpr/filesystem.h
@@ -0,0 +1,26 @@
+#ifndef CPR_FILESYSTEM_H
+#define CPR_FILESYSTEM_H
+
+// Include filesystem into the namespace "fs" from either "filesystem" or "experimental/filesystem" or "boost/filesystem"
+#ifdef CPR_USE_BOOST_FILESYSTEM
+#define BOOST_FILESYSTEM_VERSION 4 // Use the latest, with the closest behavior to std::filesystem.
+#include <boost/filesystem.hpp>
+namespace cpr {
+namespace fs = boost::filesystem;
+}
+// cppcheck-suppress preprocessorErrorDirective
+#elif __has_include(<filesystem>)
+#include <filesystem>
+namespace cpr {
+namespace fs = std::filesystem;
+}
+#elif __has_include("experimental/filesystem")
+#include <experimental/filesystem>
+namespace cpr {
+namespace fs = std::experimental::filesystem;
+}
+#else
+#error "Failed to include <filesystem> header!"
+#endif
+
+#endif
--- a/vendor/CPR/include/cpr/http_version.h
+++ b/vendor/CPR/include/cpr/http_version.h
@@ -0,0 +1,67 @@
+#ifndef CPR_HTTP_VERSION_H
+#define CPR_HTTP_VERSION_H
+
+#include <curl/curlver.h>
+
+namespace cpr {
+enum class HttpVersionCode {
+    /**
+     * Let libcurl decide which version is the best.
+     **/
+    VERSION_NONE,
+    /**
+     * Enforce HTTP 1.0 requests.
+     **/
+    VERSION_1_0,
+    /**
+     * Enforce HTTP 1.1 requests.
+     **/
+    VERSION_1_1,
+#if LIBCURL_VERSION_NUM >= 0x072100 // 7.33.0
+    /**
+     * Attempt HTTP 2.0 requests.
+     * Fallback to HTTP 1.1 if negotiation fails.
+     **/
+    VERSION_2_0,
+#endif
+#if LIBCURL_VERSION_NUM >= 0x072F00 // 7.47.0
+    /**
+     * Attempt HTTP 2.0 for HTTPS requests only.
+     * Fallback to HTTP 1.1 if negotiation fails.
+     * HTTP 1.1 will be used for HTTP connections.
+     **/
+    VERSION_2_0_TLS,
+#endif
+#if LIBCURL_VERSION_NUM >= 0x073100 // 7.49.0
+    /**
+     * Start HTTP 2.0 for HTTP requests.
+     * Requires prior knowledge that the server supports HTTP 2.0.
+     * For HTTPS requests we will negotiate the protocol version in the TLS handshake.
+     **/
+    VERSION_2_0_PRIOR_KNOWLEDGE,
+#endif
+#if LIBCURL_VERSION_NUM >= 0x074200 // 7.66.0
+    /**
+     * Attempt HTTP 3.0 requests.
+     * Requires prior knowledge that the server supports HTTP 3.0 since there is no gracefully downgrade.
+     * Fallback to HTTP 1.1 if negotiation fails.
+     **/
+    VERSION_3_0
+#endif
+};
+
+class HttpVersion {
+  public:
+    /**
+     * The HTTP version that should be used by libcurl when initiating a HTTP(S) connection.
+     * Default: HttpVersionCode::VERSION_NONE
+     **/
+    HttpVersionCode code = HttpVersionCode::VERSION_NONE;
+
+    HttpVersion() = default;
+    explicit HttpVersion(HttpVersionCode _code) : code(_code) {}
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/interceptor.h
+++ b/vendor/CPR/include/cpr/interceptor.h
@@ -0,0 +1,74 @@
+#ifndef CPR_INTERCEPTOR_H
+#define CPR_INTERCEPTOR_H
+
+#include "cpr/multiperform.h"
+#include "cpr/response.h"
+#include "cpr/session.h"
+#include <vector>
+
+namespace cpr {
+class Interceptor {
+  public:
+    enum class ProceedHttpMethod {
+        GET_REQUEST = 0,
+        POST_REQUEST,
+        PUT_REQUEST,
+        DELETE_REQUEST,
+        PATCH_REQUEST,
+        HEAD_REQUEST,
+        OPTIONS_REQUEST,
+        DOWNLOAD_CALLBACK_REQUEST,
+        DOWNLOAD_FILE_REQUEST,
+    };
+
+    Interceptor() = default;
+    Interceptor(const Interceptor& other) = default;
+    Interceptor(Interceptor&& old) = default;
+    virtual ~Interceptor() = default;
+
+    Interceptor& operator=(const Interceptor& other) = default;
+    Interceptor& operator=(Interceptor&& old) = default;
+
+    virtual Response intercept(Session& session) = 0;
+
+  protected:
+    static Response proceed(Session& session);
+    static Response proceed(Session& session, ProceedHttpMethod httpMethod);
+    static Response proceed(Session& session, ProceedHttpMethod httpMethod, std::ofstream& file);
+    static Response proceed(Session& session, ProceedHttpMethod httpMethod, const WriteCallback& write);
+};
+
+class InterceptorMulti {
+  public:
+    enum class ProceedHttpMethod {
+        GET_REQUEST = 0,
+        POST_REQUEST,
+        PUT_REQUEST,
+        DELETE_REQUEST,
+        PATCH_REQUEST,
+        HEAD_REQUEST,
+        OPTIONS_REQUEST,
+        DOWNLOAD_CALLBACK_REQUEST,
+        DOWNLOAD_FILE_REQUEST,
+    };
+
+    InterceptorMulti() = default;
+    InterceptorMulti(const InterceptorMulti& other) = default;
+    InterceptorMulti(InterceptorMulti&& old) = default;
+    virtual ~InterceptorMulti() = default;
+
+    InterceptorMulti& operator=(const InterceptorMulti& other) = default;
+    InterceptorMulti& operator=(InterceptorMulti&& old) = default;
+
+    virtual std::vector<Response> intercept(MultiPerform& multi) = 0;
+
+  protected:
+    static std::vector<Response> proceed(MultiPerform& multi);
+
+    static void PrepareDownloadSession(MultiPerform& multi, size_t sessions_index, const WriteCallback& write);
+};
+
+} // namespace cpr
+
+
+#endif
--- a/vendor/CPR/include/cpr/interface.h
+++ b/vendor/CPR/include/cpr/interface.h
@@ -10,11 +10,11 @@ namespace cpr {

 class Interface : public StringHolder<Interface> {
  public:
-    Interface() : StringHolder<Interface>() {}
+    Interface() = default;
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Interface(const std::string& iface) : StringHolder<Interface>(iface) {}
+    Interface(std::string iface) : StringHolder<Interface>(std::move(iface)) {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Interface(std::string&& iface) : StringHolder<Interface>(std::move(iface)) {}
+    Interface(std::string_view iface) : StringHolder<Interface>(iface) {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    Interface(const char* iface) : StringHolder<Interface>(iface) {}
    Interface(const char* str, size_t len) : StringHolder<Interface>(str, len) {}
@@ -29,4 +29,4 @@ class Interface : public StringHolder<Interface> {

 } // namespace cpr

-#endif
+#endif
--- a/vendor/CPR/include/cpr/limit_rate.h
+++ b/vendor/CPR/include/cpr/limit_rate.h
@@ -7,8 +7,7 @@ namespace cpr {

 class LimitRate {
  public:
-    LimitRate(const std::int64_t p_downrate, const std::int64_t p_uprate)
-            : downrate(p_downrate), uprate(p_uprate) {}
+    LimitRate(const std::int64_t p_downrate, const std::int64_t p_uprate) : downrate(p_downrate), uprate(p_uprate) {}

    std::int64_t downrate = 0;
    std::int64_t uprate = 0;
@@ -16,4 +15,4 @@ class LimitRate {

 } // namespace cpr

-#endif
+#endif
--- a/vendor/CPR/include/cpr/local_port.h
+++ b/vendor/CPR/include/cpr/local_port.h
@@ -0,0 +1,23 @@
+#ifndef CPR_LOCAL_PORT_H
+#define CPR_LOCAL_PORT_H
+
+#include <cstdint>
+
+namespace cpr {
+
+class LocalPort {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    LocalPort(const std::uint16_t p_localport) : localport_(p_localport) {}
+
+    operator std::uint16_t() const {
+        return localport_;
+    }
+
+  private:
+    std::uint16_t localport_ = 0;
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/local_port_range.h
+++ b/vendor/CPR/include/cpr/local_port_range.h
@@ -0,0 +1,23 @@
+#ifndef CPR_LOCAL_PORT_RANGE_H
+#define CPR_LOCAL_PORT_RANGE_H
+
+#include <cstdint>
+
+namespace cpr {
+
+class LocalPortRange {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    LocalPortRange(const std::uint16_t p_localportrange) : localportrange_(p_localportrange) {}
+
+    operator std::uint16_t() const {
+        return localportrange_;
+    }
+
+  private:
+    std::uint16_t localportrange_ = 0;
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/multipart.h
+++ b/vendor/CPR/include/cpr/multipart.h
@@ -7,69 +7,35 @@
 #include <type_traits>
 #include <vector>

+#include "buffer.h"
+#include "file.h"
+
 namespace cpr {

-struct File {
-    explicit File(std::string&& p_filepath) : filepath(std::move(p_filepath)) {}
-    explicit File(const std::string& p_filepath) : filepath(p_filepath) {}
-    const std::string filepath;
-};
-
-struct Buffer {
-    using data_t = const unsigned char*;
-
-    template <typename Iterator>
-    Buffer(Iterator begin, Iterator end, std::string&& p_filename)
-            // Ignored here since libcurl reqires a long.
-            // There is also no way around the reinterpret_cast.
-            // NOLINTNEXTLINE(google-runtime-int, cppcoreguidelines-pro-type-reinterpret-cast)
-            : data{reinterpret_cast<data_t>(&(*begin))}, datalen{static_cast<long>(
-                                                            std::distance(begin, end))},
-              filename(std::move(p_filename)) {
-        is_random_access_iterator(begin, end);
-        static_assert(sizeof(*begin) == 1, "only byte buffers can be used");
-    }
-
-    template <typename Iterator>
-    typename std::enable_if<std::is_same<typename std::iterator_traits<Iterator>::iterator_category,
-                                         std::random_access_iterator_tag>::value>::type
-    is_random_access_iterator(Iterator /* begin */, Iterator /* end */) {}
-
-    data_t data;
-    // Ignored here since libcurl reqires a long:
-    // NOLINTNEXTLINE(google-runtime-int)
-    long datalen;
-    const std::string filename;
-};
-
 struct Part {
-    Part(const std::string& p_name, const std::string& p_value, const std::string& p_content_type = {})
-            : name{p_name}, value{p_value},
-              content_type{p_content_type}, is_file{false}, is_buffer{false} {}
-    Part(const std::string& p_name, const std::int32_t& p_value, const std::string& p_content_type = {})
-            : name{p_name}, value{std::to_string(p_value)},
-              content_type{p_content_type}, is_file{false}, is_buffer{false} {}
-    Part(const std::string& p_name, const File& file, const std::string& p_content_type = {})
-            : name{p_name}, value{file.filepath},
-              content_type{p_content_type}, is_file{true}, is_buffer{false} {}
-    Part(const std::string& p_name, const Buffer& buffer, const std::string& p_content_type = {})
-            : name{p_name}, value{buffer.filename}, content_type{p_content_type}, data{buffer.data},
-              datalen{buffer.datalen}, is_file{false}, is_buffer{true} {}
+    Part(const std::string& p_name, const std::string& p_value, const std::string& p_content_type = {}) : name{p_name}, value{p_value}, content_type{p_content_type}, is_file{false}, is_buffer{false} {}
+    Part(const std::string& p_name, const std::int32_t& p_value, const std::string& p_content_type = {}) : name{p_name}, value{std::to_string(p_value)}, content_type{p_content_type}, is_file{false}, is_buffer{false} {}
+    Part(const std::string& p_name, const Files& p_files, const std::string& p_content_type = {}) : name{p_name}, content_type{p_content_type}, is_file{true}, is_buffer{false}, files{p_files} {}
+    Part(const std::string& p_name, Files&& p_files, const std::string& p_content_type = {}) : name{p_name}, content_type{p_content_type}, is_file{true}, is_buffer{false}, files{p_files} {}
+    Part(const std::string& p_name, const Buffer& buffer, const std::string& p_content_type = {}) : name{p_name}, value{buffer.filename.string()}, content_type{p_content_type}, data{buffer.data}, datalen{buffer.datalen}, is_file{false}, is_buffer{true} {}

    std::string name;
+    // We don't use fs::path here, as this leads to problems using windows
    std::string value;
    std::string content_type;
    Buffer::data_t data{nullptr};
-    // Ignored here since libcurl reqires a long:
-    // NOLINTNEXTLINE(google-runtime-int)
-    long datalen{0};
+    size_t datalen{0};
    bool is_file;
    bool is_buffer;
+
+    Files files;
 };

 class Multipart {
  public:
    Multipart(const std::initializer_list<Part>& parts);
+    Multipart(const std::vector<Part>& parts);
+    Multipart(const std::vector<Part>&& parts);

    std::vector<Part> parts;
 };
--- a/vendor/CPR/include/cpr/multiperform.h
+++ b/vendor/CPR/include/cpr/multiperform.h
@@ -0,0 +1,137 @@
+#ifndef CPR_MULTIPERFORM_H
+#define CPR_MULTIPERFORM_H
+
+#include "cpr/curlmultiholder.h"
+#include "cpr/response.h"
+#include "cpr/session.h"
+#include <functional>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace cpr {
+
+class InterceptorMulti;
+
+class MultiPerform {
+  public:
+    enum class HttpMethod {
+        UNDEFINED = 0,
+        GET_REQUEST,
+        POST_REQUEST,
+        PUT_REQUEST,
+        DELETE_REQUEST,
+        PATCH_REQUEST,
+        HEAD_REQUEST,
+        OPTIONS_REQUEST,
+        DOWNLOAD_REQUEST,
+    };
+
+    MultiPerform();
+    MultiPerform(const MultiPerform& other) = delete;
+    MultiPerform(MultiPerform&& old) = default;
+    ~MultiPerform();
+
+    MultiPerform& operator=(const MultiPerform& other) = delete;
+    MultiPerform& operator=(MultiPerform&& old) noexcept = default;
+
+    std::vector<Response> Get();
+    std::vector<Response> Delete();
+    template <typename... DownloadArgTypes>
+    std::vector<Response> Download(DownloadArgTypes... args);
+    std::vector<Response> Put();
+    std::vector<Response> Head();
+    std::vector<Response> Options();
+    std::vector<Response> Patch();
+    std::vector<Response> Post();
+
+    std::vector<Response> Perform();
+    template <typename... DownloadArgTypes>
+    std::vector<Response> PerformDownload(DownloadArgTypes... args);
+
+    void AddSession(std::shared_ptr<Session>& session, HttpMethod method = HttpMethod::UNDEFINED);
+    void RemoveSession(const std::shared_ptr<Session>& session);
+    std::vector<std::pair<std::shared_ptr<Session>, HttpMethod>>& GetSessions();
+    [[nodiscard]] const std::vector<std::pair<std::shared_ptr<Session>, HttpMethod>>& GetSessions() const;
+
+    void AddInterceptor(const std::shared_ptr<InterceptorMulti>& pinterceptor);
+
+  private:
+    // Interceptors should be able to call the private proceed() and PrepareDownloadSessions() functions
+    friend InterceptorMulti;
+
+    void SetHttpMethod(HttpMethod method);
+
+    void PrepareSessions();
+    template <typename CurrentDownloadArgType, typename... DownloadArgTypes>
+    void PrepareDownloadSessions(size_t sessions_index, CurrentDownloadArgType current_arg, DownloadArgTypes... args);
+    template <typename CurrentDownloadArgType>
+    void PrepareDownloadSessions(size_t sessions_index, CurrentDownloadArgType current_arg);
+    void PrepareDownloadSession(size_t sessions_index, std::ofstream& file);
+    void PrepareDownloadSession(size_t sessions_index, const WriteCallback& write);
+
+    void PrepareGet();
+    void PrepareDelete();
+    void PreparePut();
+    void PreparePatch();
+    void PrepareHead();
+    void PrepareOptions();
+    void PreparePost();
+    template <typename... DownloadArgTypes>
+    void PrepareDownload(DownloadArgTypes... args);
+
+    std::vector<Response> intercept();
+    std::vector<Response> proceed();
+    std::vector<Response> MakeRequest();
+    std::vector<Response> MakeDownloadRequest();
+
+    void DoMultiPerform();
+    std::vector<Response> ReadMultiInfo(std::function<Response(Session&, CURLcode)>&& complete_function);
+
+    std::vector<std::pair<std::shared_ptr<Session>, HttpMethod>> sessions_;
+    std::unique_ptr<CurlMultiHolder> multicurl_;
+    bool is_download_multi_perform{false};
+
+    std::queue<std::shared_ptr<InterceptorMulti>> interceptors_;
+};
+
+template <typename CurrentDownloadArgType>
+void MultiPerform::PrepareDownloadSessions(size_t sessions_index, CurrentDownloadArgType current_arg) {
+    PrepareDownloadSession(sessions_index, current_arg);
+}
+
+template <typename CurrentDownloadArgType, typename... DownloadArgTypes>
+void MultiPerform::PrepareDownloadSessions(size_t sessions_index, CurrentDownloadArgType current_arg, DownloadArgTypes... args) {
+    PrepareDownloadSession(sessions_index, current_arg);
+    PrepareDownloadSessions<DownloadArgTypes...>(sessions_index + 1, args...);
+}
+
+
+template <typename... DownloadArgTypes>
+void MultiPerform::PrepareDownload(DownloadArgTypes... args) {
+    SetHttpMethod(HttpMethod::DOWNLOAD_REQUEST);
+    PrepareDownloadSessions<DownloadArgTypes...>(0, args...);
+}
+
+template <typename... DownloadArgTypes>
+std::vector<Response> MultiPerform::Download(DownloadArgTypes... args) {
+    if (sizeof...(args) != sessions_.size()) {
+        throw std::invalid_argument("Number of download arguments has to match the number of sessions added to the multiperform!");
+    }
+    PrepareDownload(args...);
+    return MakeDownloadRequest();
+}
+
+template <typename... DownloadArgTypes>
+std::vector<Response> MultiPerform::PerformDownload(DownloadArgTypes... args) {
+    if (sizeof...(args) != sessions_.size()) {
+        throw std::invalid_argument("Number of download arguments has to match the number of sessions added to the multiperform!");
+    }
+    PrepareDownloadSessions<DownloadArgTypes...>(0, args...);
+    return MakeDownloadRequest();
+}
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/ntlm.h
+++ b/vendor/CPR/include/cpr/ntlm.h
@@ -1,15 +0,0 @@
-#ifndef CPR_NTLM_H
-#define CPR_NTLM_H
-
-#include "cpr/auth.h"
-
-namespace cpr {
-class NTLM : public Authentication {
-  public:
-    NTLM(const std::string& username, const std::string& password)
-            : Authentication{username, password} {}
-};
-
-} // namespace cpr
-
-#endif
--- a/vendor/CPR/include/cpr/parameters.h
+++ b/vendor/CPR/include/cpr/parameters.h
@@ -10,7 +10,7 @@ namespace cpr {
 class Parameters : public CurlContainer<Parameter> {
  public:
    Parameters() = default;
-    Parameters(const std::initializer_list<Parameter>& parameters);
+    Parameters(const std::initializer_list<Parameter>& parameters) : CurlContainer<Parameter>(parameters) {}
 };

 } // namespace cpr
--- a/vendor/CPR/include/cpr/payload.h
+++ b/vendor/CPR/include/cpr/payload.h
@@ -15,7 +15,7 @@ class Payload : public CurlContainer<Pair> {
            Add(*pair);
        }
    }
-    Payload(const std::initializer_list<Pair>& pairs);
+    Payload(const std::initializer_list<Pair>& pairs) : CurlContainer<Pair>(pairs) {}
 };

 } // namespace cpr
--- a/vendor/CPR/include/cpr/proxies.h
+++ b/vendor/CPR/include/cpr/proxies.h
@@ -10,6 +10,7 @@ class Proxies {
  public:
    Proxies() = default;
    Proxies(const std::initializer_list<std::pair<const std::string, std::string>>& hosts);
+    Proxies(const std::map<std::string, std::string>& hosts);

    bool has(const std::string& protocol) const;
    const std::string& operator[](const std::string& protocol);
--- a/vendor/CPR/include/cpr/proxyauth.h
+++ b/vendor/CPR/include/cpr/proxyauth.h
@@ -3,36 +3,44 @@

 #include <initializer_list>
 #include <map>
+#include <string>

 #include "cpr/auth.h"
 #include "cpr/util.h"

 namespace cpr {
+class ProxyAuthentication;
+
 class EncodedAuthentication {
+    friend ProxyAuthentication;
+
  public:
-    EncodedAuthentication() : auth_string_{""} {}
-    EncodedAuthentication(const std::string& username, const std::string& password) : auth_string_{cpr::util::urlEncode(username) + ":" + cpr::util::urlEncode(password)} {}
-    EncodedAuthentication(std::string&& username, std::string&& password) : auth_string_{cpr::util::urlEncode(std::move(username)) + ":" + cpr::util::urlEncode(std::move(password))} {}
+    EncodedAuthentication() = default;
+    EncodedAuthentication(const std::string& p_username, const std::string& p_password) : username(util::urlEncode(p_username)), password(util::urlEncode(p_password)) {}
    EncodedAuthentication(const EncodedAuthentication& other) = default;
    EncodedAuthentication(EncodedAuthentication&& old) noexcept = default;
-    virtual ~EncodedAuthentication() noexcept = default;
+    virtual ~EncodedAuthentication() noexcept;

    EncodedAuthentication& operator=(EncodedAuthentication&& old) noexcept = default;
    EncodedAuthentication& operator=(const EncodedAuthentication& other) = default;

-    const char* GetAuthString() const noexcept;
+    [[nodiscard]] const std::string& GetUsername() const;
+    [[nodiscard]] const std::string& GetPassword() const;

-  protected:
-    std::string auth_string_;
+  private:
+    std::string username;
+    std::string password;
 };

 class ProxyAuthentication {
  public:
    ProxyAuthentication() = default;
    ProxyAuthentication(const std::initializer_list<std::pair<const std::string, EncodedAuthentication>>& auths) : proxyAuth_{auths} {}
+    explicit ProxyAuthentication(const std::map<std::string, EncodedAuthentication>& auths) : proxyAuth_{auths} {}

-    bool has(const std::string& protocol) const;
-    const char* operator[](const std::string& protocol);
+    [[nodiscard]] bool has(const std::string& protocol) const;
+    const char* GetUsername(const std::string& protocol);
+    const char* GetPassword(const std::string& protocol);

  private:
    std::map<std::string, EncodedAuthentication> proxyAuth_;
--- a/vendor/CPR/include/cpr/range.h
+++ b/vendor/CPR/include/cpr/range.h
@@ -0,0 +1,44 @@
+#ifndef CPR_RANGE_H
+#define CPR_RANGE_H
+
+#include <cstdint>
+#include <optional>
+
+namespace cpr {
+
+class Range {
+  public:
+    Range(const std::optional<std::int64_t> p_resume_from = std::nullopt, const std::optional<std::int64_t> p_finish_at = std::nullopt) {
+        resume_from = p_resume_from.value_or(0);
+        finish_at = p_finish_at.value_or(-1);
+    }
+
+    std::int64_t resume_from;
+    std::int64_t finish_at;
+
+    const std::string str() const {
+        std::string from_str = (resume_from < 0U) ? "" : std::to_string(resume_from);
+        std::string to_str = (finish_at < 0U) ? "" : std::to_string(finish_at);
+        return from_str + "-" + to_str;
+    }
+};
+
+class MultiRange {
+  public:
+    MultiRange(std::initializer_list<Range> rs) : ranges{rs} {}
+
+    const std::string str() const {
+        std::string multi_range_string{};
+        for (Range range : ranges) {
+            multi_range_string += ((multi_range_string.empty()) ? "" : ", ") + range.str();
+        }
+        return multi_range_string;
+    }
+
+  private:
+    std::vector<Range> ranges;
+}; // namespace cpr
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/redirect.h
+++ b/vendor/CPR/include/cpr/redirect.h
@@ -50,7 +50,7 @@ class Redirect {
     * Default: 50
     * https://curl.se/libcurl/c/CURLOPT_MAXREDIRS.html
     **/
-    // NOLINTNEXTLINE (cppcoreguidelines-avoid-magic-numbers, google-runtime-int)
+    // NOLINTNEXTLINE (google-runtime-int)
    long maximum{50L};
    /**
     * Follow 3xx redirects.
@@ -58,6 +58,12 @@ class Redirect {
     * https://curl.se/libcurl/c/CURLOPT_FOLLOWLOCATION.html
     **/
    bool follow{true};
+    /**
+     * Continue to send authentication (user+password) credentials when following locations, even when hostname changed.
+     * Default: false
+     * https://curl.se/libcurl/c/CURLOPT_UNRESTRICTED_AUTH.html
+     **/
+    bool cont_send_cred{false};
    /**
     * Flags to control how to act after a redirect for a post request.
     * Default: POST_ALL
@@ -66,11 +72,12 @@ class Redirect {

    Redirect() = default;
    // NOLINTNEXTLINE (google-runtime-int)
-    Redirect(long p_maximum, bool p_follow, PostRedirectFlags p_post_flags) : maximum(p_maximum), follow(p_follow), post_flags(p_post_flags){};
+    Redirect(long p_maximum, bool p_follow, bool p_cont_send_cred, PostRedirectFlags p_post_flags) : maximum(p_maximum), follow(p_follow), cont_send_cred(p_cont_send_cred), post_flags(p_post_flags){}
    // NOLINTNEXTLINE (google-runtime-int)
-    explicit Redirect(long p_maximum) : maximum(p_maximum){};
-    explicit Redirect(bool p_follow) : follow(p_follow){};
-    explicit Redirect(PostRedirectFlags p_post_flags) : post_flags(p_post_flags){};
+    explicit Redirect(long p_maximum) : maximum(p_maximum){}
+    explicit Redirect(bool p_follow) : follow(p_follow){}
+    Redirect(bool p_follow, bool p_cont_send_cred) : follow(p_follow), cont_send_cred(p_cont_send_cred){}
+    explicit Redirect(PostRedirectFlags p_post_flags) : post_flags(p_post_flags){}
 };
 } // namespace cpr

--- a/vendor/CPR/include/cpr/reserve_size.h
+++ b/vendor/CPR/include/cpr/reserve_size.h
@@ -0,0 +1,17 @@
+#ifndef CPR_RESERVE_SIZE_H
+#define CPR_RESERVE_SIZE_H
+
+#include <cstdint>
+
+namespace cpr {
+
+class ReserveSize {
+  public:
+    ReserveSize(const size_t _size) : size(_size) {}
+
+    size_t size = 0;
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/resolve.h
+++ b/vendor/CPR/include/cpr/resolve.h
@@ -0,0 +1,23 @@
+#ifndef CPR_RESOLVE_H
+#define CPR_RESOLVE_H
+
+#include <string>
+#include <set>
+
+namespace cpr {
+    class Resolve {
+      public:
+        std::string host;
+        std::string addr;
+        std::set<uint16_t> ports;
+
+        Resolve(const std::string& host_param, const std::string& addr_param, const std::set<uint16_t>& ports_param = std::set<uint16_t>{80U, 443U}): host(host_param), addr(addr_param), ports(ports_param) {
+            if (this->ports.empty()) {
+                this->ports.insert(80U);
+                this->ports.insert(443U);
+            }
+        }
+    };
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/response.h
+++ b/vendor/CPR/include/cpr/response.h
@@ -3,12 +3,12 @@

 #include <cassert>
 #include <cstdint>
-#include <curl/curl.h>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>

+#include "cpr/cert_info.h"
 #include "cpr/cookies.h"
 #include "cpr/cprtypes.h"
 #include "cpr/error.h"
@@ -17,8 +17,11 @@

 namespace cpr {

+class MultiPerform;
+
 class Response {
  protected:
+    friend MultiPerform;
    std::shared_ptr<CurlHolder> curl_{nullptr};

  public:
@@ -41,9 +44,8 @@ class Response {
    long redirect_count{};

    Response() = default;
-    Response(std::shared_ptr<CurlHolder> curl, std::string&& p_text, std::string&& p_header_string,
-             Cookies&& p_cookies, Error&& p_error);
-    std::vector<std::string> GetCertInfo();
+    Response(std::shared_ptr<CurlHolder> curl, std::string&& p_text, std::string&& p_header_string, Cookies&& p_cookies, Error&& p_error);
+    std::vector<CertInfo> GetCertInfos();
    Response(const Response& other) = default;
    Response(Response&& old) noexcept = default;
    ~Response() noexcept = default;
--- a/vendor/CPR/include/cpr/session.h
+++ b/vendor/CPR/include/cpr/session.h
@@ -3,8 +3,13 @@

 #include <cstdint>
 #include <fstream>
+#include <functional>
+#include <future>
 #include <memory>
+#include <queue>

+#include "cpr/accept_encoding.h"
+#include "cpr/async_wrapper.h"
 #include "cpr/auth.h"
 #include "cpr/bearer.h"
 #include "cpr/body.h"
@@ -13,35 +18,45 @@
 #include "cpr/cookies.h"
 #include "cpr/cprtypes.h"
 #include "cpr/curlholder.h"
-#include "cpr/digest.h"
+#include "cpr/http_version.h"
 #include "cpr/interface.h"
 #include "cpr/limit_rate.h"
+#include "cpr/local_port.h"
+#include "cpr/local_port_range.h"
 #include "cpr/low_speed.h"
 #include "cpr/multipart.h"
-#include "cpr/ntlm.h"
 #include "cpr/parameters.h"
 #include "cpr/payload.h"
 #include "cpr/proxies.h"
 #include "cpr/proxyauth.h"
+#include "cpr/range.h"
 #include "cpr/redirect.h"
+#include "cpr/reserve_size.h"
+#include "cpr/resolve.h"
 #include "cpr/response.h"
 #include "cpr/ssl_options.h"
 #include "cpr/timeout.h"
 #include "cpr/unix_socket.h"
 #include "cpr/user_agent.h"
+#include "cpr/util.h"
 #include "cpr/verbose.h"

 namespace cpr {

-class Session {
+using AsyncResponse = AsyncWrapper<Response>;
+
+class Interceptor;
+class MultiPerform;
+
+class Session : public std::enable_shared_from_this<Session> {
  public:
    Session();
-    Session(Session&& old) noexcept;
    Session(const Session& other) = delete;
+    Session(Session&& old) = default;

-    ~Session();
+    ~Session() = default;

-    Session& operator=(Session&& old) noexcept;
+    Session& operator=(Session&& old) noexcept = default;
    Session& operator=(const Session& other) = delete;

    void SetUrl(const Url& url);
@@ -52,7 +67,11 @@ class Session {
    void SetTimeout(const Timeout& timeout);
    void SetConnectTimeout(const ConnectTimeout& timeout);
    void SetAuth(const Authentication& auth);
-    void SetDigest(const Digest& auth);
+// Only supported with libcurl >= 7.61.0.
+// As an alternative use SetHeader and add the token manually.
+#if LIBCURL_VERSION_NUM >= 0x073D00
+    void SetBearer(const Bearer& token);
+#endif
    void SetUserAgent(const UserAgent& ua);
    void SetPayload(Payload&& payload);
    void SetPayload(const Payload& payload);
@@ -62,7 +81,6 @@ class Session {
    void SetProxyAuth(const ProxyAuthentication& proxy_auth);
    void SetMultipart(Multipart&& multipart);
    void SetMultipart(const Multipart& multipart);
-    void SetNTLM(const NTLM& auth);
    void SetRedirect(const Redirect& redirect);
    void SetCookies(const Cookies& cookies);
    void SetBody(Body&& body);
@@ -78,6 +96,20 @@ class Session {
    void SetDebugCallback(const DebugCallback& debug);
    void SetVerbose(const Verbose& verbose);
    void SetInterface(const Interface& iface);
+    void SetLocalPort(const LocalPort& local_port);
+    void SetLocalPortRange(const LocalPortRange& local_port_range);
+    void SetHttpVersion(const HttpVersion& version);
+    void SetRange(const Range& range);
+    void SetResolve(const Resolve& resolve);
+    void SetResolves(const std::vector<Resolve>& resolves);
+    void SetMultiRange(const MultiRange& multi_range);
+    void SetReserveSize(const ReserveSize& reserve_size);
+    void SetAcceptEncoding(const AcceptEncoding& accept_encoding);
+    void SetAcceptEncoding(AcceptEncoding&& accept_encoding);
+    void SetLimitRate(const LimitRate& limit_rate);
+
+    // For cancellable requests
+    void SetCancellationParam(std::shared_ptr<std::atomic_bool> param);

    // Used in templated functions
    void SetOption(const Url& url);
@@ -92,7 +124,6 @@ class Session {
 #if LIBCURL_VERSION_NUM >= 0x073D00
    void SetOption(const Bearer& auth);
 #endif
-    void SetOption(const Digest& auth);
    void SetOption(const UserAgent& ua);
    void SetOption(Payload&& payload);
    void SetOption(const Payload& payload);
@@ -103,7 +134,6 @@ class Session {
    void SetOption(const ProxyAuthentication& proxy_auth);
    void SetOption(Multipart&& multipart);
    void SetOption(const Multipart& multipart);
-    void SetOption(const NTLM& auth);
    void SetOption(const Redirect& redirect);
    void SetOption(const Cookies& cookies);
    void SetOption(Body&& body);
@@ -119,8 +149,29 @@ class Session {
    void SetOption(const UnixSocket& unix_socket);
    void SetOption(const SslOptions& options);
    void SetOption(const Interface& iface);
+    void SetOption(const LocalPort& local_port);
+    void SetOption(const LocalPortRange& local_port_range);
+    void SetOption(const HttpVersion& version);
+    void SetOption(const Range& range);
+    void SetOption(const MultiRange& multi_range);
+    void SetOption(const ReserveSize& reserve_size);
+    void SetOption(const AcceptEncoding& accept_encoding);
+    void SetOption(AcceptEncoding&& accept_encoding);
+    void SetOption(const Resolve& resolve);
+    void SetOption(const std::vector<Resolve>& resolves);

    cpr_off_t GetDownloadFileLength();
+    /**
+     * Attempt to preallocate enough memory for specified number of characters in the response string.
+     * Pass 0 to disable this behavior and let the response string be allocated dynamically on demand.
+     *
+     * Example:
+     * cpr::Session session;
+     * session.SetUrl(cpr::Url{"http://xxx/file"});
+     * session.ResponseStringReserve(1024 * 512); // Reserve space for at least 1024 * 512 characters
+     * cpr::Response r = session.Get();
+     **/
+    void ResponseStringReserve(size_t size);
    Response Delete();
    Response Download(const WriteCallback& write);
    Response Download(std::ofstream& file);
@@ -131,7 +182,33 @@ class Session {
    Response Post();
    Response Put();

+    AsyncResponse GetAsync();
+    AsyncResponse DeleteAsync();
+    AsyncResponse DownloadAsync(const WriteCallback& write);
+    AsyncResponse DownloadAsync(std::ofstream& file);
+    AsyncResponse HeadAsync();
+    AsyncResponse OptionsAsync();
+    AsyncResponse PatchAsync();
+    AsyncResponse PostAsync();
+    AsyncResponse PutAsync();
+
+    template <typename Then>
+    auto GetCallback(Then then);
+    template <typename Then>
+    auto PostCallback(Then then);
+    template <typename Then>
+    auto PutCallback(Then then);
+    template <typename Then>
+    auto HeadCallback(Then then);
+    template <typename Then>
+    auto DeleteCallback(Then then);
+    template <typename Then>
+    auto OptionsCallback(Then then);
+    template <typename Then>
+    auto PatchCallback(Then then);
+
    std::shared_ptr<CurlHolder> GetCurlHolder();
+    std::string GetFullRequestUrl();

    void PrepareDelete();
    void PrepareGet();
@@ -140,13 +217,92 @@ class Session {
    void PreparePatch();
    void PreparePost();
    void PreparePut();
+    void PrepareDownload(const WriteCallback& write);
+    void PrepareDownload(std::ofstream& file);
    Response Complete(CURLcode curl_error);
+    Response CompleteDownload(CURLcode curl_error);

-  protected:
-    class Impl;
-    std::unique_ptr<Impl> pimpl_;
+    void AddInterceptor(const std::shared_ptr<Interceptor>& pinterceptor);
+
+  private:
+    // Interceptors should be able to call the private proceed() function
+    friend Interceptor;
+    friend MultiPerform;
+
+
+    bool hasBodyOrPayload_{false};
+    bool chunkedTransferEncoding_{false};
+    std::shared_ptr<CurlHolder> curl_;
+    Url url_;
+    Parameters parameters_;
+    Proxies proxies_;
+    ProxyAuthentication proxyAuth_;
+    Header header_;
+    AcceptEncoding acceptEncoding_;
+    /**
+     * Will be set by the read callback.
+     * Ensures that the "Transfer-Encoding" is set to "chunked", if not overriden in header_.
+     **/
+    ReadCallback readcb_;
+    HeaderCallback headercb_;
+    WriteCallback writecb_;
+    ProgressCallback progresscb_;
+    DebugCallback debugcb_;
+    CancellationCallback cancellationcb_;
+
+    size_t response_string_reserve_size_{0};
+    std::string response_string_;
+    std::string header_string_;
+    std::queue<std::shared_ptr<Interceptor>> interceptors_;
+    bool isUsedInMultiPerform{false};
+    bool isCancellable{false};
+
+    Response makeDownloadRequest();
+    Response makeRequest();
+    Response proceed();
+    Response intercept();
+    void prepareCommon();
+    void prepareCommonDownload();
+    void SetHeaderInternal();
+    std::shared_ptr<Session> GetSharedPtrFromThis();
+    CURLcode DoEasyPerform();
 };

+template <typename Then>
+auto Session::GetCallback(Then then) {
+    return async([shared_this = GetSharedPtrFromThis()](Then then_inner) { return then_inner(shared_this->Get()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::PostCallback(Then then) {
+    return async([shared_this = GetSharedPtrFromThis()](Then then_inner) { return then_inner(shared_this->Post()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::PutCallback(Then then) {
+    return async([shared_this = GetSharedPtrFromThis()](Then then_inner) { return then_inner(shared_this->Put()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::HeadCallback(Then then) {
+    return async([shared_this = GetSharedPtrFromThis()](Then then_inner) { return then_inner(shared_this->Head()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::DeleteCallback(Then then) {
+    return async([shared_this = GetSharedPtrFromThis()](Then then_inner) { return then_inner(shared_this->Delete()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::OptionsCallback(Then then) {
+    return async([shared_this = GetSharedPtrFromThis()](Then then_inner) { return then_inner(shared_this->Options()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::PatchCallback(Then then) {
+    return async([shared_this = GetSharedPtrFromThis()](Then then_inner) { return then_inner(shared_this->Patch()); }, std::move(then));
+}
+
 } // namespace cpr

 #endif
--- a/vendor/CPR/include/cpr/singleton.h
+++ b/vendor/CPR/include/cpr/singleton.h
@@ -0,0 +1,47 @@
+#ifndef CPR_SINGLETON_H
+#define CPR_SINGLETON_H
+
+#include <mutex>
+
+#ifndef CPR_DISABLE_COPY
+#define CPR_DISABLE_COPY(Class) \
+    Class(const Class&) = delete; \
+    Class& operator=(const Class&) = delete;
+#endif
+
+#ifndef CPR_SINGLETON_DECL
+#define CPR_SINGLETON_DECL(Class) \
+    public: \
+        static Class* GetInstance(); \
+        static void ExitInstance(); \
+    private: \
+        CPR_DISABLE_COPY(Class) \
+        static Class* s_pInstance; \
+        static std::mutex s_mutex;
+#endif
+
+#ifndef CPR_SINGLETON_IMPL
+#define CPR_SINGLETON_IMPL(Class) \
+    Class* Class::s_pInstance = nullptr; \
+    std::mutex Class::s_mutex; \
+    Class* Class::GetInstance() { \
+        if (s_pInstance == nullptr) { \
+            s_mutex.lock(); \
+            if (s_pInstance == nullptr) { \
+                s_pInstance = new Class; \
+            } \
+            s_mutex.unlock(); \
+        } \
+        return s_pInstance; \
+    } \
+    void Class::ExitInstance() { \
+        s_mutex.lock(); \
+        if (s_pInstance) {  \
+            delete s_pInstance; \
+            s_pInstance = nullptr; \
+        }   \
+        s_mutex.unlock(); \
+    }
+#endif
+
+#endif
--- a/vendor/CPR/include/cpr/ssl_ctx.h
+++ b/vendor/CPR/include/cpr/ssl_ctx.h
@@ -0,0 +1,26 @@
+#ifndef CPR_SSL_CTX_H
+#define CPR_SSL_CTX_H
+
+#include "cpr/ssl_options.h"
+#include <curl/curl.h>
+
+#if SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+
+namespace cpr {
+
+/**
+ * This callback function loads a CA certificate from raw_cert_buf and gets called by libcurl
+ * just before the initialization of an SSL connection.
+ * The raw_cert_buf argument is set with the CURLOPT_SSL_CTX_DATA option and has to be a nul
+ * terminated buffer.
+ *
+ * Sources: https://curl.se/libcurl/c/CURLOPT_SSL_CTX_FUNCTION.html
+ *         https://curl.se/libcurl/c/CURLOPT_SSL_CTX_DATA.html
+ */
+CURLcode sslctx_function_load_ca_cert_from_buffer(CURL* curl, void* sslctx, void* raw_cert_buf);
+
+} // Namespace cpr
+
+#endif
+
+#endif
--- a/vendor/CPR/include/cpr/ssl_options.h
+++ b/vendor/CPR/include/cpr/ssl_options.h
@@ -1,67 +1,70 @@
 #ifndef CPR_SSLOPTIONS_H
 #define CPR_SSLOPTIONS_H

+#include <memory>
 #include <string>
+#include <vector>

+#include <cpr/filesystem.h>
 #include <curl/curl.h>

+#include "cpr/util.h"
 #include <utility>

-#define __LIBCURL_VERSION_GTE(major, minor) \
-    ((LIBCURL_VERSION_MAJOR > (major)) ||   \
-     ((LIBCURL_VERSION_MAJOR == (major)) && (LIBCURL_VERSION_MINOR >= (minor))))
-#define __LIBCURL_VERSION_LT(major, minor) \
-    ((LIBCURL_VERSION_MAJOR < (major)) ||  \
-     ((LIBCURL_VERSION_MAJOR == (major)) && (LIBCURL_VERSION_MINOR < (minor))))
-
 #ifndef SUPPORT_ALPN
-#define SUPPORT_ALPN __LIBCURL_VERSION_GTE(7, 36)
+#define SUPPORT_ALPN LIBCURL_VERSION_NUM >= 0x072400 // 7.36.0
 #endif
 #ifndef SUPPORT_NPN
-#define SUPPORT_NPN __LIBCURL_VERSION_GTE(7, 36)
+#define SUPPORT_NPN LIBCURL_VERSION_NUM >= 0x072400 && LIBCURL_VERSION_NUM <= 0x078600 // 7.36.0 - 7.86.0
 #endif

 #ifndef SUPPORT_SSLv2
-#define SUPPORT_SSLv2 __LIBCURL_VERSION_LT(7, 19)
+#define SUPPORT_SSLv2 LIBCURL_VERSION_NUM <= 0x071300 // 7.19.0
 #endif
 #ifndef SUPPORT_SSLv3
-#define SUPPORT_SSLv3 __LIBCURL_VERSION_LT(7, 39)
+#define SUPPORT_SSLv3 LIBCURL_VERSION_NUM <= 0x072700 // 7.39.0
 #endif
 #ifndef SUPPORT_TLSv1_0
-#define SUPPORT_TLSv1_0 __LIBCURL_VERSION_GTE(7, 34)
+#define SUPPORT_TLSv1_0 LIBCURL_VERSION_NUM >= 0x072200 // 7.34.0
 #endif
 #ifndef SUPPORT_TLSv1_1
-#define SUPPORT_TLSv1_1 __LIBCURL_VERSION_GTE(7, 34)
+#define SUPPORT_TLSv1_1 LIBCURL_VERSION_NUM >= 0x072200 // 7.34.0
 #endif
 #ifndef SUPPORT_TLSv1_2
-#define SUPPORT_TLSv1_2 __LIBCURL_VERSION_GTE(7, 34)
+#define SUPPORT_TLSv1_2 LIBCURL_VERSION_NUM >= 0x072200 // 7.34.0
 #endif
 #ifndef SUPPORT_TLSv1_3
-#define SUPPORT_TLSv1_3 __LIBCURL_VERSION_GTE(7, 52)
+#define SUPPORT_TLSv1_3 LIBCURL_VERSION_NUM >= 0x073400 // 7.52.0
 #endif
 #ifndef SUPPORT_MAX_TLS_VERSION
-#define SUPPORT_MAX_TLS_VERSION __LIBCURL_VERSION_GTE(7, 54)
+#define SUPPORT_MAX_TLS_VERSION LIBCURL_VERSION_NUM >= 0x073600 // 7.54.0
 #endif
 #ifndef SUPPORT_MAX_TLSv1_1
-#define SUPPORT_MAX_TLSv1_1 __LIBCURL_VERSION_GTE(7, 54)
+#define SUPPORT_MAX_TLSv1_1 LIBCURL_VERSION_NUM >= 0x073600 // 7.54.0
 #endif
 #ifndef SUPPORT_MAX_TLSv1_2
-#define SUPPORT_MAX_TLSv1_2 __LIBCURL_VERSION_GTE(7, 54)
+#define SUPPORT_MAX_TLSv1_2 LIBCURL_VERSION_NUM >= 0x073600 // 7.54.0
 #endif
 #ifndef SUPPORT_MAX_TLSv1_3
-#define SUPPORT_MAX_TLSv1_3 __LIBCURL_VERSION_GTE(7, 54)
+#define SUPPORT_MAX_TLSv1_3 LIBCURL_VERSION_NUM >= 0x073600 // 7.54.0
 #endif
 #ifndef SUPPORT_TLSv13_CIPHERS
-#define SUPPORT_TLSv13_CIPHERS __LIBCURL_VERSION_GTE(7, 61)
+#define SUPPORT_TLSv13_CIPHERS LIBCURL_VERSION_NUM >= 0x073D00 // 7.61.0
 #endif
 #ifndef SUPPORT_SESSIONID_CACHE
-#define SUPPORT_SESSIONID_CACHE __LIBCURL_VERSION_GTE(7, 16)
+#define SUPPORT_SESSIONID_CACHE LIBCURL_VERSION_NUM >= 0x071000 // 7.16.0
 #endif
 #ifndef SUPPORT_SSL_FALSESTART
-#define SUPPORT_SSL_FALSESTART __LIBCURL_VERSION_GTE(7, 42)
+#define SUPPORT_SSL_FALSESTART LIBCURL_VERSION_NUM >= 0x072A00 // 7.42.0
 #endif
 #ifndef SUPPORT_SSL_NO_REVOKE
-#define SUPPORT_SSL_NO_REVOKE __LIBCURL_VERSION_GTE(7, 44)
+#define SUPPORT_SSL_NO_REVOKE LIBCURL_VERSION_NUM >= 0x072C00 // 7.44.0
+#endif
+#ifndef SUPPORT_CURLOPT_SSLKEY_BLOB
+#define SUPPORT_CURLOPT_SSLKEY_BLOB LIBCURL_VERSION_NUM >= 0x074700 // 7.71.0
+#endif
+#ifndef SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+#define SUPPORT_CURLOPT_SSL_CTX_FUNCTION LIBCURL_VERSION_NUM >= 0x070B00 // 7.11.0
 #endif

 namespace cpr {
@@ -85,9 +88,11 @@ namespace ssl {
 class CertFile {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    CertFile(std::string&& p_filename) : filename(std::move(p_filename)) {}
+    CertFile(fs::path&& p_filename) : filename(std::move(p_filename)) {}

-    const std::string filename;
+    virtual ~CertFile() = default;
+
+    const fs::path filename;

    virtual const char* GetCertType() const {
        return "PEM";
@@ -99,7 +104,9 @@ using PemCert = CertFile;
 class DerCert : public CertFile {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    DerCert(std::string&& p_filename) : CertFile(std::move(p_filename)) {}
+    DerCert(fs::path&& p_filename) : CertFile(std::move(p_filename)) {}
+
+    ~DerCert() override = default;

    const char* GetCertType() const override {
        return "DER";
@@ -110,13 +117,16 @@ class DerCert : public CertFile {
 class KeyFile {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    KeyFile(std::string&& p_filename) : filename(std::move(p_filename)) {}
+    KeyFile(fs::path&& p_filename) : filename(std::move(p_filename)) {}

    template <typename FileType, typename PassType>
-    KeyFile(FileType&& p_filename, PassType p_password)
-            : filename(std::forward<FileType>(p_filename)), password(std::move(p_password)) {}
+    KeyFile(FileType&& p_filename, PassType p_password) : filename(std::forward<FileType>(p_filename)), password(std::move(p_password)) {}

-    std::string filename;
+    virtual ~KeyFile() {
+        util::secureStringClear(password);
+    }
+
+    fs::path filename;
    std::string password;

    virtual const char* GetKeyType() const {
@@ -124,16 +134,39 @@ class KeyFile {
    }
 };

+#if SUPPORT_CURLOPT_SSLKEY_BLOB
+class KeyBlob {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    KeyBlob(std::string&& p_blob) : blob(std::move(p_blob)) {}
+
+    template <typename BlobType, typename PassType>
+    KeyBlob(BlobType&& p_blob, PassType p_password) : blob(std::forward<BlobType>(p_blob)), password(std::move(p_password)) {}
+
+    virtual ~KeyBlob() {
+        util::secureStringClear(password);
+    }
+
+    std::string blob;
+    std::string password;
+
+    virtual const char* GetKeyType() const {
+        return "PEM";
+    }
+};
+#endif
+
 using PemKey = KeyFile;

 class DerKey : public KeyFile {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    DerKey(std::string&& p_filename) : KeyFile(std::move(p_filename)) {}
+    DerKey(fs::path&& p_filename) : KeyFile(std::move(p_filename)) {}

    template <typename FileType, typename PassType>
-    DerKey(FileType&& p_filename, PassType p_password)
-            : KeyFile(std::forward<FileType>(p_filename), std::move(p_password)) {}
+    DerKey(FileType&& p_filename, PassType p_password) : KeyFile(std::forward<FileType>(p_filename), std::move(p_password)) {}
+
+    ~DerKey() override = default;

    const char* GetKeyType() const override {
        return "DER";
@@ -277,27 +310,37 @@ struct MaxTLSv1_3 {};
 class CaInfo {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    CaInfo(std::string&& p_filename) : filename(std::move(p_filename)) {}
+    CaInfo(fs::path&& p_filename) : filename(std::move(p_filename)) {}

-    std::string filename;
+    fs::path filename;
 };

 // specify directory holding CA certificates
 class CaPath {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    CaPath(std::string&& p_filename) : filename(std::move(p_filename)) {}
+    CaPath(fs::path&& p_filename) : filename(std::move(p_filename)) {}

-    std::string filename;
+    fs::path filename;
 };

+#if SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+class CaBuffer {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    CaBuffer(std::string&& p_buffer) : buffer(std::move(p_buffer)) {}
+
+    const std::string buffer;
+};
+#endif
+
 // specify a Certificate Revocation List file
 class Crl {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Crl(std::string&& p_filename) : filename(std::move(p_filename)) {}
+    Crl(fs::path&& p_filename) : filename(std::move(p_filename)) {}

-    std::string filename;
+    fs::path filename;
 };

 // specify ciphers to use for TLS
@@ -352,7 +395,7 @@ class SslFastStart {
 #endif

 class NoRevoke {
-public:
+  public:
    NoRevoke() = default;
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    NoRevoke(bool p_enabled) : enabled(p_enabled) {}
@@ -367,9 +410,14 @@ public:
 } // namespace ssl

 struct SslOptions {
+    // We don't use fs::path here, as this leads to problems using windows
    std::string cert_file;
    std::string cert_type;
+    // We don't use fs::path here, as this leads to problems using windows
    std::string key_file;
+#if SUPPORT_CURLOPT_SSLKEY_BLOB
+    std::string key_blob;
+#endif
    std::string key_type;
    std::string key_pass;
    std::string pinned_public_key;
@@ -389,8 +437,14 @@ struct SslOptions {
 #if SUPPORT_MAX_TLS_VERSION
    int max_version = CURL_SSLVERSION_MAX_DEFAULT;
 #endif
+    // We don't use fs::path here, as this leads to problems using windows
    std::string ca_info;
+    // We don't use fs::path here, as this leads to problems using windows
    std::string ca_path;
+#if SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+    std::string ca_buffer;
+#endif
+    // We don't use fs::path here, as this leads to problems using windows
    std::string crl_file;
    std::string ciphers;
 #if SUPPORT_TLSv13_CIPHERS
@@ -400,15 +454,29 @@ struct SslOptions {
    bool session_id_cache = true;
 #endif

+    ~SslOptions() noexcept {
+#if SUPPORT_CURLOPT_SSLKEY_BLOB
+        util::secureStringClear(key_blob);
+#endif
+        util::secureStringClear(key_pass);
+    }
+
    void SetOption(const ssl::CertFile& opt) {
-        cert_file = opt.filename;
+        cert_file = opt.filename.string();
        cert_type = opt.GetCertType();
    }
    void SetOption(const ssl::KeyFile& opt) {
-        key_file = opt.filename;
+        key_file = opt.filename.string();
        key_type = opt.GetKeyType();
        key_pass = opt.password;
    }
+#if SUPPORT_CURLOPT_SSLKEY_BLOB
+    void SetOption(const ssl::KeyBlob& opt) {
+        key_blob = opt.blob;
+        key_type = opt.GetKeyType();
+        key_pass = opt.password;
+    }
+#endif
    void SetOption(const ssl::PinnedPublicKey& opt) {
        pinned_public_key = opt.pinned_public_key;
    }
@@ -496,13 +564,18 @@ struct SslOptions {
    }
 #endif
    void SetOption(const ssl::CaInfo& opt) {
-        ca_info = opt.filename;
+        ca_info = opt.filename.string();
    }
    void SetOption(const ssl::CaPath& opt) {
-        ca_path = opt.filename;
+        ca_path = opt.filename.string();
    }
+#if SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+    void SetOption(const ssl::CaBuffer& opt) {
+        ca_buffer = opt.buffer;
+    }
+#endif
    void SetOption(const ssl::Crl& opt) {
-        crl_file = opt.filename;
+        crl_file = opt.filename.string();
    }
    void SetOption(const ssl::Ciphers& opt) {
        ciphers = opt.ciphers;
--- a/vendor/CPR/include/cpr/status_codes.h
+++ b/vendor/CPR/include/cpr/status_codes.h
@@ -1,5 +1,5 @@
-#ifndef _CPR_STATUS_CODES
-#define _CPR_STATUS_CODES
+#ifndef CPR_STATUS_CODES
+#define CPR_STATUS_CODES
 #include <cstdint>
 namespace cpr {
 namespace status {
--- a/vendor/CPR/include/cpr/threadpool.h
+++ b/vendor/CPR/include/cpr/threadpool.h
@@ -0,0 +1,122 @@
+#ifndef CPR_THREAD_POOL_H
+#define CPR_THREAD_POOL_H
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <future>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <utility>
+
+#define CPR_DEFAULT_THREAD_POOL_MAX_THREAD_NUM std::thread::hardware_concurrency()
+
+constexpr size_t CPR_DEFAULT_THREAD_POOL_MIN_THREAD_NUM = 1;
+constexpr std::chrono::milliseconds CPR_DEFAULT_THREAD_POOL_MAX_IDLE_TIME{60000};
+
+namespace cpr {
+
+class ThreadPool {
+  public:
+    using Task = std::function<void()>;
+
+    explicit ThreadPool(size_t min_threads = CPR_DEFAULT_THREAD_POOL_MIN_THREAD_NUM, size_t max_threads = CPR_DEFAULT_THREAD_POOL_MAX_THREAD_NUM, std::chrono::milliseconds max_idle_ms = CPR_DEFAULT_THREAD_POOL_MAX_IDLE_TIME);
+
+    virtual ~ThreadPool();
+
+    void SetMinThreadNum(size_t min_threads) {
+        min_thread_num = min_threads;
+    }
+    void SetMaxThreadNum(size_t max_threads) {
+        max_thread_num = max_threads;
+    }
+    void SetMaxIdleTime(std::chrono::milliseconds ms) {
+        max_idle_time = ms;
+    }
+    size_t GetCurrentThreadNum() {
+        return cur_thread_num;
+    }
+    size_t GetIdleThreadNum() {
+        return idle_thread_num;
+    }
+    bool IsStarted() {
+        return status != STOP;
+    }
+    bool IsStopped() {
+        return status == STOP;
+    }
+
+    int Start(size_t start_threads = 0);
+    int Stop();
+    int Pause();
+    int Resume();
+    int Wait();
+
+    /**
+     * Return a future, calling future.get() will wait task done and return RetType.
+     * Submit(fn, args...)
+     * Submit(std::bind(&Class::mem_fn, &obj))
+     * Submit(std::mem_fn(&Class::mem_fn, &obj))
+     **/
+    template <class Fn, class... Args>
+    auto Submit(Fn&& fn, Args&&... args) {
+        if (status == STOP) {
+            Start();
+        }
+        if (idle_thread_num <= 0 && cur_thread_num < max_thread_num) {
+            CreateThread();
+        }
+        using RetType = decltype(fn(args...));
+        auto task = std::make_shared<std::packaged_task<RetType()> >(std::bind(std::forward<Fn>(fn), std::forward<Args>(args)...));
+        std::future<RetType> future = task->get_future();
+        {
+            std::lock_guard<std::mutex> locker(task_mutex);
+            tasks.emplace([task] { (*task)(); });
+        }
+
+        task_cond.notify_one();
+        return future;
+    }
+
+  private:
+    bool CreateThread();
+    void AddThread(std::thread* thread);
+    void DelThread(std::thread::id id);
+
+  public:
+    size_t min_thread_num;
+    size_t max_thread_num;
+    std::chrono::milliseconds max_idle_time;
+
+  private:
+    enum Status {
+        STOP,
+        RUNNING,
+        PAUSE,
+    };
+
+    struct ThreadData {
+        std::shared_ptr<std::thread> thread;
+        std::thread::id id;
+        Status status;
+        time_t start_time;
+        time_t stop_time;
+    };
+
+    std::atomic<Status> status;
+    std::atomic<size_t> cur_thread_num;
+    std::atomic<size_t> idle_thread_num;
+    std::list<ThreadData> threads;
+    std::mutex thread_mutex;
+    std::queue<Task> tasks;
+    std::mutex task_mutex;
+    std::condition_variable task_cond;
+};
+
+} // namespace cpr
+
+#endif
--- a/vendor/CPR/include/cpr/timeout.h
+++ b/vendor/CPR/include/cpr/timeout.h
@@ -12,6 +12,8 @@ class Timeout {
    Timeout(const std::chrono::milliseconds& duration) : ms{duration} {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    Timeout(const std::int32_t& milliseconds) : Timeout{std::chrono::milliseconds(milliseconds)} {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Timeout(const std::chrono::seconds& duration) : ms{std::chrono::milliseconds(duration).count()} {}

    // No way around since curl uses a long here.
    // NOLINTNEXTLINE(google-runtime-int)
--- a/vendor/CPR/include/cpr/unix_socket.h
+++ b/vendor/CPR/include/cpr/unix_socket.h
@@ -8,7 +8,7 @@ namespace cpr {
 class UnixSocket {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    UnixSocket(std::string&& unix_socket) : unix_socket_(std::move(unix_socket)) {}
+    UnixSocket(std::string unix_socket) : unix_socket_(std::move(unix_socket)) {}

    const char* GetUnixSocketString() const noexcept;

--- a/vendor/CPR/include/cpr/user_agent.h
+++ b/vendor/CPR/include/cpr/user_agent.h
@@ -9,11 +9,11 @@
 namespace cpr {
 class UserAgent : public StringHolder<UserAgent> {
  public:
-    UserAgent() : StringHolder<UserAgent>() {}
+    UserAgent() = default;
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    UserAgent(const std::string& useragent) : StringHolder<UserAgent>(useragent) {}
+    UserAgent(std::string useragent) : StringHolder<UserAgent>(std::move(useragent)) {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    UserAgent(std::string&& useragent) : StringHolder<UserAgent>(std::move(useragent)) {}
+    UserAgent(std::string_view useragent) : StringHolder<UserAgent>(useragent) {}
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    UserAgent(const char* useragent) : StringHolder<UserAgent>(useragent) {}
    UserAgent(const char* str, size_t len) : StringHolder<UserAgent>(str, len) {}
--- a/vendor/CPR/include/cpr/util.h
+++ b/vendor/CPR/include/cpr/util.h
@@ -10,31 +10,36 @@
 #include "cpr/cprtypes.h"
 #include "cpr/curlholder.h"

-namespace cpr {
-namespace util {
+namespace cpr::util {

-Header parseHeader(const std::string& headers, std::string* status_line = nullptr,
-                   std::string* reason = nullptr);
+Header parseHeader(const std::string& headers, std::string* status_line = nullptr, std::string* reason = nullptr);
 Cookies parseCookies(curl_slist* raw_cookies);
 size_t readUserFunction(char* ptr, size_t size, size_t nitems, const ReadCallback* read);
 size_t headerUserFunction(char* ptr, size_t size, size_t nmemb, const HeaderCallback* header);
 size_t writeFunction(char* ptr, size_t size, size_t nmemb, std::string* data);
 size_t writeFileFunction(char* ptr, size_t size, size_t nmemb, std::ofstream* file);
 size_t writeUserFunction(char* ptr, size_t size, size_t nmemb, const WriteCallback* write);
-#if LIBCURL_VERSION_NUM < 0x072000
-int progressUserFunction(const ProgressCallback* progress, double dltotal, double dlnow,
-                         double ultotal, double ulnow);
-#else
-int progressUserFunction(const ProgressCallback* progress, curl_off_t dltotal, curl_off_t dlnow,
-                         curl_off_t ultotal, curl_off_t ulnow);
-#endif
-int debugUserFunction(CURL* handle, curl_infotype type, char* data, size_t size,
-                      const DebugCallback* debug);
+
+template <typename T = ProgressCallback>
+int progressUserFunction(const T* progress, cpr_pf_arg_t dltotal, cpr_pf_arg_t dlnow, cpr_pf_arg_t ultotal, cpr_pf_arg_t ulnow) {
+    const int cancel_retval{1};
+    static_assert(cancel_retval != CURL_PROGRESSFUNC_CONTINUE);
+    return (*progress)(dltotal, dlnow, ultotal, ulnow) ? 0 : cancel_retval;
+}
+int debugUserFunction(CURL* handle, curl_infotype type, char* data, size_t size, const DebugCallback* debug);
 std::vector<std::string> split(const std::string& to_split, char delimiter);
 std::string urlEncode(const std::string& s);
 std::string urlDecode(const std::string& s);

-} // namespace util
-} // namespace cpr
+/**
+ * Override the content of the provided string to hide sensitive data. The
+ * string content after invocation is undefined. The string size is reset to zero.
+ * impl. based on:
+ * https://github.com/ojeda/secure_clear/blob/master/example-implementation/secure_clear.h
+ **/
+void secureStringClear(std::string& s);
+bool isTrue(const std::string& s);
+
+} // namespace cpr::util

 #endif