Incomplete Discord implementation.

cmake/_FindOpus.cmake

@@ -1,92 +0,0 @@
-############################################################################
-# FindOpus.cmake
-# Copyright (C) 2014-2023  Belledonne Communications, Grenoble France
-#
-############################################################################
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-#
-############################################################################
-#
-# Find the opus library.
-#
-# Targets
-# ^^^^^^^
-#
-# The following targets may be defined:
-#
-#  opus - If the opus library has been found
-#
-#
-# Result variables
-# ^^^^^^^^^^^^^^^^
-#
-# This module will set the following variables in your project:
-#
-#  Opus_FOUND - The opus library has been found
-#  Opus_TARGET - The name of the CMake target for the opus library
-#
-# This module may set the following variable:
-#
-#  Opus_USE_BUILD_INTERFACE - If the opus library is used from its build directory
-
-
-include(FindPackageHandleStandardArgs)
-
-set(_Opus_REQUIRED_VARS Opus_TARGET)
-set(_Opus_CACHE_VARS ${_Opus_REQUIRED_VARS})
-
-if(TARGET opus)
-
-	set(Opus_TARGET opus)
-	set(Opus_USE_BUILD_INTERFACE TRUE)
-
-else()
-
-	find_path(_Opus_INCLUDE_DIRS
-		NAMES opus/opus.h
-		PATH_SUFFIXES include
-	)
-
-	find_library(_Opus_LIBRARY NAMES opus)
-	if(_Opus_LIBRARY)
-		find_library(_m_LIBRARY NAMES m)
-	endif()
-
-	if(_Opus_INCLUDE_DIRS AND _Opus_LIBRARY)
-		add_library(opus UNKNOWN IMPORTED)
-		if(WIN32)
-			set_target_properties(opus PROPERTIES
-				INTERFACE_INCLUDE_DIRECTORIES "${_Opus_INCLUDE_DIRS}"
-				IMPORTED_IMPLIB "${_Opus_LIBRARY}"
-				IMPORTED_LINK_INTERFACE_LIBRARIES "${_m_LIBRARY}"
-			)
-		else()
-			set_target_properties(opus PROPERTIES
-				INTERFACE_INCLUDE_DIRECTORIES "${_Opus_INCLUDE_DIRS}"
-				IMPORTED_LOCATION "${_Opus_LIBRARY}"
-				IMPORTED_LINK_INTERFACE_LIBRARIES "${_m_LIBRARY}"
-			)
-		endif()
-
-		set(Opus_TARGET opus)
-	endif()
-
-endif()
-
-find_package_handle_standard_args(Opus
-	REQUIRED_VARS ${_Opus_REQUIRED_VARS}
-)
-mark_as_advanced(${_Opus_CACHE_VARS})

module/CMakeLists.txt

@@ -179,28 +179,28 @@ if(POSTGRESQL_FOUND)
 endif()
 # Is Discord support enabled?
 if(ENABLE_DISCORD)
-target_link_libraries(SqModule dpp)
+    target_link_libraries(SqModule dpp)
-target_sources(SqModule PRIVATE
+    target_sources(SqModule PRIVATE
-    Library/Discord.cpp Library/Discord.hpp
+        Library/Discord.cpp Library/Discord.hpp
-    Library/Discord/Application.hpp Library/Discord/Application.cpp
+        Library/Discord/Application.hpp Library/Discord/Application.cpp
-    Library/Discord/Automod.hpp Library/Discord/Automod.cpp
+        Library/Discord/Automod.hpp Library/Discord/Automod.cpp
-    Library/Discord/Channel.hpp Library/Discord/Channel.cpp
+        Library/Discord/Channel.hpp Library/Discord/Channel.cpp
-    Library/Discord/Client.hpp Library/Discord/Client.cpp
+        Library/Discord/Client.hpp Library/Discord/Client.cpp
-    Library/Discord/Cluster.hpp Library/Discord/Cluster.cpp
+        Library/Discord/Cluster.hpp Library/Discord/Cluster.cpp
-    Library/Discord/Command.hpp Library/Discord/Command.cpp
+        Library/Discord/Command.hpp Library/Discord/Command.cpp
-    Library/Discord/Constants.hpp Library/Discord/Constants.cpp
+        Library/Discord/Constants.hpp Library/Discord/Constants.cpp
-    Library/Discord/Events.hpp Library/Discord/Events.cpp
+        Library/Discord/Events.hpp Library/Discord/Events.cpp
-    Library/Discord/Guild.hpp Library/Discord/Guild.cpp
+        Library/Discord/Guild.hpp Library/Discord/Guild.cpp
-    Library/Discord/Integration.hpp Library/Discord/Integration.cpp
+        Library/Discord/Integration.hpp Library/Discord/Integration.cpp
-    Library/Discord/Message.hpp Library/Discord/Message.cpp
+        Library/Discord/Message.hpp Library/Discord/Message.cpp
-    Library/Discord/Misc.hpp Library/Discord/Misc.cpp
+        Library/Discord/Misc.hpp Library/Discord/Misc.cpp
-    Library/Discord/Presence.hpp Library/Discord/Presence.cpp
+        Library/Discord/Presence.hpp Library/Discord/Presence.cpp
-    Library/Discord/Role.hpp Library/Discord/Role.cpp
+        Library/Discord/Role.hpp Library/Discord/Role.cpp
-    Library/Discord/User.hpp Library/Discord/User.cpp
+        Library/Discord/User.hpp Library/Discord/User.cpp
-    Library/Discord/Utilities.hpp Library/Discord/Utilities.cpp
+        Library/Discord/Utilities.hpp Library/Discord/Utilities.cpp
-)
+    )
-# Inform the plug-in that discord is enabled
+    # Inform the plug-in that discord is enabled
-target_compile_definitions(SqModule PRIVATE SQMOD_DISCORD=1)
+    target_compile_definitions(SqModule PRIVATE SQMOD_DISCORD=1)
 endif()
 # Determine if build mode
 if(${CMAKE_BUILD_TYPE} MATCHES "(Release)+")

module/Library/CURL.cpp

@@ -19,19 +19,6 @@ SQMOD_DECL_TYPENAME(SqCpProxies, _SC("SqCprProxies"))
 SQMOD_DECL_TYPENAME(SqCpRedirect, _SC("SqCprRedirect"))
 SQMOD_DECL_TYPENAME(SqCpSession, _SC("SqCprSession"))
 
-// ------------------------------------------------------------------------------------------------
-struct CurlInit
-{
-    CurlInit()
-    {
-        curl_global_init(CURL_GLOBAL_ALL);
-    }
-    ~CurlInit()
-    {
-        curl_global_cleanup();
-    }
-};
-
 /* ------------------------------------------------------------------------------------------------
  * Common session action implementation.
 */
@@ -671,11 +658,13 @@ void Register_CURL(HSQUIRRELVM vm)
         .Func(_SC("SetTimeout"), &CpSession::SetTimeout_)
         .Func(_SC("SetConnectTimeout"), &CpSession::SetConnectTimeout_)
         .FmtFunc(_SC("SetAuth"), &CpSession::SetAuth_)
+        .FmtFunc(_SC("SetDigest"), &CpSession::SetDigest_)
         .FmtFunc(_SC("SetUserAgent"), &CpSession::SetUserAgent_)
         .Func(_SC("SetPayload"), &CpSession::SetPayload_)
         .Func(_SC("YieldPayload"), &CpSession::YieldPayload)
         .Func(_SC("SetProxies"), &CpSession::SetProxies_)
         .Func(_SC("YieldProxies"), &CpSession::YieldProxies)
+        .FmtFunc(_SC("SetNTLM"), &CpSession::SetNTLM_)
         .Func(_SC("SetRedirect"), &CpSession::SetRedirect_)
         .Func(_SC("SetCookies"), &CpSession::SetCookies_)
         .FmtFunc(_SC("SetBody"), &CpSession::SetBody_)

module/Library/CURL.hpp

@@ -507,7 +507,7 @@ struct CpCookies : public cpr::Cookies
      * Move constructor.
     */
     explicit CpCookies(cpr::Cookies && e) : cpr::Cookies(std::move(e)) { }
-
+    
     /* --------------------------------------------------------------------------------------------
      * Copy constructor.
     */
@@ -538,7 +538,7 @@ struct CpCookies : public cpr::Cookies
     */
     SQMOD_NODISCARD SQInteger Size() const
     {
-        return static_cast< SQInteger >(cpr::Cookies::cookies_.size());
+        return static_cast< SQInteger >(cpr::Cookies::map_.size());
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -546,7 +546,7 @@ struct CpCookies : public cpr::Cookies
     */
     SQMOD_NODISCARD bool Empty() const
     {
-        return cpr::Cookies::cookies_.empty();
+        return cpr::Cookies::map_.empty();
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -554,7 +554,7 @@ struct CpCookies : public cpr::Cookies
     */
     void Clear()
     {
-        cpr::Cookies::cookies_.clear();
+        cpr::Cookies::map_.clear();
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -562,12 +562,7 @@ struct CpCookies : public cpr::Cookies
     */
     SQMOD_NODISCARD SQInteger Count(StackStrF & key) const
     {
-      SQInteger cnt = 0;
+        return static_cast< SQInteger >(cpr::Cookies::map_.count(key.ToStr()));
-      for (const auto & c : cpr::Cookies::cookies_)
-      {
-        if (c.GetName().compare(0, static_cast<size_t>(key.mLen), key.mPtr) == 0) ++cnt;
-      }
-      return cnt;
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -575,14 +570,14 @@ struct CpCookies : public cpr::Cookies
     */
     bool Erase(StackStrF & key)
     {
-        // auto itr = cpr::Cookies::cookies_.find(key.ToStr());
+        auto itr = cpr::Cookies::map_.find(key.ToStr());
-        // // Does it exist?
+        // Does it exist?
-        // if (itr == cpr::Cookies::cookies_.end())
+        if (itr == cpr::Cookies::map_.end())
-        // {
+        {
-        //     return false; // Nope
+            return false; // Nope
-        // }
+        }
-        // // Erase it
+        // Erase it
-        // cpr::Cookies::cookies_.erase(itr);
+        cpr::Cookies::map_.erase(itr);
         // Erased
         return true;
     }
@@ -592,7 +587,7 @@ struct CpCookies : public cpr::Cookies
     */
     SQMOD_NODISCARD bool Has(StackStrF & key) const
     {
-        return false;//cpr::Cookies::cookies_.find(key.ToStr()) != cpr::Cookies::cookies_.end()
+        return cpr::Cookies::map_.find(key.ToStr()) != cpr::Cookies::map_.end();
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -600,15 +595,14 @@ struct CpCookies : public cpr::Cookies
     */
     SQMOD_NODISCARD std::string & Get(StackStrF & key)
     {
-        // auto itr = cpr::Cookies::cookies_.find(key.ToStr());
+        auto itr = cpr::Cookies::map_.find(key.ToStr());
-        // // Does it exist?
+        // Does it exist?
-        // if (itr == cpr::Cookies::cookies_.end())
+        if (itr == cpr::Cookies::map_.end())
-        // {
+        {
-        //     STHROWF("No cookie named: %s", key.mPtr);
+            STHROWF("No cookie named: %s", key.mPtr);
-        // }
+        }
-        static std::string s;
         // Return it
-        return s;// itr->second;
+        return itr->second;
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -616,7 +610,7 @@ struct CpCookies : public cpr::Cookies
     */
     void Set(StackStrF & key, StackStrF & val)
     {
-        //cpr::Cookies::cookies_[key.ToStr()] = val.ToStr();
+        cpr::Cookies::map_[key.ToStr()] = val.ToStr();
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -624,9 +618,9 @@ struct CpCookies : public cpr::Cookies
     */
     void Each(Function & fn) const
     {
-        for (const auto & c : cpr::Cookies::cookies_)
+        for (const auto & p : cpr::Cookies::map_)
         {
-            fn.Execute(c);
+            fn.Execute(p.first, p.second);
         }
     }
 
@@ -635,9 +629,9 @@ struct CpCookies : public cpr::Cookies
     */
     void While(Function & fn) const
     {
-        for (const auto & c : cpr::Cookies::cookies_)
+        for (const auto & p : cpr::Cookies::map_)
         {
-            auto ret = fn.Eval(c);
+            auto ret = fn.Eval(p.first, p.second);
             // (null || true) == continue & false == break
             if (!ret.IsNull() || !ret.Cast< bool >())
             {
@@ -670,7 +664,7 @@ struct CpHeader
      * Move constructor.
     */
     explicit CpHeader(cpr::Header && e) : mMap(std::move(e)) { }
-
+    
     /* --------------------------------------------------------------------------------------------
      * Copy constructor.
     */
@@ -869,7 +863,7 @@ struct CpResponse : public cpr::Response
             STHROWF("Invalid response instance");
         }
         // Retrieve the info vector
-        auto vec = cpr::Response::GetCertInfos();
+        auto vec = cpr::Response::GetCertInfo();
         // Create a script array
         Array arr(SqVM(), static_cast< SQInteger >(vec.size()));
         // Populate the array with vector elements
@@ -1126,7 +1120,7 @@ struct CpParameters : public cpr::Parameters
      * Move constructor.
     */
     explicit CpParameters(cpr::Parameters && e) : cpr::Parameters(std::move(e)) { }
-
+    
     /* --------------------------------------------------------------------------------------------
      * Copy constructor.
     */
@@ -1297,7 +1291,7 @@ struct CpPayload : public cpr::Payload
      * Move constructor.
     */
     explicit CpPayload(cpr::Payload && e) : cpr::Payload(std::move(e)) { }
-
+    
     /* --------------------------------------------------------------------------------------------
      * Copy constructor.
     */
@@ -1476,7 +1470,7 @@ struct CpProxies : public cpr::Proxies
      * Move constructor.
     */
     explicit CpProxies(cpr::Proxies && e) : cpr::Proxies(std::move(e)) { }
-
+    
     /* --------------------------------------------------------------------------------------------
      * Copy constructor.
     */
@@ -1625,7 +1619,7 @@ struct CpRedirect : public cpr::Redirect
      * Explicit constructor.
     */
     explicit CpRedirect(SQInteger maximum)
-        : cpr::Redirect(static_cast< long >(maximum), true, false, cpr::PostRedirectFlags::POST_ALL)
+        : cpr::Redirect(static_cast< long >(maximum), true, cpr::PostRedirectFlags::POST_ALL)
     {
     }
 
@@ -1633,23 +1627,15 @@ struct CpRedirect : public cpr::Redirect
      * Explicit constructor.
     */
     CpRedirect(SQInteger maximum, bool follow)
-        : cpr::Redirect(static_cast< long >(maximum), follow, false, cpr::PostRedirectFlags::POST_ALL)
+        : cpr::Redirect(static_cast< long >(maximum), follow, cpr::PostRedirectFlags::POST_ALL)
     {
     }
 
     /* --------------------------------------------------------------------------------------------
      * Explicit constructor.
     */
-    CpRedirect(SQInteger maximum, bool follow, bool cont_send_cred)
+    CpRedirect(SQInteger maximum, bool follow, SQInteger post_flags)
-        : cpr::Redirect(static_cast< long >(maximum), follow, cont_send_cred, cpr::PostRedirectFlags::POST_ALL)
+        : cpr::Redirect(static_cast< long >(maximum), follow, static_cast< cpr::PostRedirectFlags >(post_flags))
-    {
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Explicit constructor.
-    */
-    CpRedirect(SQInteger maximum, bool follow, bool cont_send_cred, SQInteger post_flags)
-        : cpr::Redirect(static_cast< long >(maximum), follow, cont_send_cred, static_cast< cpr::PostRedirectFlags >(post_flags))
     {
     }
 
@@ -1662,7 +1648,7 @@ struct CpRedirect : public cpr::Redirect
      * Move constructor.
     */
     explicit CpRedirect(cpr::Redirect && e) : cpr::Redirect(e) { }
-
+    
     /* --------------------------------------------------------------------------------------------
      * Copy constructor.
     */
@@ -1893,10 +1879,20 @@ struct CpSession : public cpr::Session
     /* --------------------------------------------------------------------------------------------
      * Modify auth option.
     */
-    CpSession & SetAuth_(StackStrF & username, StackStrF & password, SQInteger mode)
+    CpSession & SetAuth_(StackStrF & username, StackStrF & password)
     {
         LockCheck();
-        cpr::Session::SetAuth(cpr::Authentication(username.ToStr(), password.ToStr(), static_cast<cpr::AuthMode>(mode)));
+        cpr::Session::SetAuth(cpr::Authentication(username.ToStr(), password.ToStr()));
+        return *this; // Allow chaining
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify digest option.
+    */
+    CpSession & SetDigest_(StackStrF & username, StackStrF & password)
+    {
+        LockCheck();
+        cpr::Session::SetAuth(cpr::Digest(username.ToStr(), password.ToStr()));
         return *this; // Allow chaining
     }
 
@@ -1964,6 +1960,16 @@ struct CpSession : public cpr::Session
     //{
     //}
 
+    /* --------------------------------------------------------------------------------------------
+     * Modify NTLM option.
+    */
+    CpSession & SetNTLM_(StackStrF & username, StackStrF & password)
+    {
+        LockCheck();
+        cpr::Session::SetNTLM(cpr::NTLM(username.ToStr(), password.ToStr()));
+        return *this; // Allow chaining
+    }
+
     /* --------------------------------------------------------------------------------------------
      * Modify redirect option.
     */

module/Library/Discord/Cluster.cpp

@@ -15,7 +15,6 @@ DpCluster::DpCluster(DpClusterOptions & o)
     : Base(), mQueue(4096)
     , mC(std::make_unique< dpp::cluster >(o.mToken, o.mIntents, o.mShards, o.mClusterID, o.mMaxClusters, o.mCompressed, o.mPolicy, o.mRequestThreads, o.mRequestThreadsRaw))
     , mSqEvents(), mEvents(), mEventsHandle()
-    , mCCList(), mCCResults(std::make_shared< CCResultQueue >(4096))
 {
     // Make sure all event handles are not valid
     mEventsHandle.fill(0);
@@ -84,31 +83,6 @@ void DpCluster::Process(bool force)
             p->Cleanup();
         }
     }
-    CCResultItem cc_item;
-    // Retrieve each command completion result individually and process it
-    for (size_t count = mCCResults->size_approx(), n = 0; n <= count; ++n)
-    {
-        // Try to get a result from the queue
-        if (mCCResults->try_dequeue(cc_item))
-        {
-            CCResult & r = *cc_item;
-            // Get the script callback
-            Function & cb = *(r.first);
-            // Is there still a valid callback to invoke?
-            if (!cb.IsNull())
-            {
-                // Don't abort everything down the line for an error caused by a script callback
-                try {
-                    cb.Execute(LightObj(SqTypeIdentity< DpCommandConfirmation >{}, cb.GetVM(), std::move(r.second)));
-                } catch (const std::exception & e) {
-                    LogErr("Squirrel exception caught in discord command completion event");
-                    LogSInf("Message: %s", e.what());
-                }
-            }
-            // Release the callback from the list
-            mCCList.erase(r.first);
-        }
-    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -148,7 +122,6 @@ void Register_Discord_Cluster(HSQUIRRELVM vm, Table & ns)
         .Func(_SC("Stop"), &DpCluster::Stop)
         .Func(_SC("EnableEvent"), &DpCluster::EnableEvent)
         .Func(_SC("DisableEvent"), &DpCluster::DisableEvent)
-        .CbFunc(_SC("CurrentUserGetGuilds"), &DpCluster::CurrentUserGetGuilds)
     );
 }
 
@@ -223,7 +196,6 @@ DpCluster & DpCluster::EnableEvent(SQInteger id)
         case DpEventID::MessageUpdate:                  eh = c.on_message_update.attach([this](const dpp::message_update_t & e) { OnMessageUpdate(e); }); break;
         case DpEventID::UserUpdate:                     eh = c.on_user_update.attach([this](const dpp::user_update_t & e) { OnUserUpdate(e); }); break;
         case DpEventID::MessageCreate:                  eh = c.on_message_create.attach([this](const dpp::message_create_t & e) { OnMessageCreate(e); }); break;
-        case DpEventID::GuildAuditLogEntryCreate:       eh = c.on_guild_audit_log_entry_create.attach([this](const dpp::guild_audit_log_entry_create_t & e) { OnGuildAuditLogEntryCreate(e); }); break;
         case DpEventID::GuildBanAdd:                    eh = c.on_guild_ban_add.attach([this](const dpp::guild_ban_add_t & e) { OnGuildBanAdd(e); }); break;
         case DpEventID::GuildBanRemove:                 eh = c.on_guild_ban_remove.attach([this](const dpp::guild_ban_remove_t & e) { OnGuildBanRemove(e); }); break;
         case DpEventID::IntegrationCreate:              eh = c.on_integration_create.attach([this](const dpp::integration_create_t & e) { OnIntegrationCreate(e); }); break;
@@ -329,7 +301,6 @@ DpCluster & DpCluster::DisableEvent(SQInteger id)
         case DpEventID::MessageUpdate:                  c.on_message_update.detach(eh); break;
         case DpEventID::UserUpdate:                     c.on_user_update.detach(eh); break;
         case DpEventID::MessageCreate:                  c.on_message_create.detach(eh); break;
-        case DpEventID::GuildAuditLogEntryCreate:       c.on_guild_audit_log_entry_create.detach(eh); break;
         case DpEventID::GuildBanAdd:                    c.on_guild_ban_add.detach(eh); break;
         case DpEventID::GuildBanRemove:                 c.on_guild_ban_remove.detach(eh); break;
         case DpEventID::IntegrationCreate:              c.on_integration_create.detach(eh); break;
@@ -467,8 +438,6 @@ void DpCluster::OnUserUpdate(const dpp::user_update_t & ev)
 { mQueue.enqueue(EventItem(new DpUserUpdateEvent(ev))); }
 void DpCluster::OnMessageCreate(const dpp::message_create_t & ev)
 { mQueue.enqueue(EventItem(new DpMessageCreateEvent(ev))); }
-void DpCluster::OnGuildAuditLogEntryCreate(const dpp::guild_audit_log_entry_create_t & ev)
-{ mQueue.enqueue(EventItem(new DpGuildAuditLogEntryCreateEvent(ev))); }
 void DpCluster::OnGuildBanAdd(const dpp::guild_ban_add_t & ev)
 { mQueue.enqueue(EventItem(new DpGuildBanAddEvent(ev))); }
 void DpCluster::OnGuildBanRemove(const dpp::guild_ban_remove_t & ev)

module/Library/Discord/Cluster.hpp

@@ -136,7 +136,7 @@ struct DpCluster : public SqChainedInstances< DpCluster >
     */
     ~DpCluster()
     {
-        if (mC) Stop();
+        Stop();
         // Forget about this instance
         UnchainInstance();
     }
@@ -165,7 +165,7 @@ struct DpCluster : public SqChainedInstances< DpCluster >
     {
         if (!mC)
         {
-            STHROWF("Cannot {} a cluster instance that is not valid anymore.", fmt::detail::to_string_view(m));
+            STHROWF("Cannot {} a cluster instance that is not valid anymore.", fmt::to_string_view(m));
         }
     }
 
@@ -307,7 +307,6 @@ private:
     void OnMessageUpdate(const dpp::message_update_t & ev);
     void OnUserUpdate(const dpp::user_update_t & ev);
     void OnMessageCreate(const dpp::message_create_t & ev);
-    void OnGuildAuditLogEntryCreate(const dpp::guild_audit_log_entry_create_t & ev);
     void OnGuildBanAdd(const dpp::guild_ban_add_t & ev);
     void OnGuildBanRemove(const dpp::guild_ban_remove_t & ev);
     void OnIntegrationCreate(const dpp::integration_create_t & ev);
@@ -333,64 +332,6 @@ private:
     void OnStageInstanceCreate(const dpp::stage_instance_create_t & ev);
     void OnStageInstanceUpdate(const dpp::stage_instance_update_t & ev);
     void OnStageInstanceDelete(const dpp::stage_instance_delete_t & ev);
-
-public:
-
-    // List type for command completion callbacks.
-    using CCList = std::list< Function >;
-    /* --------------------------------------------------------------------------------------------
-     * List of command completion callbacks.
-    */
-    CCList mCCList{};
-
-    /* --------------------------------------------------------------------------------------------
-     * Queue of iterators pointing to results of completed commands and their associated result.
-    */
-    using CCResult = std::pair< CCList::iterator, DpCommandConfirmation::Ptr >;
-    using CCResultItem = std::unique_ptr< CCResult >;
-    using CCResultQueue = moodycamel::ConcurrentQueue< CCResultItem >;
-
-    /* --------------------------------------------------------------------------------------------
-     * Command completion links queue.
-    */
-    std::shared_ptr< CCResultQueue > mCCResults{};
-
-    /* --------------------------------------------------------------------------------------------
-     * Maintains an iterator to the script callback associated with a completed command result.
-    */
-    struct CCLink
-    {
-        // Iterator to the element where the state can be found.
-        CCList::iterator    mItr{};
-        // Reference to the queue of iterators pointing to completed commands.
-        std::shared_ptr< CCResultQueue > mQueue{};
-        /* ----------------------------------------------------------------------------------------
-         * Base constructor.
-        */
-        CCLink(CCList::iterator && itr, std::shared_ptr< CCResultQueue > & q)
-            : mItr(std::forward< CCList::iterator >(itr)), mQueue(q)
-        { }
-        // Copy/Move constructors.
-        CCLink(const CCLink &) = default;
-        CCLink(CCLink &&) noexcept = default;
-        // Copy/Move assignment operators.
-        CCLink & operator = (const CCLink &) = default;
-        CCLink & operator = (CCLink &&) noexcept = default;
-        // Function call operator. Marks the linked callback as ready to invoke with obtained result.
-        void operator () (const dpp::confirmation_callback_t & cc) const
-        {
-            mQueue->enqueue(std::make_unique< CCResult >(std::move(mItr), std::make_unique< dpp::confirmation_callback_t >(cc.http_info)));
-        }
-    };
-
-    /* --------------------------------------------------------------------------------------------
-     * Get current (bot) user guilds.
-     * https://discord.com/developers/docs/resources/user#get-current-user-guilds
-    */
-    void CurrentUserGetGuilds(Function & cb)
-    {
-        Valid("get message").current_user_get_guilds(CCLink(mCCList.emplace(mCCList.cend(), std::move(cb)), mCCResults));
-    }
 };
 
 } // Namespace:: SqMod

module/Library/Discord/Constants.cpp

@@ -60,7 +60,6 @@ const std::array< const char *, static_cast< size_t >(DpEventID::Max) > DpEventI
   "MessageUpdate",
   "UserUpdate",
   "MessageCreate",
-  "GuildAuditLogEntryCreate",
   "GuildBanAdd",
   "GuildBanRemove",
   "IntegrationCreate",

module/Library/Discord/Constants.hpp

@@ -74,7 +74,6 @@ struct DpEventID
         MessageUpdate,
         UserUpdate,
         MessageCreate,
-        GuildAuditLogEntryCreate,
         GuildBanAdd,
         GuildBanRemove,
         IntegrationCreate,
@@ -417,12 +416,6 @@ struct DpMessageCreateEventInfo
     static inline constexpr size_t ID = DpEventID::MessageCreate;
     static inline constexpr std::string_view Name = "MessageCreate";
 };
-struct DpGuildAuditLogEntryCreateEventInfo
-{
-    using Type = dpp::guild_audit_log_entry_create_t;
-    static inline constexpr size_t ID = DpEventID::GuildAuditLogEntryCreate;
-    static inline constexpr std::string_view Name = "GuildAuditLogEntryCreate";
-};
 struct DpGuildBanAddEventInfo
 {
     using Type = dpp::guild_ban_add_t;
@@ -633,7 +626,6 @@ template < > struct EventInfoID< DpEventID::InviteCreate > : public DpInviteCrea
 template < > struct EventInfoID< DpEventID::MessageUpdate > : public DpMessageUpdateEventInfo { };
 template < > struct EventInfoID< DpEventID::UserUpdate > : public DpUserUpdateEventInfo { };
 template < > struct EventInfoID< DpEventID::MessageCreate > : public DpMessageCreateEventInfo { };
-template < > struct EventInfoID< DpEventID::GuildAuditLogEntryCreate > : public DpGuildAuditLogEntryCreateEventInfo { };
 template < > struct EventInfoID< DpEventID::GuildBanAdd > : public DpGuildBanAddEventInfo { };
 template < > struct EventInfoID< DpEventID::GuildBanRemove > : public DpGuildBanRemoveEventInfo { };
 template < > struct EventInfoID< DpEventID::IntegrationCreate > : public DpIntegrationCreateEventInfo { };

module/Library/Discord/Events.cpp

@@ -56,7 +56,6 @@ SQMOD_DECL_TYPENAME(SqDpInviteCreateEvent, _SC("SqDiscordInviteCreateEvent"))
 SQMOD_DECL_TYPENAME(SqDpMessageUpdateEvent, _SC("SqDiscordMessageUpdateEvent"))
 SQMOD_DECL_TYPENAME(SqDpUserUpdateEvent, _SC("SqDiscordUserUpdateEvent"))
 SQMOD_DECL_TYPENAME(SqDpMessageCreateEvent, _SC("SqDiscordMessageCreateEvent"))
-SQMOD_DECL_TYPENAME(SqDpGuildAuditLogEntryCreateEvent, _SC("SqDiscordGuildAuditLogEntryCreateEvent"))
 SQMOD_DECL_TYPENAME(SqDpGuildBanAddEvent, _SC("SqDiscordGuildBanAddEvent"))
 SQMOD_DECL_TYPENAME(SqDpGuildBanRemoveEvent, _SC("SqDiscordGuildBanRemoveEvent"))
 SQMOD_DECL_TYPENAME(SqDpIntegrationCreateEvent, _SC("SqDiscordIntegrationCreateEvent"))
@@ -549,15 +548,6 @@ void Register_Discord_Events(HSQUIRRELVM vm, Table & ns)
         .Prop(_SC("Raw"), &DpMessageCreateEvent::GetRawEvent)
     );
     // --------------------------------------------------------------------------------------------
-    ns.Bind(_SC("GuildAuditLogEntryCreate"),
-        Class< DpGuildAuditLogEntryCreateEvent, NoConstructor< DpGuildAuditLogEntryCreateEvent > >(vm, SqDpGuildAuditLogEntryCreateEvent::Str)
-        // Meta-methods
-        .SquirrelFunc(_SC("_typename"), &SqDpGuildAuditLogEntryCreateEvent::Fn)
-        .Func(_SC("_tostring"), &DpGuildAuditLogEntryCreateEvent::GetRawEvent)
-        // Member Properties
-        .Prop(_SC("Raw"), &DpGuildAuditLogEntryCreateEvent::GetRawEvent)
-    );
-    // --------------------------------------------------------------------------------------------
     ns.Bind(_SC("GuildBanAdd"),
         Class< DpGuildBanAddEvent, NoConstructor< DpGuildBanAddEvent > >(vm, SqDpGuildBanAddEvent::Str)
         // Meta-methods

module/Library/Discord/Events.hpp

@@ -1857,39 +1857,6 @@ struct DpMessageCreateEvent : public DpEvent< DpMessageCreateEventInfo >
 /* ------------------------------------------------------------------------------------------------
  *
 */
-struct DpGuildAuditLogEntryCreateEvent : public DpEvent< DpGuildAuditLogEntryCreateEventInfo >
-{
-    using Type = dpp::guild_audit_log_entry_create_t;
-    using Base = DpEvent< DpGuildAuditLogEntryCreateEventInfo >;
-    // --------------------------------------------------------------------------------------------
-
-    /* --------------------------------------------------------------------------------------------
-     * Explicit constructor.
-    */
-    explicit DpGuildAuditLogEntryCreateEvent(const Type & d) noexcept
-        : Base(d)
-    {
-    }
-    /* --------------------------------------------------------------------------------------------
-     * Transform the event object itself to a script object. Used internally.
-    */
-    SQMOD_NODISCARD LightObj ToScriptObject() override { return LightObj{this}; }
-    /* --------------------------------------------------------------------------------------------
-     * Retrieve the raw event.
-    */
-    SQMOD_NODISCARD const std::string & GetRawEvent() const { return Base::mRaw; }
-    /* --------------------------------------------------------------------------------------------
-     * Cleanup after the event was processed.
-    */
-    void Cleanup() override
-    {
-        // Allow the base to cleanup as well
-        Base::Cleanup();
-    }
-};
-/* ------------------------------------------------------------------------------------------------
- *
-*/
 struct DpGuildBanAddEvent : public DpEvent< DpGuildBanAddEventInfo >
 {
     using Type = dpp::guild_ban_add_t;

module/Library/Discord/Misc.cpp

@@ -10,7 +10,6 @@ SQMOD_DECL_TYPENAME(SqDpUptime, _SC("SqDiscordUptime"))
 SQMOD_DECL_TYPENAME(SqDpIconHash, _SC("SqDiscordIconHash"))
 SQMOD_DECL_TYPENAME(SqDpVoiceState, _SC("SqDiscordVoiceState"))
 SQMOD_DECL_TYPENAME(SqDpEmoji, _SC("SqDiscordEmoji"))
-SQMOD_DECL_TYPENAME(SqDpCommandConfirmation, _SC("SqDiscordCommandConfirmation"))
 
 // ------------------------------------------------------------------------------------------------
 void Register_Discord_Misc(HSQUIRRELVM vm, Table & ns)
@@ -113,17 +112,6 @@ void Register_Discord_Misc(HSQUIRRELVM vm, Table & ns)
         .Func(_SC("BuildJSON"), &DpEmoji::BuildJSON_)
         .Func(_SC("LoadImage"), &DpEmoji::LoadImage)
     );
-    // --------------------------------------------------------------------------------------------
-    ns.Bind(_SC("CommandConfirmation"),
-        Class< DpCommandConfirmation, NoConstructor< DpCommandConfirmation > >(vm, SqDpCommandConfirmation::Str)
-        // Meta-methods
-        .SquirrelFunc(_SC("_typename"), &SqDpCommandConfirmation::Fn)
-        // Member Properties
-        .Prop(_SC("Valid"), &DpCommandConfirmation::IsValid)
-        .Prop(_SC("HttpBody"), &DpCommandConfirmation::GetHttpBody)
-        // Member Methods
-        //.Func(_SC("SetName"), &DpCommandConfirmation::ApplyName)
-    );
 }
 
 } // Namespace:: SqMod

module/Library/Discord/Misc.hpp

@@ -390,104 +390,4 @@ struct DpEmoji
     SQMOD_NODISCARD std::string GetMention() const { return Valid().get_mention(); }
 };
 
-/* ------------------------------------------------------------------------------------------------
- * The results of a REST call wrapped in a convenient struct.
-*/
-struct DpCommandConfirmation
-{
-    using Ptr = std::unique_ptr< dpp::confirmation_callback_t >;
-    /* --------------------------------------------------------------------------------------------
-     * Referenced confirmation callback instance.
-    */
-    Ptr mPtr{nullptr};
-    /* --------------------------------------------------------------------------------------------
-     * Whether the referenced pointer is owned.
-    */
-    bool mOwned{false};
-    /* --------------------------------------------------------------------------------------------
-     * Default constructor.
-    */
-    DpCommandConfirmation() noexcept = default;
-    /* --------------------------------------------------------------------------------------------
-     * Explicit constructor.
-    */
-    explicit DpCommandConfirmation(Ptr::pointer ptr, bool owned = false) noexcept
-        : mPtr(ptr), mOwned(owned)
-    { }
-    /* --------------------------------------------------------------------------------------------
-     * Explicit constructor.
-    */
-    explicit DpCommandConfirmation(Ptr && ptr) noexcept
-        : mPtr(std::forward< Ptr >(ptr)), mOwned(true)
-    { }
-    /* --------------------------------------------------------------------------------------------
-     * Explicit constructor.
-    */
-    explicit DpCommandConfirmation(const Ptr::element_type & o) noexcept
-        : DpCommandConfirmation(new Ptr::element_type(o), true)
-    { }
-    /* --------------------------------------------------------------------------------------------
-     * Move constructor.
-    */
-    explicit DpCommandConfirmation(Ptr::element_type && o) noexcept
-        : DpCommandConfirmation(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
-    { }
-    /* --------------------------------------------------------------------------------------------
-     * Copy constructor (disabled).
-    */
-    DpCommandConfirmation(const DpCommandConfirmation & o) = delete;
-    /* --------------------------------------------------------------------------------------------
-     * Move constructor.
-    */
-    DpCommandConfirmation(DpCommandConfirmation && o) noexcept = default;
-    /* --------------------------------------------------------------------------------------------
-     * Destructor.
-    */
-    ~DpCommandConfirmation() noexcept { Cleanup(); }
-    /* --------------------------------------------------------------------------------------------
-     * Copy assignment operator (disabled).
-    */
-    DpCommandConfirmation & operator = (const DpCommandConfirmation & o) = delete;
-    /* --------------------------------------------------------------------------------------------
-     * Move assignment operator.
-    */
-    DpCommandConfirmation & operator = (DpCommandConfirmation && o) noexcept
-    {
-        if (this != &o) {
-            Cleanup();
-            // Transfer members values
-            mPtr = std::move(o.mPtr);
-            mOwned = o.mOwned;
-        }
-        return *this;
-    }
-    /* --------------------------------------------------------------------------------------------
-     * Release any referenced resources and default to an empty/invalid state.
-    */
-    void Cleanup()
-    {
-        // Do we own this to try delete it?
-        if (!mOwned && mPtr) {
-            // Not our job, simply forget about it
-            [[maybe_unused]] auto p = mPtr.release();
-        } else mPtr.reset(); // We own this so delete the instance
-    }
-    /* --------------------------------------------------------------------------------------------
-     * Validate the managed handle.
-    */
-    void Validate() const { if (!mPtr) STHROWF("Invalid discord confirmation callback handle"); }
-    /* --------------------------------------------------------------------------------------------
-     * Validate the managed handle and retrieve a const reference to it.
-    */
-    SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
-    /* --------------------------------------------------------------------------------------------
-     * Check whether a valid instance is managed.
-    */
-    SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
-    /* --------------------------------------------------------------------------------------------
-     * Retrieve the raw body string of the HTTP result.
-    */
-    SQMOD_NODISCARD std::string & GetHttpBody() const { return Valid().http_info.body; }
-};
-
 } // Namespace:: SqMod

module/Library/Discord/Utilities.hpp

@@ -12,49 +12,32 @@
 // ------------------------------------------------------------------------------------------------
 namespace Sqrat {
 
-// // Allow the VM to treat the dpp::snowflake type as a integer.
+// Allow the VM to treat the dpp::snowflake type as a integer.
-// template<> struct Var<dpp::snowflake>
+template<> struct Var<dpp::snowflake>
-// {
+{
-//     dpp::snowflake value;
+    dpp::snowflake value;
-//     Var(HSQUIRRELVM vm, SQInteger idx) {
+    Var(HSQUIRRELVM vm, SQInteger idx)
-//         sq_getinteger(vm, idx, reinterpret_cast<SQInteger*>(&static_cast<uint64_t&>(value)));
+    {
-//     }
+        sq_getinteger(vm, idx, reinterpret_cast<SQInteger*>(&static_cast<uint64_t&>(value)));
-//     inline static void push(HSQUIRRELVM vm, const dpp::snowflake& value) noexcept {
-//         sq_pushinteger(vm, static_cast<SQInteger>(static_cast<uint64_t>(value)));
-//     }
-// };
-
-// // Allow the VM to treat the dpp::snowflake type as a integer.
-// template<> struct Var<const dpp::snowflake&>
-// {
-//     dpp::snowflake value;
-//     Var(HSQUIRRELVM vm, SQInteger idx) {
-//         sq_getinteger(vm, idx, reinterpret_cast<SQInteger*>(&static_cast<uint64_t&>(value)));
-//     }
-//     inline static void push(HSQUIRRELVM vm, const dpp::snowflake& value) noexcept {
-//         sq_pushinteger(vm, static_cast<SQInteger>(static_cast<uint64_t>(value)));
-//     }
-// };
-
-
-// ------------------------------------------------------------------------------------------------
-// Used to get and push dpp::snowflake instances to and from the stack
-template <> struct Var<dpp::snowflake> {
-    dpp::snowflake value; ///< The actual value of get operations
-    Var(HSQUIRRELVM vm, SQInteger idx) : value(popAsInt< uint64_t, true >(vm, idx).value) { }
-    // Push dpp::snowflake instances to the stack as integers
-    static void push(HSQUIRRELVM vm, const dpp::snowflake& value) noexcept {
-        sq_pushinteger(vm, static_cast< SQInteger >(static_cast< std::uint64_t >(value)));
     }
-    static void push(HSQUIRRELVM vm, dpp::snowflake& value) noexcept {
+    inline static void push(HSQUIRRELVM vm, const dpp::snowflake& value) noexcept
-        sq_pushinteger(vm, static_cast< SQInteger >(static_cast< std::uint64_t & >(value)));
+    {
+        sq_pushinteger(vm, static_cast<SQInteger>(static_cast<uint64_t>(value)));
     }
 };
-template <> struct Var<dpp::snowflake&> : public Var<dpp::snowflake> {
+
-    Var(HSQUIRRELVM vm, SQInteger idx) : Var<dpp::snowflake>(vm, idx) { }
+// Allow the VM to treat the dpp::snowflake type as a integer.
-};
+template<> struct Var<const dpp::snowflake&>
-template <> struct Var<const dpp::snowflake&> : public Var<dpp::snowflake> {
+{
-    Var(HSQUIRRELVM vm, SQInteger idx) : Var<dpp::snowflake>(vm, idx) { }
+    dpp::snowflake value;
+    Var(HSQUIRRELVM vm, SQInteger idx)
+    {
+        sq_getinteger(vm, idx, reinterpret_cast<SQInteger*>(&static_cast<uint64_t&>(value)));
+    }
+    inline static void push(HSQUIRRELVM vm, const dpp::snowflake& value) noexcept
+    {
+        sq_pushinteger(vm, static_cast<SQInteger>(static_cast<uint64_t>(value)));
+    }
 };
 
 }

module/Main.cpp

@@ -10,10 +10,6 @@
     #include <winsock2.h>
 #endif // SQMOD_OS_WINDOWS
 
-// ------------------------------------------------------------------------------------------------
-#include <curl/curl.h>
-#include <civetweb.h>
-
 // ------------------------------------------------------------------------------------------------
 namespace SqMod {
 
@@ -154,7 +150,6 @@ static void OnServerShutdown()
         Core::Get().EmitServerShutdown();
         // Deallocate and release everything obtained at startup
         Core::Get().Terminate(true);
-        curl_global_cleanup();
         SQMOD_SV_EV_TRACEBACK("[TRACE>] OnServerShutdown")
     }
     SQMOD_CATCH_EVENT_EXCEPTION(OnServerShutdown)
@@ -1006,8 +1001,6 @@ SQMOD_API_EXPORT unsigned int VcmpPluginInit(PluginFuncs * funcs, PluginCallback
     _Info->apiMinorVersion = PLUGIN_API_MINOR;
     // Assign the plug-in name
     std::snprintf(_Info->name, sizeof(_Info->name), "%s", SQMOD_HOST_NAME);
-    // Initialize CURL
-    curl_global_init(CURL_GLOBAL_DEFAULT);
     // Initialize third-party allocator
     gsRPMallocInit = std::make_unique< RPMallocInit >();
     // Attempt to initialize the logger before anything else

module/Sqrat/sqratTypes.h

@@ -45,28 +45,28 @@ struct popAsInt
     T value;
     popAsInt(HSQUIRRELVM vm, SQInteger idx)
     {
-        const SQObjectType value_type = sq_gettype(vm, idx);
+        SQObjectType value_type = sq_gettype(vm, idx);
         switch(value_type) {
-            case OT_BOOL:
+        case OT_BOOL:
-                SQBool sqValueb;
+            SQBool sqValueb;
-                sq_getbool(vm, idx, &sqValueb);
+            sq_getbool(vm, idx, &sqValueb);
-                value = static_cast<T>(sqValueb);
+            value = static_cast<T>(sqValueb);
             break;
-            case OT_INTEGER:
+        case OT_INTEGER:
-                SQInteger sqValue;
+            SQInteger sqValue;
-                sq_getinteger(vm, idx, &sqValue);
+            sq_getinteger(vm, idx, &sqValue);
-                value = static_cast<T>(sqValue);
+            value = static_cast<T>(sqValue);
             break;
-            case OT_FLOAT:
+        case OT_FLOAT:
-                SQFloat sqValuef;
+            SQFloat sqValuef;
-                sq_getfloat(vm, idx, &sqValuef);
+            sq_getfloat(vm, idx, &sqValuef);
-                value = static_cast<T>(static_cast<SQInteger>(sqValuef));
+			value = static_cast<T>(static_cast<int>(sqValuef));
             break;
-            default:
+        default:
-                SQTHROW(vm, FormatTypeError(vm, idx, _SC("integer")));
+            SQTHROW(vm, FormatTypeError(vm, idx, _SC("integer")));
-                value = static_cast<T>(0);
+            value = static_cast<T>(0);
             break;
-            }
+        }
     }
 };
 
@@ -86,26 +86,26 @@ struct popAsFloat
     T value;
     popAsFloat(HSQUIRRELVM vm, SQInteger idx)
     {
-        const SQObjectType value_type = sq_gettype(vm, idx);
+        SQObjectType value_type = sq_gettype(vm, idx);
         switch(value_type) {
-            case OT_BOOL:
+        case OT_BOOL:
-                SQBool sqValueb;
+            SQBool sqValueb;
-                sq_getbool(vm, idx, &sqValueb);
+            sq_getbool(vm, idx, &sqValueb);
-                value = static_cast<T>(sqValueb);
+            value = static_cast<T>(sqValueb);
             break;
-            case OT_INTEGER:
+        case OT_INTEGER:
-                SQInteger sqValue; \
+            SQInteger sqValue; \
-                sq_getinteger(vm, idx, &sqValue);
+            sq_getinteger(vm, idx, &sqValue);
-                value = static_cast<T>(sqValue);
+            value = static_cast<T>(sqValue);
             break;
-            case OT_FLOAT:
+        case OT_FLOAT:
-                SQFloat sqValuef;
+            SQFloat sqValuef;
-                sq_getfloat(vm, idx, &sqValuef);
+            sq_getfloat(vm, idx, &sqValuef);
-                value = static_cast<T>(sqValuef);
+            value = static_cast<T>(sqValuef);
             break;
-            default:
+        default:
-                SQTHROW(vm, FormatTypeError(vm, idx, _SC("float")));
+            SQTHROW(vm, FormatTypeError(vm, idx, _SC("float")));
-                value = 0;
+            value = 0;
             break;
         }
     }

vendor/CMakeLists.txt

@@ -72,8 +72,6 @@ set(BUILD_STATIC ON CACHE INTERNAL "" FORCE)
 if (WIN32 OR MINGW)
     set(ZMQ_HAVE_IPC OFF CACHE INTERNAL "" FORCE)
 endif()
-set(ENABLE_CURVE OFF CACHE INTERNAL "" FORCE)
-set(WITH_LIBSODIUM OFF CACHE INTERNAL "" FORCE)
 add_subdirectory(ZMQ)
 if(ENABLE_DISCORD)
     set(BUILD_TESTING OFF CACHE INTERNAL "" FORCE)

vendor/CPR/CMakeLists.txt

@@ -1,84 +1,52 @@
 # Create the CPR library
 add_library(CPR STATIC
     # Source files
+    cpr/auth.cpp
+    cpr/bearer.cpp
+    cpr/cookies.cpp
+    cpr/cprtypes.cpp
+    cpr/curl_container.cpp
+    cpr/curlholder.cpp
     cpr/error.cpp
-    cpr/file.cpp
-    cpr/interceptor.cpp
     cpr/multipart.cpp
-    cpr/multiperform.cpp
     cpr/parameters.cpp
     cpr/payload.cpp
     cpr/proxies.cpp
     cpr/proxyauth.cpp
     cpr/redirect.cpp
-    cpr/response.cpp
     cpr/session.cpp
-    cpr/ssl_ctx.cpp
-    cpr/threadpool.cpp
     cpr/timeout.cpp
     cpr/unix_socket.cpp
     cpr/util.cpp
-    cpr/accept_encoding.cpp
+    cpr/response.cpp
-    cpr/async.cpp
+    # Header files
-    cpr/auth.cpp
+    include/cpr/api.h
-    cpr/bearer.cpp
+    include/cpr/auth.h
-    cpr/callback.cpp
-    cpr/cert_info.cpp
-    cpr/cookies.cpp
-    cpr/cprtypes.cpp
-    cpr/curl_container.cpp
-    cpr/curlholder.cpp
-    cpr/curlmultiholder.cpp
-    # Header Files
     include/cpr/bearer.h
     include/cpr/body.h
-    include/cpr/buffer.h
-    include/cpr/callback.h
-    include/cpr/cert_info.h
-    include/cpr/connect_timeout.h
     include/cpr/cookies.h
     include/cpr/cpr.h
     include/cpr/cprtypes.h
-    include/cpr/curl_container.h
     include/cpr/curlholder.h
-    include/cpr/curlmultiholder.h
+    include/cpr/curlholder.h
+    include/cpr/digest.h
     include/cpr/error.h
-    include/cpr/file.h
-    include/cpr/filesystem.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/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/session.h
-    include/cpr/singleton.h
-    include/cpr/ssl_ctx.h
     include/cpr/ssl_options.h
-    include/cpr/status_codes.h
-    include/cpr/threadpool.h
     include/cpr/timeout.h
     include/cpr/unix_socket.h
-    include/cpr/user_agent.h
     include/cpr/util.h
     include/cpr/verbose.h
-    include/cpr/accept_encoding.h
-    include/cpr/api.h
-    include/cpr/async.h
-    include/cpr/async_wrapper.h
-    include/cpr/auth.h
 )
 # Library includes
 target_include_directories(CPR PRIVATE ${CMAKE_CURRENT_LIST_DIR}/cpr)
@@ -87,7 +55,7 @@ target_include_directories(CPR PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include)
 if (NOT MSVC)
     target_compile_options(CPR PRIVATE -Wno-deprecated-declarations)
 endif()
-# Find CURL
+# Find CURK
 find_package(CURL REQUIRED)
 if (CURL_FOUND)
     set(SSL_ENABLED ON CACHE INTERNAL "" FORCE)

vendor/CPR/cpr/accept_encoding.cpp

@@ -1,37 +0,0 @@
-#include "cpr/accept_encoding.h"
-
-#include <algorithm>
-#include <cassert>
-#include <initializer_list>
-#include <iterator>
-#include <numeric>
-#include <stdexcept>
-
-namespace cpr {
-
-AcceptEncoding::AcceptEncoding(const std::initializer_list<AcceptEncodingMethods>& methods) {
-    methods_.clear();
-    std::transform(methods.begin(), methods.end(), std::inserter(methods_, methods_.begin()), [&](cpr::AcceptEncodingMethods method) { return cpr::AcceptEncodingMethodsStringMap.at(method); });
-}
-
-AcceptEncoding::AcceptEncoding(const std::initializer_list<std::string>& string_methods) : methods_{string_methods} {}
-
-bool AcceptEncoding::empty() const noexcept {
-    return methods_.empty();
-}
-
-const std::string AcceptEncoding::getString() const {
-    return std::accumulate(std::next(methods_.begin()), methods_.end(), *methods_.begin(), [](std::string a, std::string b) { return std::move(a) + ", " + std::move(b); });
-}
-
-[[nodiscard]] bool AcceptEncoding::disabled() const {
-    if (methods_.find(cpr::AcceptEncodingMethodsStringMap.at(AcceptEncodingMethods::disabled)) != methods_.end()) {
-        if (methods_.size() != 1) {
-            throw std::invalid_argument("AcceptEncoding does not accept any other values if 'disabled' is present. You set the following encodings: " + getString());
-        }
-        return true;
-    }
-    return false;
-}
-
-} // namespace cpr

vendor/CPR/cpr/async.cpp

@@ -1,8 +0,0 @@
-#include "cpr/async.h"
-
-namespace cpr {
-
-// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-CPR_SINGLETON_IMPL(GlobalThreadPool)
-
-} // namespace cpr

vendor/CPR/cpr/auth.cpp

@@ -1,16 +1,7 @@
 #include "cpr/auth.h"
-#include "cpr/util.h"
 
 namespace cpr {
-Authentication::~Authentication() noexcept {
-    util::secureStringClear(auth_string_);
-}
-
 const char* Authentication::GetAuthString() const noexcept {
     return auth_string_.c_str();
 }
-
-AuthMode Authentication::GetAuthMode() const noexcept {
-    return auth_mode_;
-}
 } // namespace cpr

vendor/CPR/cpr/bearer.cpp

@@ -1,14 +1,9 @@
 #include "cpr/bearer.h"
-#include "cpr/util.h"
 
 namespace cpr {
 // Only supported with libcurl >= 7.61.0.
 // As an alternative use SetHeader and add the token manually.
 #if LIBCURL_VERSION_NUM >= 0x073D00
-Bearer::~Bearer() noexcept {
-    util::secureStringClear(token_string_);
-}
-
 const char* Bearer::GetToken() const noexcept {
     return token_string_.c_str();
 }

vendor/CPR/cpr/callback.cpp

@@ -1,14 +0,0 @@
-#include <cpr/callback.h>
-#include <curl/curl.h>
-#include <functional>
-
-namespace cpr {
-
-void CancellationCallback::SetProgressCallback(ProgressCallback& u_cb) {
-    user_cb.emplace(std::reference_wrapper{u_cb});
-}
-bool CancellationCallback::operator()(cpr_pf_arg_t dltotal, cpr_pf_arg_t dlnow, cpr_pf_arg_t ultotal, cpr_pf_arg_t ulnow) const {
-    const bool cont_operation{!cancellation_state->load()};
-    return user_cb ? (cont_operation && (*user_cb)(dltotal, dlnow, ultotal, ulnow)) : cont_operation;
-}
-} // namespace cpr

vendor/CPR/cpr/cert_info.cpp

@@ -1,43 +0,0 @@
-#include "cpr/cert_info.h"
-
-namespace cpr {
-
-std::string& CertInfo::operator[](const size_t& pos) {
-    return cert_info_[pos];
-}
-
-CertInfo::iterator CertInfo::begin() {
-    return cert_info_.begin();
-}
-CertInfo::iterator CertInfo::end() {
-    return cert_info_.end();
-}
-
-CertInfo::const_iterator CertInfo::begin() const {
-    return cert_info_.begin();
-}
-
-CertInfo::const_iterator CertInfo::end() const {
-    return cert_info_.end();
-}
-
-CertInfo::const_iterator CertInfo::cbegin() const {
-    return cert_info_.cbegin();
-}
-
-CertInfo::const_iterator CertInfo::cend() const {
-    return cert_info_.cend();
-}
-
-void CertInfo::emplace_back(const std::string& str) {
-    cert_info_.emplace_back(str);
-}
-
-void CertInfo::push_back(const std::string& str) {
-    cert_info_.push_back(str);
-}
-
-void CertInfo::pop_back() {
-    cert_info_.pop_back();
-}
-} // namespace cpr

vendor/CPR/cpr/cookies.cpp

@@ -1,106 +1,51 @@
 #include "cpr/cookies.h"
-#include <ctime>
-#include <iomanip>
 
 namespace cpr {
-const std::string Cookie::GetDomain() const {
+std::string Cookies::GetEncoded(const CurlHolder& holder) const {
-    return domain_;
-}
-
-bool Cookie::IsIncludingSubdomains() const {
-    return includeSubdomains_;
-}
-
-const std::string Cookie::GetPath() const {
-    return path_;
-}
-
-bool Cookie::IsHttpsOnly() const {
-    return httpsOnly_;
-}
-
-const std::chrono::system_clock::time_point Cookie::GetExpires() const {
-    return expires_;
-}
-
-const std::string Cookie::GetExpiresString() const {
-    std::stringstream ss;
-    std::tm tm{};
-    const std::time_t tt = std::chrono::system_clock::to_time_t(expires_);
-#ifdef _WIN32
-    gmtime_s(&tm, &tt);
-#else
-    gmtime_r(&tt, &tm);
-#endif
-    ss << std::put_time(&tm, "%a, %d %b %Y %H:%M:%S GMT");
-    return ss.str();
-}
-
-const std::string Cookie::GetName() const {
-    return name_;
-}
-
-const std::string Cookie::GetValue() const {
-    return value_;
-}
-
-const std::string Cookies::GetEncoded(const CurlHolder& holder) const {
     std::stringstream stream;
-    for (const cpr::Cookie& item : cookies_) {
+    for (const std::pair<const std::string, std::string>& item : map_) {
         // Depending on if encoding is set to "true", we will URL-encode cookies
-        stream << (encode ? holder.urlEncode(item.GetName()) : item.GetName()) << "=";
+        stream << (encode ? holder.urlEncode(item.first) : item.first) << "=";
 
         // special case version 1 cookies, which can be distinguished by
         // beginning and trailing quotes
-        if (!item.GetValue().empty() && item.GetValue().front() == '"' && item.GetValue().back() == '"') {
+        if (!item.second.empty() && item.second.front() == '"' && item.second.back() == '"') {
-            stream << item.GetValue();
+            stream << item.second;
         } else {
             // Depending on if encoding is set to "true", we will URL-encode cookies
-            stream << (encode ? holder.urlEncode(item.GetValue()) : item.GetValue());
+            stream << (encode ? holder.urlEncode(item.second) : item.second);
         }
         stream << "; ";
     }
     return stream.str();
 }
 
-cpr::Cookie& Cookies::operator[](size_t pos) {
+std::string& Cookies::operator[](const std::string& key) {
-    return cookies_[pos];
+    return map_[key];
 }
 
 Cookies::iterator Cookies::begin() {
-    return cookies_.begin();
+    return map_.begin();
 }
 
 Cookies::iterator Cookies::end() {
-    return cookies_.end();
+    return map_.end();
 }
 
 Cookies::const_iterator Cookies::begin() const {
-    return cookies_.begin();
+    return map_.begin();
 }
 
 Cookies::const_iterator Cookies::end() const {
-    return cookies_.end();
+    return map_.end();
 }
 
 Cookies::const_iterator Cookies::cbegin() const {
-    return cookies_.cbegin();
+    return map_.cbegin();
 }
 
 Cookies::const_iterator Cookies::cend() const {
-    return cookies_.cend();
+    return map_.cend();
-}
-
-void Cookies::emplace_back(const Cookie& str) {
-    cookies_.emplace_back(str);
-}
-
-void Cookies::push_back(const Cookie& str) {
-    cookies_.push_back(str);
-}
-
-void Cookies::pop_back() {
-    cookies_.pop_back();
 }
 
 } // namespace cpr

vendor/CPR/cpr/cprtypes.cpp

@@ -5,6 +5,8 @@
 
 namespace cpr {
 bool CaseInsensitiveCompare::operator()(const std::string& a, const std::string& b) const noexcept {
-    return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end(), [](unsigned char ac, unsigned char bc) { return std::tolower(ac) < std::tolower(bc); });
+    return std::lexicographical_compare(
+            a.begin(), a.end(), b.begin(), b.end(),
+            [](unsigned char ac, unsigned char bc) { return std::tolower(ac) < std::tolower(bc); });
 }
 } // namespace cpr

vendor/CPR/cpr/curl_container.cpp

@@ -1,15 +1,16 @@
 #include "cpr/curl_container.h"
-#include <algorithm>
-#include <iterator>
 
 
 namespace cpr {
 template <class T>
-CurlContainer<T>::CurlContainer(const std::initializer_list<T>& containerList) : containerList_(containerList) {}
+CurlContainer<T>::CurlContainer(const std::initializer_list<T>& containerList)
+        : containerList_(containerList) {}
 
 template <class T>
 void CurlContainer<T>::Add(const std::initializer_list<T>& containerList) {
-    std::transform(containerList.begin(), containerList.end(), std::back_inserter(containerList_), [](const T& elem) { return std::move(elem); });
+    for (const T& element : containerList) {
+        containerList_.push_back(std::move(element));
+    }
 }
 
 template <class T>
@@ -25,15 +26,15 @@ const std::string CurlContainer<Parameter>::GetContent(const CurlHolder& holder)
             content += "&";
         }
 
-        const std::string escapedKey = encode ? holder.urlEncode(parameter.key) : parameter.key;
+        std::string escapedKey = encode ? holder.urlEncode(parameter.key) : parameter.key;
         if (parameter.value.empty()) {
             content += escapedKey;
         } else {
-            const std::string escapedValue = encode ? holder.urlEncode(parameter.value) : parameter.value;
+            std::string escapedValue = encode ? holder.urlEncode(parameter.value) : parameter.value;
             content += escapedKey + "=";
             content += escapedValue;
         }
-    }
+    };
 
     return content;
 }
@@ -45,7 +46,7 @@ const std::string CurlContainer<Pair>::GetContent(const CurlHolder& holder) cons
         if (!content.empty()) {
             content += "&";
         }
-        const std::string escaped = encode ? holder.urlEncode(element.value) : element.value;
+        std::string escaped = encode ? holder.urlEncode(element.value) : element.value;
         content += element.key + "=" + escaped;
     }
 

vendor/CPR/cpr/curlholder.cpp

@@ -2,6 +2,10 @@
 #include <cassert>
 
 namespace cpr {
+// It does not make sense to make a std::mutex const.
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+std::mutex CurlHolder::curl_easy_init_mutex_{};
+
 CurlHolder::CurlHolder() {
     /**
      * Allow multithreaded access to CPR by locking curl_easy_init().
@@ -10,24 +14,22 @@ CurlHolder::CurlHolder() {
      * https://curl.haxx.se/libcurl/c/curl_easy_init.html
      * https://curl.haxx.se/libcurl/c/threadsafe.html
      **/
-    curl_easy_init_mutex_().lock();
+    curl_easy_init_mutex_.lock();
-    // NOLINTNEXTLINE (cppcoreguidelines-prefer-member-initializer) since we need it to happen inside the lock
     handle = curl_easy_init();
-    curl_easy_init_mutex_().unlock();
+    curl_easy_init_mutex_.unlock();
 
     assert(handle);
 } // namespace cpr
 
 CurlHolder::~CurlHolder() {
     curl_slist_free_all(chunk);
-    curl_slist_free_all(resolveCurlList);
+    curl_formfree(formpost);
-    curl_mime_free(multipart);
     curl_easy_cleanup(handle);
 }
 
 std::string CurlHolder::urlEncode(const std::string& s) const {
     assert(handle);
-    char* output = curl_easy_escape(handle, s.c_str(), static_cast<int>(s.length()));
+    char* output = curl_easy_escape(handle, s.c_str(), s.length());
     if (output) {
         std::string result = output;
         curl_free(output);
@@ -38,7 +40,7 @@ std::string CurlHolder::urlEncode(const std::string& s) const {
 
 std::string CurlHolder::urlDecode(const std::string& s) const {
     assert(handle);
-    char* output = curl_easy_unescape(handle, s.c_str(), static_cast<int>(s.length()), nullptr);
+    char* output = curl_easy_unescape(handle, s.c_str(), s.length(), nullptr);
     if (output) {
         std::string result = output;
         curl_free(output);

vendor/CPR/cpr/curlmultiholder.cpp

@@ -1,15 +0,0 @@
-#include "cpr/curlmultiholder.h"
-
-#include <cassert>
-
-namespace cpr {
-
-CurlMultiHolder::CurlMultiHolder() : handle{curl_multi_init()} {
-    assert(handle);
-}
-
-CurlMultiHolder::~CurlMultiHolder() {
-    curl_multi_cleanup(handle);
-}
-
-} // namespace cpr

vendor/CPR/cpr/error.cpp

@@ -59,7 +59,7 @@ ErrorCode Error::getErrorCodeForCurlError(std::int32_t curl_code) {
         case CURLE_SSL_ISSUER_ERROR:
             return ErrorCode::SSL_CACERT_ERROR;
         case CURLE_TOO_MANY_REDIRECTS:
-            return ErrorCode::TOO_MANY_REDIRECTS;
+            return ErrorCode::OK;
         default:
             return ErrorCode::INTERNAL_ERROR;
     }

vendor/CPR/cpr/file.cpp

@@ -1,60 +0,0 @@
-#include "cpr/file.h"
-
-namespace cpr {
-
-Files::Files(const std::initializer_list<std::string>& p_filepaths) {
-    for (const std::string& filepath : p_filepaths) {
-        files.emplace_back(filepath);
-    }
-}
-
-Files::iterator Files::begin() {
-    return files.begin();
-}
-
-Files::iterator Files::end() {
-    return files.end();
-}
-
-Files::const_iterator Files::begin() const {
-    return files.begin();
-}
-
-Files::const_iterator Files::end() const {
-    return files.end();
-}
-
-Files::const_iterator Files::cbegin() const {
-    return files.cbegin();
-}
-
-Files::const_iterator Files::cend() const {
-    return files.cend();
-}
-
-void Files::emplace_back(const File& file) {
-    files.emplace_back(file);
-}
-
-void Files::push_back(const File& file) {
-    files.push_back(file);
-}
-
-void Files::pop_back() {
-    files.pop_back();
-}
-
-Files& Files::operator=(const Files& other) {
-    if (&other != this) {
-        files = other.files;
-    }
-    return *this;
-}
-
-Files& Files::operator=(Files&& old) noexcept {
-    if (&old != this) {
-        files = std::move(old.files);
-    }
-    return *this;
-}
-} // namespace cpr

vendor/CPR/cpr/interceptor.cpp

@@ -1,53 +0,0 @@
-#include "cpr/interceptor.h"
-
-#include <exception>
-
-namespace cpr {
-
-Response Interceptor::proceed(Session& session) {
-    return session.proceed();
-}
-
-Response Interceptor::proceed(Session& session, ProceedHttpMethod httpMethod) {
-    switch (httpMethod) {
-        case ProceedHttpMethod::DELETE_REQUEST:
-            return session.Delete();
-        case ProceedHttpMethod::GET_REQUEST:
-            return session.Get();
-        case ProceedHttpMethod::HEAD_REQUEST:
-            return session.Head();
-        case ProceedHttpMethod::OPTIONS_REQUEST:
-            return session.Options();
-        case ProceedHttpMethod::PATCH_REQUEST:
-            return session.Patch();
-        case ProceedHttpMethod::POST_REQUEST:
-            return session.Post();
-        case ProceedHttpMethod::PUT_REQUEST:
-            return session.Put();
-        default:
-            throw std::invalid_argument{"Can't proceed the session with the provided http method!"};
-    }
-}
-
-Response Interceptor::proceed(Session& session, ProceedHttpMethod httpMethod, std::ofstream& file) {
-    if (httpMethod == ProceedHttpMethod::DOWNLOAD_FILE_REQUEST) {
-        return session.Download(file);
-    }
-    throw std::invalid_argument{"std::ofstream argument is only valid for ProceedHttpMethod::DOWNLOAD_FILE!"};
-}
-
-Response Interceptor::proceed(Session& session, ProceedHttpMethod httpMethod, const WriteCallback& write) {
-    if (httpMethod == ProceedHttpMethod::DOWNLOAD_CALLBACK_REQUEST) {
-        return session.Download(write);
-    }
-    throw std::invalid_argument{"WriteCallback argument is only valid for ProceedHttpMethod::DOWNLOAD_CALLBACK!"};
-}
-
-std::vector<Response> InterceptorMulti::proceed(MultiPerform& multi) {
-    return multi.proceed();
-}
-
-void InterceptorMulti::PrepareDownloadSession(MultiPerform& multi, size_t sessions_index, const WriteCallback& write) {
-    multi.PrepareDownloadSessions(sessions_index, write);
-}
-} // namespace cpr

vendor/CPR/cpr/multipart.cpp

@@ -2,6 +2,4 @@
 
 namespace cpr {
 Multipart::Multipart(const std::initializer_list<Part>& p_parts) : parts{p_parts} {}
-Multipart::Multipart(const std::vector<Part>& p_parts) : parts{p_parts} {}
-Multipart::Multipart(const std::vector<Part>&& p_parts) : parts{p_parts} {}
 } // namespace cpr

vendor/CPR/cpr/multiperform.cpp

@@ -1,323 +0,0 @@
-#include "cpr/multiperform.h"
-
-#include "cpr/interceptor.h"
-#include "cpr/response.h"
-#include "cpr/session.h"
-#include <algorithm>
-#include <iostream>
-#include <memory>
-#include <vector>
-
-namespace cpr {
-
-MultiPerform::MultiPerform() : multicurl_(new CurlMultiHolder()) {}
-
-MultiPerform::~MultiPerform() {
-    // Unlock all sessions
-    for (const std::pair<std::shared_ptr<Session>, HttpMethod>& pair : sessions_) {
-        pair.first->isUsedInMultiPerform = false;
-    }
-}
-
-void MultiPerform::AddSession(std::shared_ptr<Session>& session, HttpMethod method) {
-    // Check if this multiperform is download only
-    if (((method != HttpMethod::DOWNLOAD_REQUEST && is_download_multi_perform) && method != HttpMethod::UNDEFINED) || (method == HttpMethod::DOWNLOAD_REQUEST && !is_download_multi_perform && !sessions_.empty())) {
-        // Currently it is not possible to mix download and non-download methods, as download needs additional parameters
-        throw std::invalid_argument("Failed to add session: Cannot mix download and non-download methods!");
-    }
-
-    // Set download only if neccessary
-    if (method == HttpMethod::DOWNLOAD_REQUEST) {
-        is_download_multi_perform = true;
-    }
-
-    // Add easy handle to multi handle
-    const CURLMcode error_code = curl_multi_add_handle(multicurl_->handle, session->curl_->handle);
-    if (error_code) {
-        std::cerr << "curl_multi_add_handle() failed, code " << static_cast<int>(error_code) << std::endl;
-        return;
-    }
-
-    // Lock session to the multihandle
-    session->isUsedInMultiPerform = true;
-
-    // Add session to sessions_
-    sessions_.emplace_back(session, method);
-}
-
-void MultiPerform::RemoveSession(const std::shared_ptr<Session>& session) {
-    // Remove easy handle from multihandle
-    const CURLMcode error_code = curl_multi_remove_handle(multicurl_->handle, session->curl_->handle);
-    if (error_code) {
-        std::cerr << "curl_multi_remove_handle() failed, code " << static_cast<int>(error_code) << std::endl;
-        return;
-    }
-
-    // Unock session
-    session->isUsedInMultiPerform = false;
-
-    // Remove session from sessions_
-    auto it = std::find_if(sessions_.begin(), sessions_.end(), [&session](const std::pair<std::shared_ptr<Session>, HttpMethod>& pair) { return session->curl_->handle == pair.first->curl_->handle; });
-    if (it == sessions_.end()) {
-        throw std::invalid_argument("Failed to find session!");
-    }
-    sessions_.erase(it);
-
-    // Reset download only if empty
-    if (sessions_.empty()) {
-        is_download_multi_perform = false;
-    }
-}
-
-std::vector<std::pair<std::shared_ptr<Session>, MultiPerform::HttpMethod>>& MultiPerform::GetSessions() {
-    return sessions_;
-}
-
-const std::vector<std::pair<std::shared_ptr<Session>, MultiPerform::HttpMethod>>& MultiPerform::GetSessions() const {
-    return sessions_;
-}
-
-void MultiPerform::DoMultiPerform() {
-    // Do multi perform until every handle has finished
-    int still_running{0};
-    do {
-        CURLMcode error_code = curl_multi_perform(multicurl_->handle, &still_running);
-        if (error_code) {
-            std::cerr << "curl_multi_perform() failed, code " << static_cast<int>(error_code) << std::endl;
-            break;
-        }
-
-        if (still_running) {
-            const int timeout_ms{250};
-            error_code = curl_multi_poll(multicurl_->handle, nullptr, 0, timeout_ms, nullptr);
-            if (error_code) {
-                std::cerr << "curl_multi_poll() failed, code " << static_cast<int>(error_code) << std::endl;
-                break;
-            }
-        }
-    } while (still_running);
-}
-
-std::vector<Response> MultiPerform::ReadMultiInfo(std::function<Response(Session&, CURLcode)>&& complete_function) {
-    // Get infos and create Response objects
-    std::vector<Response> responses;
-    struct CURLMsg* info{nullptr};
-    do {
-        int msgq = 0;
-
-        // Read info from multihandle
-        info = curl_multi_info_read(multicurl_->handle, &msgq);
-
-        if (info) {
-            // Find current session
-            auto it = std::find_if(sessions_.begin(), sessions_.end(), [&info](const std::pair<std::shared_ptr<Session>, HttpMethod>& pair) { return pair.first->curl_->handle == info->easy_handle; });
-            if (it == sessions_.end()) {
-                std::cerr << "Failed to find current session!" << std::endl;
-                break;
-            }
-            const std::shared_ptr<Session> current_session = (*it).first;
-
-            // Add response object
-            // NOLINTNEXTLINE (cppcoreguidelines-pro-type-union-access)
-            responses.push_back(complete_function(*current_session, info->data.result));
-        }
-    } while (info);
-
-    // Sort response objects to match order of added sessions
-    std::vector<Response> sorted_responses;
-    for (const std::pair<std::shared_ptr<Session>, HttpMethod>& pair : sessions_) {
-        Session& current_session = *(pair.first);
-        auto it = std::find_if(responses.begin(), responses.end(), [&current_session](const Response& response) { return current_session.curl_->handle == response.curl_->handle; });
-        const Response current_response = *it;
-        // Erase response from original vector to increase future search speed
-        responses.erase(it);
-        sorted_responses.push_back(current_response);
-    }
-
-    return sorted_responses;
-}
-
-std::vector<Response> MultiPerform::MakeRequest() {
-    if (!interceptors_.empty()) {
-        return intercept();
-    }
-
-    DoMultiPerform();
-    return ReadMultiInfo([](Session& session, CURLcode curl_error) -> Response { return session.Complete(curl_error); });
-}
-
-std::vector<Response> MultiPerform::MakeDownloadRequest() {
-    if (!interceptors_.empty()) {
-        return intercept();
-    }
-
-    DoMultiPerform();
-    return ReadMultiInfo([](Session& session, CURLcode curl_error) -> Response { return session.CompleteDownload(curl_error); });
-}
-
-void MultiPerform::PrepareSessions() {
-    for (const std::pair<std::shared_ptr<Session>, HttpMethod>& pair : sessions_) {
-        switch (pair.second) {
-            case HttpMethod::GET_REQUEST:
-                pair.first->PrepareGet();
-                break;
-            case HttpMethod::POST_REQUEST:
-                pair.first->PreparePost();
-                break;
-            case HttpMethod::PUT_REQUEST:
-                pair.first->PreparePut();
-                break;
-            case HttpMethod::DELETE_REQUEST:
-                pair.first->PrepareDelete();
-                break;
-            case HttpMethod::PATCH_REQUEST:
-                pair.first->PreparePatch();
-                break;
-            case HttpMethod::HEAD_REQUEST:
-                pair.first->PrepareHead();
-                break;
-            case HttpMethod::OPTIONS_REQUEST:
-                pair.first->PrepareOptions();
-                break;
-            default:
-                std::cerr << "PrepareSessions failed: Undefined HttpMethod or download without arguments!" << std::endl;
-                return;
-        }
-    }
-}
-
-void MultiPerform::PrepareDownloadSession(size_t sessions_index, const WriteCallback& write) {
-    const std::pair<std::shared_ptr<Session>, HttpMethod>& pair = sessions_[sessions_index];
-    switch (pair.second) {
-        case HttpMethod::DOWNLOAD_REQUEST:
-            pair.first->PrepareDownload(write);
-            break;
-        default:
-            std::cerr << "PrepareSessions failed: Undefined HttpMethod or non download method with arguments!" << std::endl;
-            return;
-    }
-}
-
-void MultiPerform::PrepareDownloadSession(size_t sessions_index, std::ofstream& file) {
-    const std::pair<std::shared_ptr<Session>, HttpMethod>& pair = sessions_[sessions_index];
-    switch (pair.second) {
-        case HttpMethod::DOWNLOAD_REQUEST:
-            pair.first->PrepareDownload(file);
-            break;
-        default:
-            std::cerr << "PrepareSessions failed: Undefined HttpMethod or non download method with arguments!" << std::endl;
-            return;
-    }
-}
-
-void MultiPerform::SetHttpMethod(HttpMethod method) {
-    for (std::pair<std::shared_ptr<Session>, HttpMethod>& pair : sessions_) {
-        pair.second = method;
-    }
-}
-
-void MultiPerform::PrepareGet() {
-    SetHttpMethod(HttpMethod::GET_REQUEST);
-    PrepareSessions();
-}
-
-void MultiPerform::PrepareDelete() {
-    SetHttpMethod(HttpMethod::DELETE_REQUEST);
-    PrepareSessions();
-}
-
-void MultiPerform::PreparePut() {
-    SetHttpMethod(HttpMethod::PUT_REQUEST);
-    PrepareSessions();
-}
-
-void MultiPerform::PreparePatch() {
-    SetHttpMethod(HttpMethod::PATCH_REQUEST);
-    PrepareSessions();
-}
-
-void MultiPerform::PrepareHead() {
-    SetHttpMethod(HttpMethod::HEAD_REQUEST);
-    PrepareSessions();
-}
-
-void MultiPerform::PrepareOptions() {
-    SetHttpMethod(HttpMethod::OPTIONS_REQUEST);
-    PrepareSessions();
-}
-
-void MultiPerform::PreparePost() {
-    SetHttpMethod(HttpMethod::POST_REQUEST);
-    PrepareSessions();
-}
-
-std::vector<Response> MultiPerform::Get() {
-    PrepareGet();
-    return MakeRequest();
-}
-
-std::vector<Response> MultiPerform::Delete() {
-    PrepareDelete();
-    return MakeRequest();
-}
-
-std::vector<Response> MultiPerform::Put() {
-    PreparePut();
-    return MakeRequest();
-}
-
-std::vector<Response> MultiPerform::Head() {
-    PrepareHead();
-    return MakeRequest();
-}
-
-std::vector<Response> MultiPerform::Options() {
-    PrepareOptions();
-    return MakeRequest();
-}
-
-std::vector<Response> MultiPerform::Patch() {
-    PreparePatch();
-    return MakeRequest();
-}
-
-std::vector<Response> MultiPerform::Post() {
-    PreparePost();
-    return MakeRequest();
-}
-
-std::vector<Response> MultiPerform::Perform() {
-    PrepareSessions();
-    return MakeRequest();
-}
-
-std::vector<Response> MultiPerform::proceed() {
-    // Check if this multiperform mixes download and non download requests
-    if (!sessions_.empty()) {
-        const bool new_is_download_multi_perform = sessions_.front().second == HttpMethod::DOWNLOAD_REQUEST;
-
-        for (const std::pair<std::shared_ptr<Session>, HttpMethod>& s : sessions_) {
-            const HttpMethod method = s.second;
-            if ((new_is_download_multi_perform && method != HttpMethod::DOWNLOAD_REQUEST) || (!new_is_download_multi_perform && method == HttpMethod::DOWNLOAD_REQUEST)) {
-                throw std::invalid_argument("Failed to proceed with session: Cannot mix download and non-download methods!");
-            }
-        }
-        is_download_multi_perform = new_is_download_multi_perform;
-    }
-
-    PrepareSessions();
-    return MakeRequest();
-}
-
-std::vector<Response> MultiPerform::intercept() {
-    // At least one interceptor exists -> Execute its intercept function
-    const std::shared_ptr<InterceptorMulti> interceptor = interceptors_.front();
-    interceptors_.pop();
-    return interceptor->intercept(*this);
-}
-
-void MultiPerform::AddInterceptor(const std::shared_ptr<InterceptorMulti>& pinterceptor) {
-    interceptors_.push(pinterceptor);
-}
-
-} // namespace cpr

vendor/CPR/cpr/parameters.cpp

@@ -1,4 +1,10 @@
 #include "cpr/parameters.h"
 
+#include <initializer_list>
+#include <string>
+
+#include "cpr/util.h"
+
 namespace cpr {
+Parameters::Parameters(const std::initializer_list<Parameter>& parameters) : CurlContainer<Parameter>(parameters) {}
 } // namespace cpr

vendor/CPR/cpr/payload.cpp

@@ -1,4 +1,10 @@
 #include "cpr/payload.h"
 
+#include <initializer_list>
+#include <string>
+
+#include "cpr/util.h"
+
 namespace cpr {
+Payload::Payload(const std::initializer_list<Pair>& pairs) : CurlContainer<Pair>(pairs) {}
 } // namespace cpr

vendor/CPR/cpr/proxies.cpp

@@ -7,8 +7,8 @@
 
 namespace cpr {
 
-Proxies::Proxies(const std::initializer_list<std::pair<const std::string, std::string>>& hosts) : hosts_{hosts} {}
+Proxies::Proxies(const std::initializer_list<std::pair<const std::string, std::string>>& hosts)
-Proxies::Proxies(const std::map<std::string, std::string>& hosts) : hosts_{hosts} {}
+        : hosts_{hosts} {}
 
 bool Proxies::has(const std::string& protocol) const {
     return hosts_.count(protocol) > 0;

vendor/CPR/cpr/proxyauth.cpp

@@ -1,30 +1,16 @@
 #include "cpr/proxyauth.h"
-#include "cpr/util.h"
 
 namespace cpr {
-EncodedAuthentication::~EncodedAuthentication() noexcept {
+const char* EncodedAuthentication::GetAuthString() const noexcept {
-    util::secureStringClear(username);
+    return auth_string_.c_str();
-    util::secureStringClear(password);
-}
-
-const std::string& EncodedAuthentication::GetUsername() const {
-    return username;
-}
-
-const std::string& EncodedAuthentication::GetPassword() const {
-    return password;
 }
 
 bool ProxyAuthentication::has(const std::string& protocol) const {
     return proxyAuth_.count(protocol) > 0;
 }
 
-const char* ProxyAuthentication::GetUsername(const std::string& protocol) {
+const char* ProxyAuthentication::operator[](const std::string& protocol) {
-    return proxyAuth_[protocol].username.c_str();
+    return proxyAuth_[protocol].GetAuthString();
-}
-
-const char* ProxyAuthentication::GetPassword(const std::string& protocol) {
-    return proxyAuth_[protocol].password.c_str();
 }
 
 } // namespace cpr

vendor/CPR/cpr/redirect.cpp

@@ -19,7 +19,7 @@ PostRedirectFlags operator~(PostRedirectFlags flag) {
 
 PostRedirectFlags& operator|=(PostRedirectFlags& lhs, PostRedirectFlags rhs) {
     lhs = static_cast<PostRedirectFlags>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
-    const uint8_t tmp = static_cast<uint8_t>(lhs);
+    uint8_t tmp = static_cast<uint8_t>(lhs);
     lhs = static_cast<PostRedirectFlags>(tmp);
     return lhs;
 }

vendor/CPR/cpr/response.cpp

@@ -1,9 +1,12 @@
 #include "cpr/response.h"
 
 namespace cpr {
-
+Response::Response(std::shared_ptr<CurlHolder> curl, std::string&& p_text,
-Response::Response(std::shared_ptr<CurlHolder> curl, std::string&& p_text, std::string&& p_header_string, Cookies&& p_cookies = Cookies{}, Error&& p_error = Error{}) : curl_(std::move(curl)), text(std::move(p_text)), cookies(std::move(p_cookies)), error(std::move(p_error)), raw_header(std::move(p_header_string)) {
+                   std::string&& p_header_string, Cookies&& p_cookies = Cookies{},
-    header = cpr::util::parseHeader(raw_header, &status_line, &reason);
+                   Error&& p_error = Error{})
+        : curl_(std::move(curl)), text(std::move(p_text)), cookies(std::move(p_cookies)),
+          error(std::move(p_error)) {
+    header = cpr::util::parseHeader(p_header_string, &status_line, &reason);
     assert(curl_);
     assert(curl_->handle);
     curl_easy_getinfo(curl_->handle, CURLINFO_RESPONSE_CODE, &status_code);
@@ -11,7 +14,7 @@ Response::Response(std::shared_ptr<CurlHolder> curl, std::string&& p_text, std::
     char* url_string{nullptr};
     curl_easy_getinfo(curl_->handle, CURLINFO_EFFECTIVE_URL, &url_string);
     url = Url(url_string);
-#if LIBCURL_VERSION_NUM >= 0x073700 // 7.55.0 
+#if LIBCURL_VERSION_NUM >= 0x073700
     curl_easy_getinfo(curl_->handle, CURLINFO_SIZE_DOWNLOAD_T, &downloaded_bytes);
     curl_easy_getinfo(curl_->handle, CURLINFO_SIZE_UPLOAD_T, &uploaded_bytes);
 #else
@@ -24,21 +27,20 @@ Response::Response(std::shared_ptr<CurlHolder> curl, std::string&& p_text, std::
     curl_easy_getinfo(curl_->handle, CURLINFO_REDIRECT_COUNT, &redirect_count);
 }
 
-std::vector<CertInfo> Response::GetCertInfos() {
+std::vector<std::string> Response::GetCertInfo() {
     assert(curl_);
     assert(curl_->handle);
     curl_certinfo* ci{nullptr};
     curl_easy_getinfo(curl_->handle, CURLINFO_CERTINFO, &ci);
 
-    std::vector<CertInfo> cert_infos;
+    std::vector<std::string> info;
+    info.resize(ci->num_of_certs);
     for (int i = 0; i < ci->num_of_certs; i++) {
-        CertInfo cert_info;
+        // No way around here.
         // NOLINTNEXTLINE (cppcoreguidelines-pro-bounds-pointer-arithmetic)
-        for (curl_slist* slist = ci->certinfo[i]; slist; slist = slist->next) {
+        info[i] = std::string{ci->certinfo[i]->data};
-            cert_info.emplace_back(std::string{slist->data});
-        }
-        cert_infos.emplace_back(cert_info);
     }
-    return cert_infos;
+
+    return info;
 }
 } // namespace cpr

vendor/CPR/cpr/ssl_ctx.cpp

@@ -1,70 +0,0 @@
-
-#include "cpr/ssl_ctx.h"
-
-#if SUPPORT_CURLOPT_SSL_CTX_FUNCTION
-
-#ifdef OPENSSL_BACKEND_USED
-
-#include <openssl/err.h>
-#include <openssl/safestack.h>
-#include <openssl/ssl.h>
-
-namespace cpr {
-
-/**
- * The ssl_ctx parameter is actually a pointer to the SSL library's SSL_CTX for OpenSSL.
- * If an error is returned from the callback no attempt to establish a connection is made and
- * the perform operation will return the callback's error code.
- *
- * 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) {
-    // Check arguments
-    if (raw_cert_buf == nullptr || sslctx == nullptr) {
-        printf("Invalid callback arguments\n");
-        return CURLE_ABORTED_BY_CALLBACK;
-    }
-
-    // Setup pointer
-    X509_STORE* store = nullptr;
-    X509* cert = nullptr;
-    BIO* bio = nullptr;
-    char* cert_buf = static_cast<char*>(raw_cert_buf);
-
-    // Create a memory BIO using the data of cert_buf.
-    // Note: It is assumed, that cert_buf is nul terminated and its length is determined by strlen.
-    bio = BIO_new_mem_buf(cert_buf, -1);
-
-    // Load the PEM formatted certicifate into an X509 structure which OpenSSL can use.
-    PEM_read_bio_X509(bio, &cert, nullptr, nullptr);
-    if (cert == nullptr) {
-        printf("PEM_read_bio_X509 failed\n");
-        return CURLE_ABORTED_BY_CALLBACK;
-    }
-
-    // Get a pointer to the current certificate verification storage
-    store = SSL_CTX_get_cert_store(static_cast<SSL_CTX*>(sslctx));
-
-    // Add the loaded certificate to the verification storage
-    const int status = X509_STORE_add_cert(store, cert);
-    if (status == 0) {
-        printf("Error adding certificate\n");
-        return CURLE_ABORTED_BY_CALLBACK;
-    }
-
-    // Decrement the reference count of the X509 structure cert and frees it up
-    X509_free(cert);
-
-    // Free the entire bio chain
-    BIO_free(bio);
-
-    // The CA certificate was loaded successfully into the verification storage
-    return CURLE_OK;
-}
-
-} // namespace cpr
-
-#endif // OPENSSL_BACKEND_USED
-
-#endif // SUPPORT_CURLOPT_SSL_CTX_FUNCTION

vendor/CPR/cpr/threadpool.cpp

@@ -1,148 +0,0 @@
-#include "cpr/threadpool.h"
-
-namespace cpr {
-
-ThreadPool::ThreadPool(size_t min_threads, size_t max_threads, std::chrono::milliseconds max_idle_ms) : min_thread_num(min_threads), max_thread_num(max_threads), max_idle_time(max_idle_ms), status(STOP), cur_thread_num(0), idle_thread_num(0) {}
-
-ThreadPool::~ThreadPool() {
-    Stop();
-}
-
-int ThreadPool::Start(size_t start_threads) {
-    if (status != STOP) {
-        return -1;
-    }
-    status = RUNNING;
-    if (start_threads < min_thread_num) {
-        start_threads = min_thread_num;
-    }
-    if (start_threads > max_thread_num) {
-        start_threads = max_thread_num;
-    }
-    for (size_t i = 0; i < start_threads; ++i) {
-        CreateThread();
-    }
-    return 0;
-}
-
-int ThreadPool::Stop() {
-    if (status == STOP) {
-        return -1;
-    }
-    status = STOP;
-    task_cond.notify_all();
-    for (auto& i : threads) {
-        if (i.thread->joinable()) {
-            i.thread->join();
-        }
-    }
-    threads.clear();
-    cur_thread_num = 0;
-    idle_thread_num = 0;
-    return 0;
-}
-
-int ThreadPool::Pause() {
-    if (status == RUNNING) {
-        status = PAUSE;
-    }
-    return 0;
-}
-
-int ThreadPool::Resume() {
-    if (status == PAUSE) {
-        status = RUNNING;
-    }
-    return 0;
-}
-
-int ThreadPool::Wait() {
-    while (true) {
-        if (status == STOP || (tasks.empty() && idle_thread_num == cur_thread_num)) {
-            break;
-        }
-        std::this_thread::yield();
-    }
-    return 0;
-}
-
-bool ThreadPool::CreateThread() {
-    if (cur_thread_num >= max_thread_num) {
-        return false;
-    }
-    std::thread* thread = new std::thread([this] {
-        bool initialRun = true;
-        while (status != STOP) {
-            while (status == PAUSE) {
-                std::this_thread::yield();
-            }
-
-            Task task;
-            {
-                std::unique_lock<std::mutex> locker(task_mutex);
-                task_cond.wait_for(locker, std::chrono::milliseconds(max_idle_time), [this]() { return status == STOP || !tasks.empty(); });
-                if (status == STOP) {
-                    return;
-                }
-                if (tasks.empty()) {
-                    if (cur_thread_num > min_thread_num) {
-                        DelThread(std::this_thread::get_id());
-                        return;
-                    }
-                    continue;
-                }
-                if (!initialRun) {
-                    --idle_thread_num;
-                }
-                task = std::move(tasks.front());
-                tasks.pop();
-            }
-            if (task) {
-                task();
-                ++idle_thread_num;
-                if (initialRun) {
-                    initialRun = false;
-                }
-            }
-        }
-    });
-    AddThread(thread);
-    return true;
-}
-
-void ThreadPool::AddThread(std::thread* thread) {
-    thread_mutex.lock();
-    ++cur_thread_num;
-    ThreadData data;
-    data.thread = std::shared_ptr<std::thread>(thread);
-    data.id = thread->get_id();
-    data.status = RUNNING;
-    data.start_time = time(nullptr);
-    data.stop_time = 0;
-    threads.emplace_back(data);
-    thread_mutex.unlock();
-}
-
-void ThreadPool::DelThread(std::thread::id id) {
-    const time_t now = time(nullptr);
-    thread_mutex.lock();
-    --cur_thread_num;
-    --idle_thread_num;
-    auto iter = threads.begin();
-    while (iter != threads.end()) {
-        if (iter->status == STOP && now > iter->stop_time) {
-            if (iter->thread->joinable()) {
-                iter->thread->join();
-                iter = threads.erase(iter);
-                continue;
-            }
-        } else if (iter->id == id) {
-            iter->status = STOP;
-            iter->stop_time = time(nullptr);
-        }
-        ++iter;
-    }
-    thread_mutex.unlock();
-}
-
-} // namespace cpr

vendor/CPR/cpr/timeout.cpp

@@ -14,12 +14,12 @@ long Timeout::Milliseconds() const {
 
     // No way around since curl uses a long here.
     // NOLINTNEXTLINE(google-runtime-int)
-    if (ms.count() > static_cast<std::chrono::milliseconds::rep>(std::numeric_limits<long>::max())) {
+    if (ms.count() > std::numeric_limits<long>::max()) {
         throw std::overflow_error("cpr::Timeout: timeout value overflow: " + std::to_string(ms.count()) + " ms.");
     }
     // No way around since curl uses a long here.
     // NOLINTNEXTLINE(google-runtime-int)
-    if (ms.count() < static_cast<std::chrono::milliseconds::rep>(std::numeric_limits<long>::min())) {
+    if (ms.count() < std::numeric_limits<long>::min()) {
         throw std::underflow_error("cpr::Timeout: timeout value underflow: " + std::to_string(ms.count()) + " ms.");
     }
 

vendor/CPR/cpr/util.cpp

@@ -3,64 +3,23 @@
 #include <algorithm>
 #include <cassert>
 #include <cctype>
-#include <chrono>
 #include <cstdint>
 #include <fstream>
 #include <iomanip>
-#include <ios>
 #include <sstream>
 #include <string>
 #include <vector>
 
-#if defined(_Win32)
+namespace cpr {
-#include <Windows.h>
+namespace util {
-#else
-#ifdef __clang__
-#pragma clang diagnostic push
-#if __has_warning("-Wreserved-macro-identifier") // Not all versions of clang support this flag like the one used on Ubuntu 18.04
-#pragma clang diagnostic ignored "-Wreserved-macro-identifier"
-#endif
-#pragma clang diagnostic ignored "-Wunused-macros"
-#endif
-// https://en.cppreference.com/w/c/string/byte/memset
-// NOLINTNEXTLINE(bugprone-reserved-identifier, cert-dcl37-c, cert-dcl51-cpp, cppcoreguidelines-macro-usage)
-#define __STDC_WANT_LIB_EXT1__ 1
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-#include <cstring>
-#endif
-
-namespace cpr::util {
-
-enum class CurlHTTPCookieField : size_t {
-    Domain = 0,
-    IncludeSubdomains,
-    Path,
-    HttpsOnly,
-    Expires,
-    Name,
-    Value,
-};
 
 Cookies parseCookies(curl_slist* raw_cookies) {
-    const int CURL_HTTP_COOKIE_SIZE = static_cast<int>(CurlHTTPCookieField::Value) + 1;
     Cookies cookies;
     for (curl_slist* nc = raw_cookies; nc; nc = nc->next) {
         std::vector<std::string> tokens = cpr::util::split(nc->data, '\t');
-        while (tokens.size() < CURL_HTTP_COOKIE_SIZE) {
+        std::string value = tokens.back();
-            tokens.emplace_back("");
+        tokens.pop_back();
-        }
+        cookies[tokens.back()] = value;
-        const std::time_t expires = static_cast<time_t>(std::stoul(tokens.at(static_cast<size_t>(CurlHTTPCookieField::Expires))));
-        cookies.emplace_back(Cookie{
-                tokens.at(static_cast<size_t>(CurlHTTPCookieField::Name)),
-                tokens.at(static_cast<size_t>(CurlHTTPCookieField::Value)),
-                tokens.at(static_cast<size_t>(CurlHTTPCookieField::Domain)),
-                isTrue(tokens.at(static_cast<size_t>(CurlHTTPCookieField::IncludeSubdomains))),
-                tokens.at(static_cast<size_t>(CurlHTTPCookieField::Path)),
-                isTrue(tokens.at(static_cast<size_t>(CurlHTTPCookieField::HttpsOnly))),
-                std::chrono::system_clock::from_time_t(expires),
-        });
     }
     return cookies;
 }
@@ -77,6 +36,7 @@ Header parseHeader(const std::string& headers, std::string* status_line, std::st
     }
 
     for (std::string& line : lines) {
+        // NOLINTNEXTLINE (cppcoreguidelines-avoid-magic-numbers)
         if (line.substr(0, 5) == "HTTP/") {
             // set the status_line if it was given
             if ((status_line != nullptr) || (reason != nullptr)) {
@@ -87,7 +47,7 @@ Header parseHeader(const std::string& headers, std::string* status_line, std::st
 
                 // set the reason if it was given
                 if (reason != nullptr) {
-                    const size_t pos1 = line.find_first_of("\t ");
+                    size_t pos1 = line.find_first_of("\t ");
                     size_t pos2 = std::string::npos;
                     if (pos1 != std::string::npos) {
                         pos2 = line.find_first_of("\t ", pos1 + 1);
@@ -102,7 +62,7 @@ Header parseHeader(const std::string& headers, std::string* status_line, std::st
         }
 
         if (line.length() > 0) {
-            const size_t found = line.find(':');
+            size_t found = line.find(':');
             if (found != std::string::npos) {
                 std::string value = line.substr(found + 1);
                 value.erase(0, value.find_first_not_of("\t "));
@@ -145,7 +105,7 @@ 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 *= nmemb;
-    file->write(ptr, static_cast<std::streamsize>(size));
+    file->write(ptr, size);
     return size;
 }
 
@@ -154,8 +114,19 @@ size_t writeUserFunction(char* ptr, size_t size, size_t nmemb, const WriteCallba
     return (*write)({ptr, size}) ? size : 0;
 }
 
-int debugUserFunction(CURL* /*handle*/, curl_infotype type, char* data, size_t size, const DebugCallback* debug) {
+#if LIBCURL_VERSION_NUM < 0x072000
-    (*debug)(static_cast<DebugCallback::InfoType>(type), std::string(data, size));
+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
+    return (*progress)(dltotal, dlnow, ultotal, ulnow) ? 0 : 1;
+}
+
+int debugUserFunction(CURL* /*handle*/, curl_infotype type, char* data, size_t size,
+                      const DebugCallback* debug) {
+    (*debug)(DebugCallback::InfoType(type), std::string(data, size));
     return 0;
 }
 
@@ -170,7 +141,7 @@ int debugUserFunction(CURL* /*handle*/, curl_infotype type, char* data, size_t s
  * std::string result = holder.urlEncode(input);
  **/
 std::string urlEncode(const std::string& s) {
-    const CurlHolder holder; // Create a temporary new holder for URL encoding
+    CurlHolder holder; // Create a temporary new holder for URL encoding
     return holder.urlEncode(s);
 }
 
@@ -185,54 +156,9 @@ std::string urlEncode(const std::string& s) {
  * std::string result = holder.urlDecode(input);
  **/
 std::string urlDecode(const std::string& s) {
-    const CurlHolder holder; // Create a temporary new holder for URL decoding
+    CurlHolder holder; // Create a temporary new holder for URL decoding
     return holder.urlDecode(s);
 }
 
-#if defined(__STDC_LIB_EXT1__)
+} // namespace util
-void secureStringClear(std::string& s) {
+} // namespace cpr
-    if (s.empty()) {
-        return;
-    }
-    memset_s(&s.front(), s.length(), 0, s.length());
-    s.clear();
-}
-#elif defined(_WIN32)
-void secureStringClear(std::string& s) {
-    if (s.empty()) {
-        return;
-    }
-    SecureZeroMemory(&s.front(), s.length());
-    s.clear();
-}
-#else
-#if defined(__clang__)
-#pragma clang optimize off // clang
-#elif defined(__GNUC__) || defined(__MINGW32__) || defined(__MINGW32__) || defined(__MINGW64__)
-#pragma GCC push_options   // g++
-#pragma GCC optimize("O0") // g++
-#endif
-void secureStringClear(std::string& s) {
-    if (s.empty()) {
-        return;
-    }
-    // NOLINTNEXTLINE (readability-container-data-pointer)
-    char* ptr = &(s[0]);
-    memset(ptr, '\0', s.length());
-    s.clear();
-}
-
-#if defined(__clang__)
-#pragma clang optimize on // clang
-#elif defined(__GNUC__) || defined(__MINGW32__) || defined(__MINGW32__) || defined(__MINGW64__)
-#pragma GCC pop_options // g++
-#endif
-#endif
-
-bool isTrue(const std::string& s) {
-    std::string temp_string{s};
-    std::transform(temp_string.begin(), temp_string.end(), temp_string.begin(), [](unsigned char c) { return std::tolower(c); });
-    return temp_string == "true";
-}
-
-} // namespace cpr::util

vendor/CPR/include/cpr/accept_encoding.h

@@ -1,41 +0,0 @@
-#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

vendor/CPR/include/cpr/api.h

@@ -7,108 +7,27 @@
 #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/multiperform.h"
+#include "cpr/ntlm.h"
 #include "cpr/payload.h"
 #include "cpr/response.h"
 #include "cpr/session.h"
-#include <cpr/filesystem.h>
+#include <utility>
 
 namespace cpr {
 
-using AsyncResponse = AsyncWrapper<Response>;
+using AsyncResponse = std::future<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) {
-    set_option_internal<false, Ts...>(session, std::forward<Ts>(ts)...);
+    std::initializer_list<int> ignore = { (session.SetOption(std::forward<Ts>(ts)), 0)... };
-}
+    (void)ignore;
-
-// 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
@@ -124,14 +43,17 @@ Response Get(Ts&&... ts) {
 // Get async methods
 template <typename... Ts>
 AsyncResponse GetAsync(Ts... ts) {
-    return cpr::async([](Ts... ts_inner) { return Get(std::move(ts_inner)...); }, std::move(ts)...);
+    return std::async(
+            std::launch::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) {
+auto GetCallback(Then then, Ts... ts) -> std::future<decltype(then(Get(std::move(ts)...)))> {
-    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Get(std::move(ts_inner)...)); }, std::move(then), 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)...);
 }
 
 // Post methods
@@ -145,14 +67,17 @@ Response Post(Ts&&... ts) {
 // Post async methods
 template <typename... Ts>
 AsyncResponse PostAsync(Ts... ts) {
-    return cpr::async([](Ts... ts_inner) { return Post(std::move(ts_inner)...); }, std::move(ts)...);
+    return std::async(
+            std::launch::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) {
+auto PostCallback(Then then, Ts... ts) -> std::future<decltype(then(Post(std::move(ts)...)))> {
-    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Post(std::move(ts_inner)...)); }, std::move(then), 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)...);
 }
 
 // Put methods
@@ -166,14 +91,17 @@ Response Put(Ts&&... ts) {
 // Put async methods
 template <typename... Ts>
 AsyncResponse PutAsync(Ts... ts) {
-    return cpr::async([](Ts... ts_inner) { return Put(std::move(ts_inner)...); }, std::move(ts)...);
+    return std::async(
+            std::launch::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) {
+auto PutCallback(Then then, Ts... ts) -> std::future<decltype(then(Put(std::move(ts)...)))> {
-    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Put(std::move(ts_inner)...)); }, std::move(then), 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)...);
 }
 
 // Head methods
@@ -187,14 +115,17 @@ Response Head(Ts&&... ts) {
 // Head async methods
 template <typename... Ts>
 AsyncResponse HeadAsync(Ts... ts) {
-    return cpr::async([](Ts... ts_inner) { return Head(std::move(ts_inner)...); }, std::move(ts)...);
+    return std::async(
+            std::launch::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) {
+auto HeadCallback(Then then, Ts... ts) -> std::future<decltype(then(Head(std::move(ts)...)))> {
-    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Head(std::move(ts_inner)...)); }, std::move(then), 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)...);
 }
 
 // Delete methods
@@ -208,14 +139,18 @@ Response Delete(Ts&&... ts) {
 // Delete async methods
 template <typename... Ts>
 AsyncResponse DeleteAsync(Ts... ts) {
-    return cpr::async([](Ts... ts_inner) { return Delete(std::move(ts_inner)...); }, std::move(ts)...);
+    return std::async(
+            std::launch::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) {
+auto DeleteCallback(Then then, Ts... ts) -> std::future<decltype(then(Delete(std::move(ts)...)))> {
-    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Delete(std::move(ts_inner)...)); }, std::move(then), 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)...);
 }
 
 // Options methods
@@ -229,14 +164,19 @@ Response Options(Ts&&... ts) {
 // Options async methods
 template <typename... Ts>
 AsyncResponse OptionsAsync(Ts... ts) {
-    return cpr::async([](Ts... ts_inner) { return Options(std::move(ts_inner)...); }, std::move(ts)...);
+    return std::async(
+            std::launch::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) {
+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)...);
+        -> 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)...);
 }
 
 // Patch methods
@@ -250,14 +190,17 @@ Response Patch(Ts&&... ts) {
 // Patch async methods
 template <typename... Ts>
 AsyncResponse PatchAsync(Ts... ts) {
-    return cpr::async([](Ts... ts_inner) { return Patch(std::move(ts_inner)...); }, std::move(ts)...);
+    return std::async(
+            std::launch::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) {
+auto PatchCallback(Then then, Ts... ts) -> std::future<decltype(then(Patch(std::move(ts)...)))> {
-    return cpr::async([](Then then_inner, Ts... ts_inner) { return then_inner(Patch(std::move(ts_inner)...)); }, std::move(then), 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)...);
 }
 
 // Download methods
@@ -268,18 +211,6 @@ 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) {
@@ -288,105 +219,6 @@ 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

vendor/CPR/include/cpr/async.h

@@ -1,50 +0,0 @@
-#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

vendor/CPR/include/cpr/async_wrapper.h

@@ -1,140 +0,0 @@
-#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

vendor/CPR/include/cpr/auth.h

@@ -7,24 +7,23 @@
 
 namespace cpr {
 
-enum class AuthMode { BASIC, DIGEST, NTLM };
-
 class Authentication {
   public:
-    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 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(const Authentication& other) = default;
     Authentication(Authentication&& old) noexcept = default;
-    ~Authentication() noexcept;
+    virtual ~Authentication() noexcept = default;
 
     Authentication& operator=(Authentication&& old) noexcept = default;
     Authentication& operator=(const Authentication& other) = default;
 
-    const char* GetAuthString() const noexcept;
+    virtual const char* GetAuthString() const noexcept;
-    AuthMode GetAuthMode() const noexcept;
 
-  private:
+  protected:
     std::string auth_string_;
-    AuthMode auth_mode_;
 };
 
 } // namespace cpr

vendor/CPR/include/cpr/bearer.h

@@ -1,8 +1,8 @@
 #ifndef CPR_BEARER_H
 #define CPR_BEARER_H
 
-#include <curl/curlver.h>
 #include <string>
+#include <curl/curlver.h>
 
 #include <utility>
 
@@ -14,10 +14,12 @@ namespace cpr {
 class Bearer {
   public:
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Bearer(std::string token) : token_string_{std::move(token)} {}
+    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(const Bearer& other) = default;
     Bearer(Bearer&& old) noexcept = default;
-    virtual ~Bearer() noexcept;
+    virtual ~Bearer() noexcept = default;
 
     Bearer& operator=(Bearer&& old) noexcept = default;
     Bearer& operator=(const Bearer& other) = default;

vendor/CPR/include/cpr/body.h

@@ -1,46 +1,24 @@
 #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() = default;
+    Body() : StringHolder<Body>() {}
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Body(std::string body) : StringHolder<Body>(std::move(body)) {}
+    Body(const std::string& body) : StringHolder<Body>(body) {}
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Body(std::string_view body) : StringHolder<Body>(body) {}
+    Body(std::string&& body) : StringHolder<Body>(std::move(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;

vendor/CPR/include/cpr/buffer.h

@@ -1,33 +0,0 @@
-#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

vendor/CPR/include/cpr/callback.h

@@ -3,9 +3,7 @@
 
 #include "cprtypes.h"
 
-#include <atomic>
 #include <functional>
-#include <optional>
 #include <utility>
 
 namespace cpr {
@@ -16,11 +14,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& buffer_size) const {
+    bool operator()(char* buffer, size_t& size) const {
-        return callback(buffer, buffer_size, userdata);
+        return callback(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;
 };
@@ -34,7 +32,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;
 };
 
@@ -47,7 +45,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;
 };
 
@@ -55,13 +53,13 @@ class ProgressCallback {
   public:
     ProgressCallback() = default;
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    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)) {}
+    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_pf_arg_t downloadTotal, cpr_pf_arg_t downloadNow, cpr_pf_arg_t uploadTotal, cpr_pf_arg_t uploadNow) const {
+    bool operator()(cpr_off_t downloadTotal, cpr_off_t downloadNow, cpr_off_t uploadTotal, cpr_off_t uploadNow) const {
         return callback(downloadTotal, downloadNow, uploadTotal, uploadNow, userdata);
     }
 
-    intptr_t userdata{};
+    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;
+    std::function<bool(size_t downloadTotal, size_t downloadNow, size_t uploadTotal, size_t uploadNow, intptr_t userdata)> callback;
 };
 
 class DebugCallback {
@@ -82,30 +80,10 @@ 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

vendor/CPR/include/cpr/cert_info.h

@@ -1,37 +0,0 @@
-#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

vendor/CPR/include/cpr/cookies.h

@@ -2,49 +2,12 @@
 #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:
@@ -62,16 +25,19 @@ class Cookies {
     bool encode{true};
 
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Cookies(bool p_encode = true) : encode{p_encode} {}
+    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} {}
+    Cookies(const std::initializer_list<std::pair<const std::string, std::string>>& pairs,
+            bool p_encode = true)
+            : encode(p_encode), map_{pairs} {}
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Cookies(const cpr::Cookie& cookie, bool p_encode = true) : encode{p_encode}, cookies_{cookie} {}
+    Cookies(const std::map<std::string, std::string>& map, bool p_encode = true)
+            : encode(p_encode), map_{map} {}
 
-    cpr::Cookie& operator[](size_t pos);
+    std::string& operator[](const std::string& key);
-    const std::string GetEncoded(const CurlHolder& holder) const;
+    std::string GetEncoded(const CurlHolder& holder) const;
 
-    using iterator = std::vector<cpr::Cookie>::iterator;
+    using iterator = std::map<std::string, std::string>::iterator;
-    using const_iterator = std::vector<cpr::Cookie>::const_iterator;
+    using const_iterator = std::map<std::string, std::string>::const_iterator;
 
     iterator begin();
     iterator end();
@@ -79,12 +45,9 @@ 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::vector<cpr::Cookie> cookies_;
+    std::map<std::string, std::string> map_;
 };
 
 } // namespace cpr

vendor/CPR/include/cpr/cpr.h

@@ -3,43 +3,12 @@
 
 #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
 

vendor/CPR/include/cpr/cprtypes.h

@@ -2,13 +2,11 @@
 #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 {
 
@@ -17,21 +15,12 @@ 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(std::string str) : str_(std::move(str)) {}
+    explicit StringHolder(const std::string& str) : str_(str) {}
-    explicit StringHolder(std::string_view str) : str_(str) {}
+    explicit StringHolder(std::string&& str) : str_(std::move(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) {
@@ -118,9 +107,9 @@ class Url : public StringHolder<Url> {
   public:
     Url() = default;
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Url(std::string url) : StringHolder<Url>(std::move(url)) {}
+    Url(const std::string& url) : StringHolder<Url>(url) {}
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Url(std::string_view url) : StringHolder<Url>(url) {}
+    Url(std::string&& url) : StringHolder<Url>(std::move(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)) {}

vendor/CPR/include/cpr/cprver.h

@@ -1,30 +0,0 @@
-#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

vendor/CPR/include/cpr/curl_container.h

@@ -12,14 +12,18 @@
 namespace cpr {
 
 struct Parameter {
-    Parameter(std::string p_key, std::string p_value) : key{std::move(p_key)}, value{std::move(p_value)} {}
+    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)} {}
 
     std::string key;
     std::string value;
 };
 
 struct Pair {
-    Pair(std::string p_key, std::string p_value) : key(std::move(p_key)), value(std::move(p_value)) {}
+    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)) {}
 
     std::string key;
     std::string value;

vendor/CPR/include/cpr/curlholder.h

@@ -17,18 +17,14 @@ 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.
-    // Avoids initalization order problems in a static build
+    // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)    
-    static std::mutex& curl_easy_init_mutex_() {
+    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_slist* resolveCurlList{nullptr};
+    struct curl_httppost* formpost{nullptr};
-    curl_mime* multipart{nullptr};
     std::array<char, CURL_ERROR_SIZE> error{};
 
     CurlHolder();

vendor/CPR/include/cpr/curlmultiholder.h

@@ -1,18 +0,0 @@
-#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

vendor/CPR/include/cpr/digest.h

@@ -0,0 +1,15 @@
+#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

vendor/CPR/include/cpr/error.h

@@ -27,7 +27,6 @@ enum class ErrorCode {
     GENERIC_SSL_ERROR,
     UNSUPPORTED_PROTOCOL,
     REQUEST_CANCELLED,
-    TOO_MANY_REDIRECTS,
     UNKNOWN_ERROR = 1000,
 };
 
@@ -38,7 +37,9 @@ 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;

vendor/CPR/include/cpr/file.h

@@ -1,59 +0,0 @@
-#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

vendor/CPR/include/cpr/filesystem.h

@@ -1,26 +0,0 @@
-#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

vendor/CPR/include/cpr/http_version.h

@@ -1,67 +0,0 @@
-#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

vendor/CPR/include/cpr/interceptor.h

@@ -1,74 +0,0 @@
-#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

vendor/CPR/include/cpr/interface.h

@@ -10,11 +10,11 @@ namespace cpr {
 
 class Interface : public StringHolder<Interface> {
   public:
-    Interface() = default;
+    Interface() : StringHolder<Interface>() {}
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Interface(std::string iface) : StringHolder<Interface>(std::move(iface)) {}
+    Interface(const std::string& iface) : StringHolder<Interface>(iface) {}
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    Interface(std::string_view iface) : StringHolder<Interface>(iface) {}
+    Interface(std::string&& iface) : StringHolder<Interface>(std::move(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

vendor/CPR/include/cpr/limit_rate.h

@@ -7,7 +7,8 @@ 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;
@@ -15,4 +16,4 @@ class LimitRate {
 
 } // namespace cpr
 
-#endif
+#endif

vendor/CPR/include/cpr/local_port.h

@@ -1,23 +0,0 @@
-#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

vendor/CPR/include/cpr/local_port_range.h

@@ -1,23 +0,0 @@
-#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

vendor/CPR/include/cpr/multipart.h

@@ -7,35 +7,69 @@
 #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::string& p_value, const std::string& p_content_type = {})
-    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} {}
+            : name{p_name}, value{p_value},
-    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} {}
+              content_type{p_content_type}, is_file{false}, is_buffer{false} {}
-    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 std::int32_t& p_value, const std::string& p_content_type = {})
-    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} {}
+            : 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} {}
 
     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};
-    size_t datalen{0};
+    // Ignored here since libcurl reqires a long:
+    // NOLINTNEXTLINE(google-runtime-int)
+    long 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;
 };

vendor/CPR/include/cpr/multiperform.h

@@ -1,137 +0,0 @@
-#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

vendor/CPR/include/cpr/ntlm.h

@@ -0,0 +1,15 @@
+#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

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) : CurlContainer<Parameter>(parameters) {}
+    Parameters(const std::initializer_list<Parameter>& parameters);
 };
 
 } // namespace cpr

vendor/CPR/include/cpr/payload.h

@@ -15,7 +15,7 @@ class Payload : public CurlContainer<Pair> {
             Add(*pair);
         }
     }
-    Payload(const std::initializer_list<Pair>& pairs) : CurlContainer<Pair>(pairs) {}
+    Payload(const std::initializer_list<Pair>& pairs);
 };
 
 } // namespace cpr

vendor/CPR/include/cpr/proxies.h

@@ -10,7 +10,6 @@ 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);

vendor/CPR/include/cpr/proxyauth.h

@@ -3,44 +3,36 @@
 
 #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() = default;
+    EncodedAuthentication() : auth_string_{""} {}
-    EncodedAuthentication(const std::string& p_username, const std::string& p_password) : username(util::urlEncode(p_username)), password(util::urlEncode(p_password)) {}
+    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(const EncodedAuthentication& other) = default;
     EncodedAuthentication(EncodedAuthentication&& old) noexcept = default;
-    virtual ~EncodedAuthentication() noexcept;
+    virtual ~EncodedAuthentication() noexcept = default;
 
     EncodedAuthentication& operator=(EncodedAuthentication&& old) noexcept = default;
     EncodedAuthentication& operator=(const EncodedAuthentication& other) = default;
 
-    [[nodiscard]] const std::string& GetUsername() const;
+    const char* GetAuthString() const noexcept;
-    [[nodiscard]] const std::string& GetPassword() const;
 
-  private:
+  protected:
-    std::string username;
+    std::string auth_string_;
-    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} {}
 
-    [[nodiscard]] bool has(const std::string& protocol) const;
+    bool has(const std::string& protocol) const;
-    const char* GetUsername(const std::string& protocol);
+    const char* operator[](const std::string& protocol);
-    const char* GetPassword(const std::string& protocol);
 
   private:
     std::map<std::string, EncodedAuthentication> proxyAuth_;

vendor/CPR/include/cpr/range.h

@@ -1,44 +0,0 @@
-#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

vendor/CPR/include/cpr/redirect.h

@@ -50,7 +50,7 @@ class Redirect {
      * Default: 50
      * https://curl.se/libcurl/c/CURLOPT_MAXREDIRS.html
      **/
-    // NOLINTNEXTLINE (google-runtime-int)
+    // NOLINTNEXTLINE (cppcoreguidelines-avoid-magic-numbers, google-runtime-int)
     long maximum{50L};
     /**
      * Follow 3xx redirects.
@@ -58,12 +58,6 @@ 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
@@ -72,12 +66,11 @@ class Redirect {
 
     Redirect() = default;
     // NOLINTNEXTLINE (google-runtime-int)
-    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){}
+    Redirect(long p_maximum, bool p_follow, PostRedirectFlags p_post_flags) : maximum(p_maximum), follow(p_follow), post_flags(p_post_flags){};
     // NOLINTNEXTLINE (google-runtime-int)
-    explicit Redirect(long p_maximum) : maximum(p_maximum){}
+    explicit Redirect(long p_maximum) : maximum(p_maximum){};
-    explicit Redirect(bool p_follow) : follow(p_follow){}
+    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){};
-    explicit Redirect(PostRedirectFlags p_post_flags) : post_flags(p_post_flags){}
 };
 } // namespace cpr
 

vendor/CPR/include/cpr/reserve_size.h

@@ -1,17 +0,0 @@
-#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

vendor/CPR/include/cpr/resolve.h

@@ -1,23 +0,0 @@
-#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

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,11 +17,8 @@
 
 namespace cpr {
 
-class MultiPerform;
-
 class Response {
   protected:
-    friend MultiPerform;
     std::shared_ptr<CurlHolder> curl_{nullptr};
 
   public:
@@ -44,8 +41,9 @@ 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);
+    Response(std::shared_ptr<CurlHolder> curl, std::string&& p_text, std::string&& p_header_string,
-    std::vector<CertInfo> GetCertInfos();
+             Cookies&& p_cookies, Error&& p_error);
+    std::vector<std::string> GetCertInfo();
     Response(const Response& other) = default;
     Response(Response&& old) noexcept = default;
     ~Response() noexcept = default;

vendor/CPR/include/cpr/session.h

@@ -3,13 +3,8 @@
 
 #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"
@@ -18,45 +13,35 @@
 #include "cpr/cookies.h"
 #include "cpr/cprtypes.h"
 #include "cpr/curlholder.h"
-#include "cpr/http_version.h"
+#include "cpr/digest.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 {
 
-using AsyncResponse = AsyncWrapper<Response>;
+class Session {
-
-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() = default;
+    ~Session();
 
-    Session& operator=(Session&& old) noexcept = default;
+    Session& operator=(Session&& old) noexcept;
     Session& operator=(const Session& other) = delete;
 
     void SetUrl(const Url& url);
@@ -67,11 +52,7 @@ class Session : public std::enable_shared_from_this<Session> {
     void SetTimeout(const Timeout& timeout);
     void SetConnectTimeout(const ConnectTimeout& timeout);
     void SetAuth(const Authentication& auth);
-// Only supported with libcurl >= 7.61.0.
+    void SetDigest(const Digest& auth);
-// 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);
@@ -81,6 +62,7 @@ class Session : public std::enable_shared_from_this<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);
@@ -96,20 +78,6 @@ class Session : public std::enable_shared_from_this<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);
@@ -124,6 +92,7 @@ class Session : public std::enable_shared_from_this<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);
@@ -134,6 +103,7 @@ class Session : public std::enable_shared_from_this<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);
@@ -149,29 +119,8 @@ class Session : public std::enable_shared_from_this<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);
@@ -182,33 +131,7 @@ class Session : public std::enable_shared_from_this<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();
@@ -217,92 +140,13 @@ class Session : public std::enable_shared_from_this<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);
 
-    void AddInterceptor(const std::shared_ptr<Interceptor>& pinterceptor);
+  protected:
-
+    class Impl;
-  private:
+    std::unique_ptr<Impl> pimpl_;
-    // 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

vendor/CPR/include/cpr/singleton.h

@@ -1,47 +0,0 @@
-#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

vendor/CPR/include/cpr/ssl_ctx.h

@@ -1,26 +0,0 @@
-#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

vendor/CPR/include/cpr/ssl_options.h

@@ -1,70 +1,67 @@
 #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_NUM >= 0x072400 // 7.36.0
+#define SUPPORT_ALPN __LIBCURL_VERSION_GTE(7, 36)
 #endif
 #ifndef SUPPORT_NPN
-#define SUPPORT_NPN LIBCURL_VERSION_NUM >= 0x072400 && LIBCURL_VERSION_NUM <= 0x078600 // 7.36.0 - 7.86.0
+#define SUPPORT_NPN __LIBCURL_VERSION_GTE(7, 36)
 #endif
 
 #ifndef SUPPORT_SSLv2
-#define SUPPORT_SSLv2 LIBCURL_VERSION_NUM <= 0x071300 // 7.19.0
+#define SUPPORT_SSLv2 __LIBCURL_VERSION_LT(7, 19)
 #endif
 #ifndef SUPPORT_SSLv3
-#define SUPPORT_SSLv3 LIBCURL_VERSION_NUM <= 0x072700 // 7.39.0
+#define SUPPORT_SSLv3 __LIBCURL_VERSION_LT(7, 39)
 #endif
 #ifndef SUPPORT_TLSv1_0
-#define SUPPORT_TLSv1_0 LIBCURL_VERSION_NUM >= 0x072200 // 7.34.0
+#define SUPPORT_TLSv1_0 __LIBCURL_VERSION_GTE(7, 34)
 #endif
 #ifndef SUPPORT_TLSv1_1
-#define SUPPORT_TLSv1_1 LIBCURL_VERSION_NUM >= 0x072200 // 7.34.0
+#define SUPPORT_TLSv1_1 __LIBCURL_VERSION_GTE(7, 34)
 #endif
 #ifndef SUPPORT_TLSv1_2
-#define SUPPORT_TLSv1_2 LIBCURL_VERSION_NUM >= 0x072200 // 7.34.0
+#define SUPPORT_TLSv1_2 __LIBCURL_VERSION_GTE(7, 34)
 #endif
 #ifndef SUPPORT_TLSv1_3
-#define SUPPORT_TLSv1_3 LIBCURL_VERSION_NUM >= 0x073400 // 7.52.0
+#define SUPPORT_TLSv1_3 __LIBCURL_VERSION_GTE(7, 52)
 #endif
 #ifndef SUPPORT_MAX_TLS_VERSION
-#define SUPPORT_MAX_TLS_VERSION LIBCURL_VERSION_NUM >= 0x073600 // 7.54.0
+#define SUPPORT_MAX_TLS_VERSION __LIBCURL_VERSION_GTE(7, 54)
 #endif
 #ifndef SUPPORT_MAX_TLSv1_1
-#define SUPPORT_MAX_TLSv1_1 LIBCURL_VERSION_NUM >= 0x073600 // 7.54.0
+#define SUPPORT_MAX_TLSv1_1 __LIBCURL_VERSION_GTE(7, 54)
 #endif
 #ifndef SUPPORT_MAX_TLSv1_2
-#define SUPPORT_MAX_TLSv1_2 LIBCURL_VERSION_NUM >= 0x073600 // 7.54.0
+#define SUPPORT_MAX_TLSv1_2 __LIBCURL_VERSION_GTE(7, 54)
 #endif
 #ifndef SUPPORT_MAX_TLSv1_3
-#define SUPPORT_MAX_TLSv1_3 LIBCURL_VERSION_NUM >= 0x073600 // 7.54.0
+#define SUPPORT_MAX_TLSv1_3 __LIBCURL_VERSION_GTE(7, 54)
 #endif
 #ifndef SUPPORT_TLSv13_CIPHERS
-#define SUPPORT_TLSv13_CIPHERS LIBCURL_VERSION_NUM >= 0x073D00 // 7.61.0
+#define SUPPORT_TLSv13_CIPHERS __LIBCURL_VERSION_GTE(7, 61)
 #endif
 #ifndef SUPPORT_SESSIONID_CACHE
-#define SUPPORT_SESSIONID_CACHE LIBCURL_VERSION_NUM >= 0x071000 // 7.16.0
+#define SUPPORT_SESSIONID_CACHE __LIBCURL_VERSION_GTE(7, 16)
 #endif
 #ifndef SUPPORT_SSL_FALSESTART
-#define SUPPORT_SSL_FALSESTART LIBCURL_VERSION_NUM >= 0x072A00 // 7.42.0
+#define SUPPORT_SSL_FALSESTART __LIBCURL_VERSION_GTE(7, 42)
 #endif
 #ifndef SUPPORT_SSL_NO_REVOKE
-#define SUPPORT_SSL_NO_REVOKE LIBCURL_VERSION_NUM >= 0x072C00 // 7.44.0
+#define SUPPORT_SSL_NO_REVOKE __LIBCURL_VERSION_GTE(7, 44)
-#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 {
@@ -88,11 +85,9 @@ namespace ssl {
 class CertFile {
   public:
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    CertFile(fs::path&& p_filename) : filename(std::move(p_filename)) {}
+    CertFile(std::string&& p_filename) : filename(std::move(p_filename)) {}
 
-    virtual ~CertFile() = default;
+    const std::string filename;
-
-    const fs::path filename;
 
     virtual const char* GetCertType() const {
         return "PEM";
@@ -104,9 +99,7 @@ using PemCert = CertFile;
 class DerCert : public CertFile {
   public:
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    DerCert(fs::path&& p_filename) : CertFile(std::move(p_filename)) {}
+    DerCert(std::string&& p_filename) : CertFile(std::move(p_filename)) {}
-
-    ~DerCert() override = default;
 
     const char* GetCertType() const override {
         return "DER";
@@ -117,16 +110,13 @@ class DerCert : public CertFile {
 class KeyFile {
   public:
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    KeyFile(fs::path&& p_filename) : filename(std::move(p_filename)) {}
+    KeyFile(std::string&& 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)) {}
 
-    virtual ~KeyFile() {
+    std::string filename;
-        util::secureStringClear(password);
-    }
-
-    fs::path filename;
     std::string password;
 
     virtual const char* GetKeyType() const {
@@ -134,39 +124,16 @@ 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(fs::path&& p_filename) : KeyFile(std::move(p_filename)) {}
+    DerKey(std::string&& 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";
@@ -310,37 +277,27 @@ struct MaxTLSv1_3 {};
 class CaInfo {
   public:
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    CaInfo(fs::path&& p_filename) : filename(std::move(p_filename)) {}
+    CaInfo(std::string&& p_filename) : filename(std::move(p_filename)) {}
 
-    fs::path filename;
+    std::string filename;
 };
 
 // specify directory holding CA certificates
 class CaPath {
   public:
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    CaPath(fs::path&& p_filename) : filename(std::move(p_filename)) {}
+    CaPath(std::string&& p_filename) : filename(std::move(p_filename)) {}
 
-    fs::path filename;
+    std::string 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(fs::path&& p_filename) : filename(std::move(p_filename)) {}
+    Crl(std::string&& p_filename) : filename(std::move(p_filename)) {}
 
-    fs::path filename;
+    std::string filename;
 };
 
 // specify ciphers to use for TLS
@@ -395,7 +352,7 @@ class SslFastStart {
 #endif
 
 class NoRevoke {
-  public:
+public:
     NoRevoke() = default;
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
     NoRevoke(bool p_enabled) : enabled(p_enabled) {}
@@ -410,14 +367,9 @@ class NoRevoke {
 } // 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;
@@ -437,14 +389,8 @@ 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
@@ -454,29 +400,15 @@ 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.string();
+        cert_file = opt.filename;
         cert_type = opt.GetCertType();
     }
     void SetOption(const ssl::KeyFile& opt) {
-        key_file = opt.filename.string();
+        key_file = opt.filename;
         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;
     }
@@ -564,18 +496,13 @@ struct SslOptions {
     }
 #endif
     void SetOption(const ssl::CaInfo& opt) {
-        ca_info = opt.filename.string();
+        ca_info = opt.filename;
     }
     void SetOption(const ssl::CaPath& opt) {
-        ca_path = opt.filename.string();
+        ca_path = opt.filename;
     }
-#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.string();
+        crl_file = opt.filename;
     }
     void SetOption(const ssl::Ciphers& opt) {
         ciphers = opt.ciphers;

vendor/CPR/include/cpr/status_codes.h

@@ -1,5 +1,5 @@
-#ifndef CPR_STATUS_CODES
+#ifndef _CPR_STATUS_CODES
-#define CPR_STATUS_CODES
+#define _CPR_STATUS_CODES
 #include <cstdint>
 namespace cpr {
 namespace status {

vendor/CPR/include/cpr/threadpool.h

@@ -1,122 +0,0 @@
-#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

vendor/CPR/include/cpr/timeout.h

@@ -12,8 +12,6 @@ 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)

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;
 

vendor/CPR/include/cpr/user_agent.h

@@ -9,11 +9,11 @@
 namespace cpr {
 class UserAgent : public StringHolder<UserAgent> {
   public:
-    UserAgent() = default;
+    UserAgent() : StringHolder<UserAgent>() {}
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    UserAgent(std::string useragent) : StringHolder<UserAgent>(std::move(useragent)) {}
+    UserAgent(const std::string& useragent) : StringHolder<UserAgent>(useragent) {}
     // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
-    UserAgent(std::string_view useragent) : StringHolder<UserAgent>(useragent) {}
+    UserAgent(std::string&& useragent) : StringHolder<UserAgent>(std::move(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) {}

vendor/CPR/include/cpr/util.h

@@ -10,36 +10,31 @@
 #include "cpr/cprtypes.h"
 #include "cpr/curlholder.h"
 
-namespace cpr::util {
+namespace cpr {
+namespace 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
-template <typename T = ProgressCallback>
+int progressUserFunction(const ProgressCallback* progress, double dltotal, double dlnow,
-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) {
+                         double ultotal, double ulnow);
-    const int cancel_retval{1};
+#else
-    static_assert(cancel_retval != CURL_PROGRESSFUNC_CONTINUE);
+int progressUserFunction(const ProgressCallback* progress, curl_off_t dltotal, curl_off_t dlnow,
-    return (*progress)(dltotal, dlnow, ultotal, ulnow) ? 0 : cancel_retval;
+                         curl_off_t ultotal, curl_off_t ulnow);
-}
+#endif
-int debugUserFunction(CURL* handle, curl_infotype type, char* data, size_t size, const DebugCallback* debug);
+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
- * Override the content of the provided string to hide sensitive data. The
+} // namespace cpr
- * 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

vendor/DPP/CMakeLists.txt

@@ -31,9 +31,7 @@ include(CheckCXXSymbolExists)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 add_compile_definitions(DPP_BUILD)
 
-set(DPP_ROOT_PATH ${CMAKE_CURRENT_SOURCE_DIR})
+file(READ "${CMAKE_CURRENT_SOURCE_DIR}/include/dpp/version.h" version_h)
-
-file(READ "${DPP_ROOT_PATH}/include/dpp/version.h" version_h)
 
 if(NOT version_h MATCHES "DPP_VERSION_SHORT ([0-9][0-9])([0-9][0-9])([0-9][0-9])")
 	message(FATAL_ERROR "Cannot get DPP_VERSION_SHORT from version.h")
@@ -45,7 +43,7 @@ math(EXPR DPP_VERSION_PATCH "${CMAKE_MATCH_3}")
 
 string(CONCAT DPP_VERSION "${DPP_VERSION_MAJOR}.${DPP_VERSION_MINOR}.${DPP_VERSION_PATCH}")
 
-set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${DPP_ROOT_PATH}/cmake/")
+set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${CMAKE_SOURCE_DIR}/cmake/")
 
 if (DPP_NO_VCPKG)
 	message("-- INFO: Explicitly disabling VCPKG as running inside the CI action.")
@@ -55,7 +53,7 @@ endif()
 
 if (WIN32 AND NOT MINGW AND BUILD_SHARED_LIBS)
 	message("-- INFO: Configuring .rc resource script")
-	configure_file("${DPP_ROOT_PATH}/src/dpp/dpp.rc.in" "${DPP_ROOT_PATH}/src/dpp/dpp.rc" NEWLINE_STYLE WIN32)
+	configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/dpp/dpp.rc.in" "${CMAKE_CURRENT_SOURCE_DIR}/src/dpp/dpp.rc" NEWLINE_STYLE WIN32)
 endif()
 
 if (NOT DPP_NO_VCPKG AND EXISTS "${_VCPKG_ROOT_DIR}")
@@ -67,7 +65,7 @@ if (NOT DPP_NO_VCPKG AND EXISTS "${_VCPKG_ROOT_DIR}")
 		HOMEPAGE_URL "https://dpp.dev/"
 		DESCRIPTION "An incredibly lightweight C++ Discord library."
 	)
-	add_subdirectory(library-vcpkg)
+	add_subdirectory(library-vcpkg)	
 else()
 	set(PROJECT_NAME "libdpp")
 	project(

vendor/DPP/buildtools/changelog.php

@@ -22,7 +22,6 @@ $categories = [
     'improvement' => '♻️ Refactoring',
     'refactor' => '♻️ Refactoring',
     'refactored' => '♻️ Refactoring',
-    'refactoring' => '♻️ Refactoring',
     'deprecated' => '♻️ Refactoring',
     'deprecate' => '♻️ Refactoring',
     'remove' => '♻️ Refactoring',

vendor/DPP/buildtools/classes/Packager/Vcpkg.php

@@ -1,287 +0,0 @@
-<?php
-
-namespace Dpp\Packager;
-
-use \RuntimeException;
-
-const GREEN = "\033[32m";
-const RED   = "\033[31m";
-const WHITE = "\033[0m";
-
-class Vcpkg
-{
-    /**
-     * @var string Git Tag
-     */
-    private string $latestTag;
-
-    /**
-     * @var string Semver version
-     */
-    private string $version;
-
-    /**
-     * @var string Path to GIT
-     */
-    private string $git;
-
-    /**
-     * @var string Path to SUDO
-     */
-    private string $sudo;
-
-    /**
-     * @var bool True when we have done the first build to get the SHA512 sum
-     */
-    private bool $firstBuildComplete = false;
-
-    /**
-     * Constructor
-     * 
-     * Examines current diretory's git repository to get latest tag and version.
-     */
-    public function __construct()
-    {
-        global $argv;
-        if (count($argv) < 2) {
-            throw new RuntimeException(RED . "Missing github repository owner and access token\n" . WHITE);
-        }
-        echo GREEN . "Starting vcpkg updater...\n" . WHITE;
-            
-        /* Get the latest tag from the version of the repository checked out by default into the action */
-        $this->latestTag = preg_replace("/\n/", "", shell_exec("git describe --tags `git rev-list --tags --max-count=1`"));
-        $this->version = preg_replace('/^v/', '', $this->getTag());
-        echo GREEN . "Latest tag: " . $this->getTag() . " version: " . $this->getVersion() . "\n" . WHITE;
-
-	$this->git = trim(`which git`);
-	$this->sudo = trim(`which sudo`);
-    }
-
-    /**
-     * Get semver version
-     *
-     * @return string
-     */
-    public function getVersion(): string
-    {
-        return $this->version;
-    }
-
-    /**
-     * Get the git tag we are building
-     * 
-     * @return string
-     */
-    public function getTag(): string
-    {
-        return $this->latestTag;
-    }
-
-    private function git(string $parameters, bool $sudo = false): void
-    {
-        system(($sudo ? $this->sudo . ' ' : '') . $this->git . ' ' . $parameters);
-    }
-
-    private function sudo(string $command): void
-    {
-        system($this->sudo . ' ' . $command);
-    }
-
-    /**
-     * Check out a repository by tag or branch name to ~/dpp,
-     * using the personal access token and username passed in as command line parameters.
-     * 
-     * @param string $tag Tag to clone
-     * @return bool false if the repository could not be cloned
-     */
-    function checkoutRepository(string $tag = ""): bool
-    {
-        global $argv;
-
-        if (empty($tag)) {
-            /* Empty tag means use the main branch */
-            $tag = `{$this->git} config --get init.defaultBranch || echo master`;
-        }
-	$repositoryUrl = 'https://' . urlencode($argv[1]) . ':' . urlencode($argv[2]) . '@github.com/brainboxdotcc/DPP';
-
-        echo GREEN . "Check out repository: $tag (user: ". $argv[1] . " branch: " . $tag . ")\n" . WHITE;
-
-        chdir(getenv('HOME'));
-        system('rm -rf ./dpp');
-        $this->git('config --global user.email "noreply@dpp.dev"');
-        $this->git('config --global user.name "DPP VCPKG Bot"');
-        $this->git('clone ' . escapeshellarg($repositoryUrl) . ' ./dpp --depth=1');
-        
-        /* This is noisy, silence it */
-	$status = chdir(getenv("HOME") . '/dpp');
-        $this->git('fetch -at 2>/dev/null');
-        $this->git('checkout ' . escapeshellarg($tag) . ' 2>/dev/null');
-	
-	return $status;
-    }
-
-    /**
-     * Create ./vcpkg/ports/dpp/vcpkg.json and return the portfile contents to
-     * build the branch that is cloned at ~/dpp
-     * 
-     * @param string $sha512 The SHA512 sum of the tagged download, or initially
-     * zero, which means that the vcpkg install command should obtain it the
-     * second time around.
-     * @return string The portfile content
-     */
-    function constructPortAndVersionFile(string $sha512 = "0"): string
-    {
-        echo GREEN . "Construct portfile for " . $this->getVersion() . ", sha512: $sha512\n" . WHITE;
-        chdir(getenv("HOME") . '/dpp');
-
-        $portFileContent = 'vcpkg_from_github(
-    OUT_SOURCE_PATH SOURCE_PATH
-    REPO brainboxdotcc/DPP
-    REF "v${VERSION}"
-    # Auto-generated by release CI action at brainboxdotcc/DPP
-    SHA512 ' . $sha512 . '
-)
-
-vcpkg_cmake_configure(
-    SOURCE_PATH "${SOURCE_PATH}"
-    DISABLE_PARALLEL_CONFIGURE
-)
-
-vcpkg_cmake_install()
-
-vcpkg_cmake_config_fixup(NO_PREFIX_CORRECTION)
-
-file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/share/dpp")
-file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include")
-
-if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
-    file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/bin" "${CURRENT_PACKAGES_DIR}/debug/bin")
-endif()
-
-file(
-    INSTALL "${SOURCE_PATH}/LICENSE"
-    DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}"
-    RENAME copyright
-)
-
-file(COPY "${CMAKE_CURRENT_LIST_DIR}/usage" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}")
-';
-        // ./vcpkg/ports/dpp/vcpkg.json
-        $versionFileContent = '{
-  "name": "dpp",
-  "version": ' . json_encode($this->getVersion()) . ',
-  "description": "D++ Extremely Lightweight C++ Discord Library.",
-  "homepage": "https://dpp.dev/",
-  "license": "Apache-2.0",
-  "supports": "((windows & !static & !uwp) | linux | osx)",
-  "dependencies": [
-    "libsodium",
-    "nlohmann-json",
-    "openssl",
-    "opus",
-    "zlib",
-    {
-      "name": "vcpkg-cmake",
-      "host": true
-    },
-    {
-      "name": "vcpkg-cmake-config",
-      "host": true
-    }
-  ]
-}';
-        echo GREEN . "Writing portfile...\n" . WHITE;
-        file_put_contents('./vcpkg/ports/dpp/vcpkg.json', $versionFileContent);
-        return $portFileContent;
-    }
-
-    /**
-     * Attempt the first build of the vcpkg port. This will always fail, as it is given
-     * an SHA512 sum of 0. When it fails the output contains the SHA512 sum, which is then
-     * extracted from the error output using a regular expression, and saved for a second
-     * attempt.
-     * @param string $portFileContent Portfile content from constructPortAndVersionFile()
-     * with an SHA512 sum of 0 passed in.
-     * @return string SHA512 sum of build output
-     */
-    function firstBuild(string $portFileContent): string
-    {
-        echo GREEN . "Starting first build\n" . WHITE;
-
-        chdir(getenv("HOME") . '/dpp');
-        echo GREEN . "Create /usr/local/share/vcpkg/ports/dpp/\n" . WHITE;
-        $this->sudo('mkdir -p /usr/local/share/vcpkg/ports/dpp/');
-        echo GREEN . "Copy vcpkg.json to /usr/local/share/vcpkg/ports/dpp/vcpkg.json\n" . WHITE;
-        $this->sudo('cp -v -R ./vcpkg/ports/dpp/vcpkg.json /usr/local/share/vcpkg/ports/dpp/vcpkg.json');
-        file_put_contents('/tmp/portfile', $portFileContent);
-        $this->sudo('cp -v -R /tmp/portfile /usr/local/share/vcpkg/ports/dpp/portfile.cmake');
-        unlink('/tmp/portfile');
-        $buildResults = shell_exec($this->sudo . ' /usr/local/share/vcpkg/vcpkg install dpp:x64-linux');
-        $matches = [];
-        if (preg_match('/Actual hash:\s+([0-9a-fA-F]+)/', $buildResults, $matches)) {
-            echo GREEN . "Obtained SHA512 for first build: " . $matches[1] . "\n" . WHITE;
-            $this->firstBuildComplete = true;
-            return $matches[1];
-        }
-        echo RED . "No SHA512 found during first build :(\n" . WHITE;
-        return '';
-    }
-
-    /**
-     * Second build using a valid SHA512 sum. This attempt should succeed, allowing us to push
-     * the changed vcpkg portfiles into the master branch, where they can be used in a PR to
-     * microsoft/vcpkg repository later.
-     * 
-     * @param string $portFileContent the contents of the portfile, containing a valid SHA512
-     * sum from the first build attempt.
-     * @return bool False if the build failed
-     */
-    function secondBuild(string $portFileContent): bool
-    {
-
-        if (!$this->firstBuildComplete) {
-            throw new RuntimeException("No SHA512 sum is available, first build has not been run!");
-        }
-
-        echo GREEN . "Executing second build\n" . WHITE;
-        echo GREEN . "Copy local port files to /usr/local/share...\n" . WHITE;
-        chdir(getenv("HOME") . '/dpp');
-        file_put_contents('./vcpkg/ports/dpp/portfile.cmake', $portFileContent);
-        $this->sudo('cp -v -R ./vcpkg/ports/dpp/vcpkg.json /usr/local/share/vcpkg/ports/dpp/vcpkg.json');
-        $this->sudo('cp -v -R ./vcpkg/ports/dpp/portfile.cmake /usr/local/share/vcpkg/ports/dpp/portfile.cmake');
-        $this->sudo('cp -v -R ./vcpkg/ports/* /usr/local/share/vcpkg/ports/');
-
-        echo GREEN . "vcpkg x-add-version...\n" . WHITE;
-        chdir('/usr/local/share/vcpkg');
-        $this->sudo('./vcpkg format-manifest ./ports/dpp/vcpkg.json');
-        /* Note: We commit this in /usr/local, but we never push it (we can't) */
-        $this->git('add .', true);
-        $this->git('commit -m "[bot] VCPKG info update"', true);
-        $this->sudo('/usr/local/share/vcpkg/vcpkg x-add-version dpp');
-
-        echo GREEN . "Copy back port files from /usr/local/share...\n" . WHITE;
-        chdir(getenv('HOME') . '/dpp');
-        system('cp -v -R /usr/local/share/vcpkg/ports/dpp/vcpkg.json ./vcpkg/ports/dpp/vcpkg.json');
-        system('cp -v -R /usr/local/share/vcpkg/versions/baseline.json ./vcpkg/versions/baseline.json');
-        system('cp -v -R /usr/local/share/vcpkg/versions/d-/dpp.json ./vcpkg/versions/d-/dpp.json');
-
-        echo GREEN . "Commit and push changes to master branch\n" . WHITE;
-        $this->git('add .');
-        $this->git('commit -m "[bot] VCPKG info update [skip ci]"');
-        $this->git('config pull.rebase false');
-        $this->git('pull');
-        $this->git('push origin master');
-
-        echo GREEN . "vcpkg install...\n" . WHITE;
-        $resultCode = 0;
-        $output = [];
-        exec($this->sudo . ' /usr/local/share/vcpkg/vcpkg install dpp:x64-linux', $output, $resultCode);
-
-        if ($resultCode != 0) {
-            echo RED . "There were build errors!\n\nBuild log:\n" . WHITE;
-            readfile("/usr/local/share/vcpkg/buildtrees/dpp/install-x64-linux-dbg-out.log");
-        }
-
-	return $resultCode == 0;
-    }
-};

vendor/DPP/buildtools/make_struct.php

@@ -42,8 +42,6 @@ $forcedReturn = [
     'message_create' => 'message',
     'message_edit' => 'message',
     'thread_create_in_forum' => 'thread',
-    'threads_get_active' => 'active_threads',
-    'user_get_cached' => 'user_identified',
 ];
 
 /* Get the contents of cluster.h into an array */
@@ -63,11 +61,8 @@ if (!$generator->checkForChanges()) {
     exit(0);
 }
 
-$lastFunc = '<none>';
-$l = 0;
 /* Scan every line of the C++ source */
 foreach ($clustercpp as $cpp) {
-    $l++;
     /* Look for declaration of function body */
     if ($state == STATE_SEARCH_FOR_FUNCTION &&
         preg_match('/^\s*void\s+cluster::([^(]+)\s*\((.*)command_completion_event_t\s*callback\s*\)/', $cpp, $matches)) {
@@ -116,15 +111,10 @@ foreach ($clustercpp as $cpp) {
             $content .= $generator->generateHeaderDef($returnType, $currentFunction, $parameters, $noDefaults, $parameterNames);
             $cppcontent .= $generator->generateCppDef($returnType, $currentFunction, $parameters, $noDefaults, $parameterNames);
         }
-	$lastFunc = $currentFunction;
         $currentFunction = $parameters = $returnType = '';
         $state = STATE_SEARCH_FOR_FUNCTION;
     }
 }
-if ($state != STATE_SEARCH_FOR_FUNCTION) {
-    die("\n\n\nBuilding headers is broken ($l) - state machine finished in the middle of function $currentFunction (previous $lastFunc) with parameters $parameters rv $returnType state=$state\n\n\n");
-}
-
 $content .= <<<EOT
 
 /* End of auto-generated definitions */

vendor/DPP/buildtools/make_vcpkg.php

@@ -1,62 +0,0 @@
-<?php
-
-/**
- * Automatic CI process for generating new vcpkg releases.
- * Based loosely on RealTimeChris's shell script version.
- * 
- * This updates the content of ./vcpkg directory within the DPP
- * repository on the master branch, which can then be diffed into
- * the microsoft/vcpkg master branch to build a PR for the new
- * release.
- * 
- * The procedure for this is:
- * 
- * 1) Generate various configuration files and put them into the
- *    systemwide vcpkg installation inside the CI container
- * 2) Attempt to build the package from the release tag,
- *    this will fail due to invalid SHA512 sum and return the
- *    correct SHA512 sum in the error output. Inability to get the
- *    SHA512 sum here will return nonzero from the script, failing
- *    the CI action.
- * 3) Capture the SHA512 from the error output, switch to master
- * 4) Copy the correct configuration into both the systemwide
- *    vcpkg install in the container, and into the vcpkg directory
- *    of master branch.
- * 5) Rerun the `vcpkg install` process again to verify it is working.
- *    A build failure here will return a nonzero return code from
- *    the script, failing the CI action.
- */
-
-require __DIR__ . '/vendor/autoload.php';
-use Dpp\Packager\Vcpkg;
-
-$vcpkg = new Vcpkg();
-
-/* Check out source for latest tag */
-if (!$vcpkg->checkoutRepository($vcpkg->getTag())) {
-    exit(1);
-}
-
-/* First run with SHA512 of 0 to gather actual value and save it */
-$sha512 = $vcpkg->firstBuild(
-    $vcpkg->constructPortAndVersionFile()
-);
-if (!empty($sha512)) {
-    /* Now check out master */
-    if (!$vcpkg->checkoutRepository()) {
-        exit(1);
-    }
-
-    /* Attempt second build with the valid SHA512 sum. Program exit
-     * status is the exit status of `vcpkg install`
-     */
-    exit(
-        $vcpkg->secondBuild(
-            $vcpkg->constructPortAndVersionFile($sha512)
-        )
-    );
-    
-}
-
-/* Error if no SHA sum could be generated */
-exit(1);

vendor/DPP/cmake/ARM64ToolChain.cmake

@@ -10,7 +10,7 @@ SET(CMAKE_LIBRARY_ARCHITECTURE aarch64-linux-gnu)
 SET(CPACK_DEBIAN_PACKAGE_ARCHITECTURE aarch64)
 SET(CPACK_RPM_PACKAGE_ARCHITECTURE aarch64)
 
-SET(RASPBERRY_ROOT_PATH ${DPP_ROOT_PATH}/arm_raspberry)
+SET(RASPBERRY_ROOT_PATH ${CMAKE_SOURCE_DIR}/arm_raspberry)
 SET(RASPBERRY_KINETIC_PATH ${RASPBERRY_ROOT_PATH}/opt/ros/kinetic)
 
 SET(CMAKE_FIND_ROOT_PATH ${RASPBERRY_ROOT_PATH} ${CATKIN_DEVEL_PREFIX})

vendor/DPP/cmake/ARMv6ToolChain.cmake

@@ -3,7 +3,7 @@ SET(CMAKE_SYSTEM_NAME Linux)
 #SET(CMAKE_SYSTEM_PROCESSOR armhf)
 
 #If you have installed cross compiler to somewhere else, please specify that path.
-SET(COMPILER_ROOT /opt/cross-pi-gcc)
+SET(COMPILER_ROOT /opt/cross-pi-gcc) 
 
 SET(CMAKE_C_COMPILER ${COMPILER_ROOT}/bin/arm-linux-gnueabihf-gcc-8.3.0)
 SET(CMAKE_CXX_COMPILER ${COMPILER_ROOT}/bin/arm-linux-gnueabihf-g++)
@@ -34,17 +34,17 @@ UNSET(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES)
 SET(CMAKE_INCLUDE_DIRECTORIES_BEFORE ON)
 INCLUDE_DIRECTORIES(
 	${COMPILER_ROOT}/arm-linux-gnueabihf/libc/usr/include
-	${COMPILER_ROOT}/arm-linux-gnueabihf/include
+	${COMPILER_ROOT}/arm-linux-gnueabihf/include 
 	${COMPILER_ROOT}/arm-linux-gnueabihf/include/c++/8.3.0
 	${COMPILER_ROOT}/arm-linux-gnueabihf/include/c++/8.3.0/arm-linux-gnueabihf
 	${COMPILER_ROOT}/lib/gcc/arm-linux-gnueabihf/8.3.0/include
 	${COMPILER_ROOT}/lib/gcc/arm-linux-gnueabihf/8.3.0/include-fixed
-	${DPP_ROOT_PATH}/rootfs/usr/include/arm-linux-gnueabihf)
+	${CMAKE_SOURCE_DIR}/rootfs/usr/include/arm-linux-gnueabihf)
 SET(CMAKE_INCLUDE_DIRECTORIES_BEFORE OFF)
 
-SET(ZLIB_LIBRARY ${DPP_ROOT_PATH}/rootfs/lib/arm-linux-gnueabihf/libz.so.1.2.11)
+SET(ZLIB_LIBRARY ${CMAKE_SOURCE_DIR}/rootfs/lib/arm-linux-gnueabihf/libz.so.1.2.11)
-SET(OPENSSL_CRYPTO_LIBRARY ${DPP_ROOT_PATH}/rootfs/usr/lib/arm-linux-gnueabihf/libcrypto.so.1.1)
+SET(OPENSSL_CRYPTO_LIBRARY ${CMAKE_SOURCE_DIR}/rootfs/usr/lib/arm-linux-gnueabihf/libcrypto.so.1.1)
-SET(OPENSSL_SSL_LIBRARY ${DPP_ROOT_PATH}/rootfs/usr/lib/arm-linux-gnueabihf/libssl.so.1.1)
+SET(OPENSSL_SSL_LIBRARY ${CMAKE_SOURCE_DIR}/rootfs/usr/lib/arm-linux-gnueabihf/libssl.so.1.1)
 
 SET(CMAKE_CXX_COMPILER_WORKS 1)
 SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -nostdinc --sysroot=${RASPBERRY_ROOT_PATH} -Wno-psabi " CACHE INTERNAL "" FORCE)
@@ -54,11 +54,11 @@ SET(CMAKE_CXX_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} --sysroot=${RASPBERRY_ROOT_PAT
 
 SET(LD_LIBRARY_PATH ${RASPBERRY_KINETIC_PATH}/lib)
 
-EXECUTE_PROCESS(COMMAND wget -P ${DPP_ROOT_PATH}/rootfs -q http://content.dpp.dev/zlib1g_1.2.11.dfsg-1_armhf.deb http://content.dpp.dev/zlib1g-dev_1.2.11.dfsg-1_armhf.deb http://content.dpp.dev/libssl1.1_1.1.1m-1_armhf.deb http://content.dpp.dev/libssl-dev_1.1.1m-1_armhf.deb https://content.dpp.dev/raspi-toolchain.tar.gz)
+EXECUTE_PROCESS(COMMAND wget -P ${CMAKE_SOURCE_DIR}/rootfs -q http://content.dpp.dev/zlib1g_1.2.11.dfsg-1_armhf.deb http://content.dpp.dev/zlib1g-dev_1.2.11.dfsg-1_armhf.deb http://content.dpp.dev/libssl1.1_1.1.1m-1_armhf.deb http://content.dpp.dev/libssl-dev_1.1.1m-1_armhf.deb https://content.dpp.dev/raspi-toolchain.tar.gz)
 
 EXECUTE_PROCESS(
-	COMMAND tar -xzf ${DPP_ROOT_PATH}/rootfs/raspi-toolchain.tar.gz -C /opt
+	COMMAND tar -xzf ${CMAKE_SOURCE_DIR}/rootfs/raspi-toolchain.tar.gz -C /opt
-	COMMAND sudo dpkg-deb -x ${DPP_ROOT_PATH}/rootfs/zlib1g-dev_1.2.11.dfsg-1_armhf.deb ${DPP_ROOT_PATH}/rootfs
+	COMMAND sudo dpkg-deb -x ${CMAKE_SOURCE_DIR}/rootfs/zlib1g-dev_1.2.11.dfsg-1_armhf.deb ${CMAKE_SOURCE_DIR}/rootfs
-	COMMAND sudo dpkg-deb -x ${DPP_ROOT_PATH}/rootfs/zlib1g_1.2.11.dfsg-1_armhf.deb ${DPP_ROOT_PATH}/rootfs
+	COMMAND sudo dpkg-deb -x ${CMAKE_SOURCE_DIR}/rootfs/zlib1g_1.2.11.dfsg-1_armhf.deb ${CMAKE_SOURCE_DIR}/rootfs
-	COMMAND sudo dpkg-deb -x ${DPP_ROOT_PATH}/rootfs/libssl-dev_1.1.1m-1_armhf.deb ${DPP_ROOT_PATH}/rootfs
+	COMMAND sudo dpkg-deb -x ${CMAKE_SOURCE_DIR}/rootfs/libssl-dev_1.1.1m-1_armhf.deb ${CMAKE_SOURCE_DIR}/rootfs
-	COMMAND sudo dpkg-deb -x ${DPP_ROOT_PATH}/rootfs/libssl1.1_1.1.1m-1_armhf.deb ${DPP_ROOT_PATH}/rootfs)
+	COMMAND sudo dpkg-deb -x ${CMAKE_SOURCE_DIR}/rootfs/libssl1.1_1.1.1m-1_armhf.deb ${CMAKE_SOURCE_DIR}/rootfs)