thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2024-11-08 08:47:17 +01:00
Code Releases Activity
ac162b0c14
SqMod/module/Library/CURL.hpp

1956 lines
66 KiB
C++
Raw Normal View History

Initial preparations for CURL and Discord integration.
2021-01-27 06:27:48 +01:00
#pragma once
// ------------------------------------------------------------------------------------------------
Initial implementation of a CURL extension. TODO: async/mt
2021-01-28 04:00:03 +01:00
#include "Base/Shared.hpp"
Initial preparations for CURL and Discord integration.
2021-01-27 06:27:48 +01:00
// ------------------------------------------------------------------------------------------------
#include <cpr/cpr.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
Initial implementation of a CURL extension. TODO: async/mt
2021-01-28 04:00:03 +01:00
/* ------------------------------------------------------------------------------------------------
* Wrapper for cpr::Options that can be bound to the script engine.
*/
struct CpSslOptions : public cpr::SslOptions
{
using Base = cpr::SslOptions;
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpSslOptions() = default;
Initial preparations for CURL and Discord integration.
2021-01-27 06:27:48 +01:00
Update CURL.hpp
2021-01-28 04:19:19 +01:00
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
CpSslOptions(const CpSslOptions &) = default;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CpSslOptions(CpSslOptions &&) noexcept = default;
Initial implementation of a CURL extension. TODO: async/mt
2021-01-28 04:00:03 +01:00
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
Update CURL.hpp
2021-01-28 04:19:19 +01:00
~CpSslOptions() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator.
*/
CpSslOptions & operator = (const CpSslOptions &) = default;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CpSslOptions & operator = (CpSslOptions &&) noexcept = default;
Initial implementation of a CURL extension. TODO: async/mt
2021-01-28 04:00:03 +01:00
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::cert_file value.
*/
const std::string & GetCertFile() const { return Base::cert_file; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::cert_file and cpr::SslOptions::cert_type values.
*/
void SetCertFile(StackStrF & type, StackStrF & file)
{
cert_file.assign(file.mPtr, file.GetSize());
cert_type.assign(type.mPtr, type.GetSize());
}
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::cert_file values.
*/
void SetPemCertFile(StackStrF & file)
{
cert_file.assign(file.mPtr, file.GetSize());
cert_type.assign("PEM");
}
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::cert_file values.
*/
void SetDerCertFile(StackStrF & file)
{
cert_file.assign(file.mPtr, file.GetSize());
cert_type.assign("DER");
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::cert_type value.
*/
const std::string & GetCertType() const { return Base::cert_type; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::cert_type values.
*/
void SetCertType(StackStrF & type) { cert_type.assign(type.mPtr, type.GetSize()); }
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::key_file value.
*/
const std::string & GetKeyFile() const { return Base::key_file; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::cert_file, cpr::SslOptions::key_pass and cpr::SslOptions::cert_type values.
*/
void SetKeyFile(StackStrF & type, StackStrF & pass, StackStrF & file)
{
key_file.assign(file.mPtr, file.GetSize());
key_type.assign(type.mPtr, type.GetSize());
key_pass.assign(pass.mPtr, pass.GetSize());
}
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::cert_file, cpr::SslOptions::key_pass values.
*/
void SetPemKeyFile(StackStrF & type, StackStrF & pass, StackStrF & file)
{
key_file.assign(file.mPtr, file.GetSize());
key_type.assign("PEM");
key_pass.assign(pass.mPtr, pass.GetSize());
}
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::cert_file, cpr::SslOptions::key_pass values.
*/
void SetDerKeyFile(StackStrF & type, StackStrF & pass, StackStrF & file)
{
key_file.assign(file.mPtr, file.GetSize());
key_type.assign("DER");
key_pass.assign(pass.mPtr, pass.GetSize());
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::key_type value.
*/
const std::string & GetKeyType() const { return Base::key_type; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::key_type values.
*/
void SetKeyType(StackStrF & type) { key_type.assign(type.mPtr, type.GetSize()); }
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::key_pass value.
*/
const std::string & GetKeyPass() const { return Base::key_pass; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::key_pass values.
*/
void SetKeyPass(StackStrF & pass) { key_pass.assign(pass.mPtr, pass.GetSize()); }
#if SUPPORT_ALPN
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::enable_alpn value.
*/
bool GetALPN() const { return Base::enable_alpn; }
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::enable_alpn value.
*/
void SetALPN(bool value) { Base::enable_alpn = value; }
#else
void GetALPN() const { STHROWF("Unsupported"); }
void SetALPN(bool) { STHROWF("Unsupported"); }
#endif // SUPPORT_ALPN
#if SUPPORT_NPN
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::enable_npn value.
*/
bool GetNPM() const { return Base::enable_npn; }
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::enable_npn value.
*/
void SetNPM(bool value) { Base::enable_npn = value; }
#else
void GetNPM() const { STHROWF("Unsupported"); }
void SetNPM(bool) { STHROWF("Unsupported"); }
#endif // SUPPORT_NPN
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::verify_host value.
*/
bool GetVerifyHost() const { return Base::verify_host; }
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::verify_host value.
*/
void SetVerifyHost(bool value) { Base::verify_host = value; }
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::verify_peer value.
*/
bool GetVerifyPeer() const { return Base::verify_peer; }
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::verify_peer value.
*/
void SetVerifyPeer(bool value) { Base::verify_peer = value; }
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::verify_status value.
*/
bool GetVerifyStatus() const { return Base::verify_status; }
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::verify_status value.
*/
void SetVerifyStatus(bool value) { Base::verify_status = value; }
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::ssl_version value.
*/
int GetSslVersion() const { return Base::ssl_version; }
#if SUPPORT_MAX_TLS_VERSION
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::max_version value.
*/
int GetMaxVersion() const { return Base::max_version; }
#else
void GetMaxVersion() const { STHROWF("Unsupported"); }
#endif // SUPPORT_MAX_TLS_VERSION
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::ca_info value.
*/
const std::string & GetCaInfo() const { return Base::ca_info; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::ca_info values.
*/
void SetCaInfo(StackStrF & info) { ca_info.assign(info.mPtr, info.GetSize()); }
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::ca_path value.
*/
const std::string & GetCaPath() const { return Base::ca_path; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::ca_path values.
*/
void SetCaPath(StackStrF & path) { ca_path.assign(path.mPtr, path.GetSize()); }
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::crl_file value.
*/
const std::string & GetCrlFile() const { return Base::crl_file; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::crl_file values.
*/
void SetCrlFile(StackStrF & file) { crl_file.assign(file.mPtr, file.GetSize()); }
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::ciphers value.
*/
const std::string & GetCiphers() const { return Base::ciphers; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::ciphers values.
*/
void SetCiphers(StackStrF & cph) { ciphers.assign(cph.mPtr, cph.GetSize()); }
#if SUPPORT_TLSv13_CIPHERS
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::tls13_ciphers value.
*/
const std::string & GetTLS13Ciphers() const { return Base::tls13_ciphers; }
/* --------------------------------------------------------------------------------------------
* Assign cpr::SslOptions::tls13_ciphers values.
*/
void SetTLS13Ciphers(StackStrF & cph) { tls13_ciphers.assign(cph.mPtr, cph.GetSize()); }
#else
void GetTLS13Ciphers() const { STHROWF("Unsupported"); }
void SetTLS13Ciphers(StackStrF &) const { STHROWF("Unsupported"); }
#endif // SUPPORT_TLSv13_CIPHERS
#if SUPPORT_SESSIONID_CACHE
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::SslOptions::session_id_cache value.
*/
bool GetSessionIdCache() const { return Base::session_id_cache; }
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::session_id_cache value.
*/
void SetSessionIdCache(bool value) { Base::session_id_cache = value; }
#else
void GetSessionIdCache() const { STHROWF("Unsupported"); }
void SetSessionIdCache(bool) const { STHROWF("Unsupported"); }
#endif // SUPPORT_SESSIONID_CACHE
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::ssl_version value.
*/
void SetTLSv1() { ssl_version = CURL_SSLVERSION_TLSv1; }
#if SUPPORT_SSLv2
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::ssl_version value.
*/
void SetSSLv2() { ssl_version = CURL_SSLVERSION_SSLv2; }
#else
void SetSSLv2() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::ssl_version value.
*/
#if SUPPORT_SSLv3
void SetSSLv3() { ssl_version = CURL_SSLVERSION_SSLv3; }
#else
void SetSSLv3() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::ssl_version value.
*/
#if SUPPORT_TLSv1_0
void SetTLSv1_0() { ssl_version = CURL_SSLVERSION_TLSv1_0; }
#else
void SetTLSv1_0() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::ssl_version value.
*/
#if SUPPORT_TLSv1_1
void SetTLSv1_1() { ssl_version = CURL_SSLVERSION_TLSv1_1; }
#else
void SetTLSv1_1() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::ssl_version value.
*/
#if SUPPORT_TLSv1_2
void SetTLSv1_2() { ssl_version = CURL_SSLVERSION_TLSv1_2; }
#else
void SetTLSv1_2() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::ssl_version value.
*/
#if SUPPORT_TLSv1_3
void SetTLSv1_3() { ssl_version = CURL_SSLVERSION_TLSv1_3; }
#else
void SetTLSv1_3() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::max_version value.
*/
#if SUPPORT_MAX_TLS_VERSION
void SetMaxTLSVersion() { max_version = CURL_SSLVERSION_DEFAULT; }
#else
void SetMaxTLSVersion() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::max_version value.
*/
#if SUPPORT_MAX_TLSv1_0
void SetMaxTLSv1_0() { max_version = CURL_SSLVERSION_MAX_TLSv1_0; }
#else
void SetMaxTLSv1_0() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::max_version value.
*/
#if SUPPORT_MAX_TLSv1_1
void SetMaxTLSv1_1() { max_version = CURL_SSLVERSION_MAX_TLSv1_1; }
#else
void SetMaxTLSv1_1() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::max_version value.
*/
#if SUPPORT_MAX_TLSv1_2
void SetMaxTLSv1_2() { max_version = CURL_SSLVERSION_MAX_TLSv1_2; }
#else
void SetMaxTLSv1_2() const { STHROWF("Unsupported"); }
#endif
/* --------------------------------------------------------------------------------------------
* Modify cpr::SslOptions::max_version value.
*/
#if SUPPORT_MAX_TLSv1_3
void SetMaxTLSv1_3() { max_version = CURL_SSLVERSION_MAX_TLSv1_3; }
#else
void SetMaxTLSv1_3() const { STHROWF("Unsupported"); }
#endif
};
/* ------------------------------------------------------------------------------------------------
* Wrapper for cpr::Error that can be bound to the script engine.
*/
struct CpError : public cpr::Error
{
using cpr::Error::Error;
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpError() = default;
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpError(SQInteger code, StackStrF & msg)
: cpr::Error(static_cast< int32_t >(code), msg.ToStr())
{
}
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit CpError(const cpr::Error & e) : cpr::Error(e) { }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit CpError(cpr::Error && e) : cpr::Error(std::move(e)) { }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
CpError(const CpError &) = default;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CpError(CpError &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CpError() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator.
*/
CpError & operator = (const CpError &) = default;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CpError & operator = (CpError &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Error::code.
*/
SQInteger GetCode() const
{
return static_cast< SQInteger >(cpr::Error::code);
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Error::code.
*/
void SetCode(SQInteger value)
{
cpr::Error::code = static_cast< cpr::ErrorCode >(value);
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Error::text.
*/
const std::string & GetMessage() const
{
return cpr::Error::message;
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Error::message.
*/
void SetMessage(StackStrF & str)
{
cpr::Error::message.assign(str.mPtr, str.GetSize());
}
};
/* ------------------------------------------------------------------------------------------------
* Wrapper for cpr::Cookies that can be bound to the script engine.
*/
struct CpCookies : public cpr::Cookies
{
using cpr::Cookies::Cookies;
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpCookies() = default;
/* --------------------------------------------------------------------------------------------
* Encode constructor.
*/
explicit CpCookies(bool enc) : cpr::Cookies(enc) { }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit CpCookies(const cpr::Cookies & e) : cpr::Cookies(e) { }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit CpCookies(cpr::Cookies && e) : cpr::Cookies(std::move(e)) { }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
CpCookies(const CpCookies &) = default;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CpCookies(CpCookies &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CpCookies() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator.
*/
CpCookies & operator = (const CpCookies &) = default;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CpCookies & operator = (CpCookies &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Retrieve the number of values.
*/
SQInteger Size() const
{
return static_cast< SQInteger >(cpr::Cookies::map_.size());
}
/* --------------------------------------------------------------------------------------------
* Check if no value is stored.
*/
bool Empty() const
{
return cpr::Cookies::map_.empty();
}
/* --------------------------------------------------------------------------------------------
* Clear all values.
*/
void Clear()
{
cpr::Cookies::map_.clear();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the number of matching values.
*/
SQInteger Count(StackStrF & key) const
{
return static_cast< SQInteger >(cpr::Cookies::map_.count(key.ToStr()));
}
/* --------------------------------------------------------------------------------------------
* Remove a value.
*/
bool Erase(StackStrF & key)
{
auto itr = cpr::Cookies::map_.find(key.ToStr());
// Does it exist?
if (itr == cpr::Cookies::map_.end())
{
return false; // Nope
}
// Erase it
cpr::Cookies::map_.erase(itr);
// Erased
return true;
}
/* --------------------------------------------------------------------------------------------
* Check if value exists.
*/
bool Has(StackStrF & key) const
{
return cpr::Cookies::map_.find(key.ToStr()) != cpr::Cookies::map_.end();
}
/* --------------------------------------------------------------------------------------------
* Retrieve value.
*/
std::string & Get(StackStrF & key)
{
auto itr = cpr::Cookies::map_.find(key.ToStr());
// Does it exist?
if (itr == cpr::Cookies::map_.end())
{
STHROWF("No cookie named: %s", key.mPtr);
}
// Return it
return itr->second;
}
/* --------------------------------------------------------------------------------------------
* Assign value.
*/
void Set(StackStrF & key, StackStrF & val)
{
cpr::Cookies::map_[key.ToStr()] = val.ToStr();
}
/* --------------------------------------------------------------------------------------------
* Iterate all values.
*/
void Each(Function & fn) const
{
for (const auto & p : cpr::Cookies::map_)
{
fn.Execute(p.first, p.second);
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all values until stopped.
*/
void While(Function & fn) const
{
for (const auto & p : cpr::Cookies::map_)
{
auto ret = fn.Eval(p.first, p.second);
// (null || true) == continue & false == break
if (!ret.IsNull() || !ret.Cast< bool >())
{
break;
}
}
}
};
/* ------------------------------------------------------------------------------------------------
* Wrapper for cpr::Header that can be bound to the script engine.
*/
struct CpHeader
{
/* --------------------------------------------------------------------------------------------
* Value container.
*/
cpr::Header mMap{};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpHeader() = default;
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit CpHeader(const cpr::Header & e) : mMap(e) { }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit CpHeader(cpr::Header && e) : mMap(std::move(e)) { }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
CpHeader(const CpHeader &) = default;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CpHeader(CpHeader &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CpHeader() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator.
*/
CpHeader & operator = (const CpHeader &) = default;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CpHeader & operator = (CpHeader &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Implicit conversion operator.
*/
operator cpr::Header & () { return mMap; } // NOLINT(google-explicit-constructor)
/* --------------------------------------------------------------------------------------------
* Implicit conversion operator.
*/
operator const cpr::Header & () const { return mMap; } // NOLINT(google-explicit-constructor)
/* --------------------------------------------------------------------------------------------
* Retrieve the number of values.
*/
SQInteger Size() const
{
return static_cast< SQInteger >(mMap.size());
}
/* --------------------------------------------------------------------------------------------
* Check if no value is stored.
*/
bool Empty() const
{
return mMap.empty();
}
/* --------------------------------------------------------------------------------------------
* Clear all values.
*/
void Clear()
{
mMap.clear();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the number of matching values.
*/
SQInteger Count(StackStrF & key) const
{
return static_cast< SQInteger >(mMap.count(key.ToStr()));
}
/* --------------------------------------------------------------------------------------------
* Remove a value.
*/
bool Erase(StackStrF & key)
{
auto itr = mMap.find(key.ToStr());
// Does it exist?
if (itr == mMap.end())
{
return false; // Nope
}
// Erase it
mMap.erase(itr);
// Erased
return true;
}
/* --------------------------------------------------------------------------------------------
* Check if value exists.
*/
bool Has(StackStrF & key) const
{
return mMap.find(key.ToStr()) != mMap.end();
}
/* --------------------------------------------------------------------------------------------
* Retrieve value.
*/
std::string & Get(StackStrF & key)
{
auto itr = mMap.find(key.ToStr());
// Does it exist?
if (itr == mMap.end())
{
STHROWF("No cookie named: %s", key.mPtr);
}
// Return it
return itr->second;
}
/* --------------------------------------------------------------------------------------------
* Assign value.
*/
void Set(StackStrF & key, StackStrF & val)
{
mMap[key.ToStr()] = val.ToStr();
}
/* --------------------------------------------------------------------------------------------
* Iterate all values.
*/
void Each(Function & fn) const
{
for (const auto & p : mMap)
{
fn.Execute(p.first, p.second);
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all values until stopped.
*/
void While(Function & fn) const
{
for (const auto & p : mMap)
{
auto ret = fn.Eval(p.first, p.second);
// (null || true) == continue & false == break
if (!ret.IsNull() || !ret.Cast< bool >())
{
break;
}
}
}
};
/* ------------------------------------------------------------------------------------------------
* Wrapper for cpr::Response that can be bound to the script engine.
*/
struct CpResponse : public cpr::Response
{
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpResponse() = default;
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit CpResponse(const cpr::Response & r) : cpr::Response(r) { }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit CpResponse(cpr::Response && r) : cpr::Response(std::move(r)) { }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
CpResponse(const CpResponse &) = default;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CpResponse(CpResponse &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CpResponse() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator.
*/
CpResponse & operator = (const CpResponse &) = default;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CpResponse & operator = (CpResponse &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Retrieve certificate information.
*/
Array GetCertInfoArray()
{
if (!cpr::Response::curl_)
{
STHROWF("Invalid response instance");
}
// Retrieve the info vector
auto vec = cpr::Response::GetCertInfo();
// Create a script array
Array arr(SqVM(), static_cast< SQInteger >(vec.size()));
// Populate the array with vector elements
for (size_t i = 0; i < vec.size(); ++i)
{
arr.SetValue(static_cast< SQInteger >(i), vec[i]);
}
// Return the array
return arr;
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::status_code.
*/
SQInteger GetStatusCode() const
{
return cpr::Response::status_code;
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::status_code.
*/
void SetStatusCode(SQInteger value)
{
cpr::Response::status_code = value;
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::text.
*/
const std::string & GetText() const
{
return cpr::Response::text;
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::text.
*/
void SetText(StackStrF & str)
{
cpr::Response::text.assign(str.mPtr, str.GetSize());
}
/* --------------------------------------------------------------------------------------------
* Steal values from cpr::Response::header.
*/
CpHeader StealHeader()
{
return CpHeader(std::move(cpr::Response::header));
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::header.
*/
CpHeader GetHeader() const
{
return CpHeader(cpr::Response::header);
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::header.
*/
void SetHeader(const CpHeader & value)
{
cpr::Response::header = value;
}
/* --------------------------------------------------------------------------------------------
* Yield values to cpr::Response::header.
*/
void YieldHeader(CpHeader & value)
{
cpr::Response::header = std::move(static_cast< cpr::Header & >(value));
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::url.
*/
const std::string & GetURL() const
{
return cpr::Response::url.str();
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::url.
*/
void SetURL(StackStrF & str)
{
cpr::Response::url = cpr::Url(str.mPtr, str.GetSize());
}
/* --------------------------------------------------------------------------------------------
* Steal values from cpr::Response::cookies.
*/
CpCookies StealCookies()
{
return CpCookies(std::move(cpr::Response::cookies));
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::cookies.
*/
CpCookies GetCookies() const
{
return CpCookies(cpr::Response::cookies);
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::cookies.
*/
void SetCookies(const CpCookies & value)
{
cpr::Response::cookies = value;
}
/* --------------------------------------------------------------------------------------------
* Yield values to cpr::Response::cookies.
*/
void YieldCookies(CpCookies & value)
{
cpr::Response::cookies = std::move(static_cast< cpr::Cookies & >(value));
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::url.
*/
CpError GetError() const
{
return CpError(cpr::Response::error);
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::url.
*/
void SetError(const CpError & e)
{
cpr::Response::error = e;
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::raw_header.
*/
const std::string & GetRawHeader() const
{
return cpr::Response::raw_header;
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::raw_header.
*/
void SetRawHeader(StackStrF & str)
{
cpr::Response::raw_header.assign(str.mPtr, str.GetSize());
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::status_line.
*/
const std::string & GetStatusLine() const
{
return cpr::Response::status_line;
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::status_line.
*/
void SetStatusLine(StackStrF & str)
{
cpr::Response::status_line.assign(str.mPtr, str.GetSize());
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::reason.
*/
const std::string & GetReason() const
{
return cpr::Response::reason;
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::reason.
*/
void SetReason(StackStrF & str)
{
cpr::Response::reason.assign(str.mPtr, str.GetSize());
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::uploaded_bytes.
*/
SQInteger GetUploadedBytes() const
{
return static_cast< SQInteger >(cpr::Response::uploaded_bytes); // possible precision loss!
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::uploaded_bytes.
*/
void SetUploadedBytes(SQInteger value)
{
cpr::Response::uploaded_bytes = static_cast< cpr::cpr_off_t >(value);
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::downloaded_bytes.
*/
SQInteger GetDownloadedBytes() const
{
return static_cast< SQInteger >(cpr::Response::downloaded_bytes); // possible precision loss!
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::downloaded_bytes.
*/
void SetDownloadedBytes(SQInteger value)
{
cpr::Response::downloaded_bytes = static_cast< cpr::cpr_off_t >(value);
}
/* --------------------------------------------------------------------------------------------
* Retrieve cpr::Response::redirect_count.
*/
SQInteger GetRedirectCount() const
{
return cpr::Response::redirect_count;
}
/* --------------------------------------------------------------------------------------------
* Modify cpr::Response::redirect_count.
*/
void SetRedirectCount(SQInteger value)
{
cpr::Response::redirect_count = static_cast< long >(value);
}
};
/* ------------------------------------------------------------------------------------------------
* Wrapper for cpr::Parameters that can be bound to the script engine.
*/
struct CpParameters : public cpr::Parameters
{
using cpr::Parameters::Parameters;
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpParameters() = default;
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit CpParameters(const cpr::Parameters & e) : cpr::Parameters(e) { }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit CpParameters(cpr::Parameters && e) : cpr::Parameters(std::move(e)) { }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
CpParameters(const CpParameters &) = default;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CpParameters(CpParameters &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CpParameters() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator.
*/
CpParameters & operator = (const CpParameters &) = default;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CpParameters & operator = (CpParameters &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Retrieve the number of values.
*/
SQInteger Size() const
{
return static_cast< SQInteger >(cpr::Parameters::containerList_.size());
}
/* --------------------------------------------------------------------------------------------
* Check if no value is stored.
*/
bool Empty() const
{
return cpr::Parameters::containerList_.empty();
}
/* --------------------------------------------------------------------------------------------
* Clear all values.
*/
void Clear()
{
cpr::Parameters::containerList_.clear();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the number of matching values.
*/
SQInteger Count(StackStrF & key) const
{
return static_cast< SQInteger >(std::count_if(
cpr::Parameters::containerList_.begin(), cpr::Parameters::containerList_.end(),
[key = key.ToStr()](const cpr::Parameter & p) { return p.key == key; }
));
}
/* --------------------------------------------------------------------------------------------
* Remove a value.
*/
SQInteger Erase(StackStrF & key)
{
const size_t n = cpr::Parameters::containerList_.size();
cpr::Parameters::containerList_.erase(std::remove_if(
cpr::Parameters::containerList_.begin(), cpr::Parameters::containerList_.end(),
[key = key.ToStr()](cpr::Parameter & p) { return p.key == key; }), cpr::Parameters::containerList_.end()
);
return static_cast< SQInteger >(n - cpr::Parameters::containerList_.size());
}
/* --------------------------------------------------------------------------------------------
* Check if value exists.
*/
bool Has(StackStrF & key) const
{
return std::find_if(
cpr::Parameters::containerList_.begin(), cpr::Parameters::containerList_.end(),
[key = key.ToStr()](const cpr::Parameter & p) { return p.key == key; }
) != cpr::Parameters::containerList_.end();
}
/* --------------------------------------------------------------------------------------------
* Retrieve value.
*/
std::string & Get(StackStrF & key)
{
auto itr = std::find_if(
cpr::Parameters::containerList_.begin(), cpr::Parameters::containerList_.end(),
[key = key.ToStr()](cpr::Parameter & p) { return p.key == key; }
);
// Does it exist?
if (itr == cpr::Parameters::containerList_.end())
{
STHROWF("No parameter named: %s", key.mPtr);
}
// Return it
return itr->value;
}
/* --------------------------------------------------------------------------------------------
* Assign value.
*/
void Set(StackStrF & key, StackStrF & val)
{
auto itr = std::find_if(
cpr::Parameters::containerList_.begin(), cpr::Parameters::containerList_.end(),
[key = key.ToStr()](cpr::Parameter & p) { return p.key == key; }
);
// Does it exist?
if (itr == cpr::Parameters::containerList_.end())
{
cpr::Parameters::containerList_.emplace_back(key.ToStr(), val.ToStr());
}
else
{
itr->value.assign(val.mPtr, val.GetSize());
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all values.
*/
void Each(Function & fn) const
{
for (const auto & p : cpr::Parameters::containerList_)
{
fn.Execute(p.key, p.value);
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all values until stopped.
*/
void While(Function & fn) const
{
for (const auto & p : cpr::Parameters::containerList_)
{
auto ret = fn.Eval(p.key, p.value);
// (null || true) == continue & false == break
if (!ret.IsNull() || !ret.Cast< bool >())
{
break;
}
}
}
};
/* ------------------------------------------------------------------------------------------------
* Wrapper for cpr::Payload that can be bound to the script engine.
*/
struct CpPayload : public cpr::Payload
{
using cpr::Payload::Payload;
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpPayload() : cpr::Payload({}) { }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit CpPayload(const cpr::Payload & e) : cpr::Payload(e) { }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit CpPayload(cpr::Payload && e) : cpr::Payload(std::move(e)) { }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
CpPayload(const CpPayload &) = default;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CpPayload(CpPayload &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CpPayload() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator.
*/
CpPayload & operator = (const CpPayload &) = default;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CpPayload & operator = (CpPayload &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Retrieve the number of values.
*/
SQInteger Size() const
{
return static_cast< SQInteger >(cpr::Payload::containerList_.size());
}
/* --------------------------------------------------------------------------------------------
* Check if no value is stored.
*/
bool Empty() const
{
return cpr::Payload::containerList_.empty();
}
/* --------------------------------------------------------------------------------------------
* Clear all values.
*/
void Clear()
{
cpr::Payload::containerList_.clear();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the number of matching values.
*/
SQInteger Count(StackStrF & key) const
{
return static_cast< SQInteger >(std::count_if(
cpr::Payload::containerList_.begin(), cpr::Payload::containerList_.end(),
[key = key.ToStr()](const cpr::Pair & p) { return p.key == key; }
));
}
/* --------------------------------------------------------------------------------------------
* Remove a value.
*/
SQInteger Erase(StackStrF & key)
{
const size_t n = cpr::Payload::containerList_.size();
cpr::Payload::containerList_.erase(std::remove_if(
cpr::Payload::containerList_.begin(), cpr::Payload::containerList_.end(),
[key = key.ToStr()](cpr::Pair & p) { return p.key == key; }), cpr::Payload::containerList_.end()
);
return static_cast< SQInteger >(n - cpr::Payload::containerList_.size());
}
/* --------------------------------------------------------------------------------------------
* Check if value exists.
*/
bool Has(StackStrF & key) const
{
return std::find_if(
cpr::Payload::containerList_.begin(), cpr::Payload::containerList_.end(),
[key = key.ToStr()](const cpr::Pair & p) { return p.key == key; }
) != cpr::Payload::containerList_.end();
}
/* --------------------------------------------------------------------------------------------
* Retrieve value.
*/
std::string & Get(StackStrF & key)
{
auto itr = std::find_if(
cpr::Payload::containerList_.begin(), cpr::Payload::containerList_.end(),
[key = key.ToStr()](cpr::Pair & p) { return p.key == key; }
);
// Does it exist?
if (itr == cpr::Payload::containerList_.end())
{
STHROWF("No Pair named: %s", key.mPtr);
}
// Return it
return itr->value;
}
/* --------------------------------------------------------------------------------------------
* Assign value.
*/
void Set(StackStrF & key, StackStrF & val)
{
auto itr = std::find_if(
cpr::Payload::containerList_.begin(), cpr::Payload::containerList_.end(),
[key = key.ToStr()](cpr::Pair & p) { return p.key == key; }
);
// Does it exist?
if (itr == cpr::Payload::containerList_.end())
{
cpr::Payload::containerList_.emplace_back(key.ToStr(), val.ToStr());
}
else
{
itr->value.assign(val.mPtr, val.GetSize());
}
}
/* --------------------------------------------------------------------------------------------
* Add value.
*/
void Add(StackStrF & key, StackStrF & val)
{
cpr::Payload::containerList_.emplace_back(key.ToStr(), val.ToStr());
}
/* --------------------------------------------------------------------------------------------
* Iterate all values.
*/
void Each(Function & fn) const
{
for (const auto & p : cpr::Payload::containerList_)
{
fn.Execute(p.key, p.value);
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all values until stopped.
*/
void While(Function & fn) const
{
for (const auto & p : cpr::Payload::containerList_)
{
auto ret = fn.Eval(p.key, p.value);
// (null || true) == continue & false == break
if (!ret.IsNull() || !ret.Cast< bool >())
{
break;
}
}
}
};
/* ------------------------------------------------------------------------------------------------
* Wrapper for cpr::Proxies that can be bound to the script engine.
*/
struct CpProxies : public cpr::Proxies
{
using cpr::Proxies::Proxies;
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpProxies() = default;
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit CpProxies(const cpr::Proxies & e) : cpr::Proxies(e) { }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit CpProxies(cpr::Proxies && e) : cpr::Proxies(std::move(e)) { }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
CpProxies(const CpProxies &) = default;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CpProxies(CpProxies &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CpProxies() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator.
*/
CpProxies & operator = (const CpProxies &) = default;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CpProxies & operator = (CpProxies &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Retrieve the number of values.
*/
SQInteger Size() const
{
return static_cast< SQInteger >(cpr::Proxies::hosts_.size());
}
/* --------------------------------------------------------------------------------------------
* Check if no value is stored.
*/
bool Empty() const
{
return cpr::Proxies::hosts_.empty();
}
/* --------------------------------------------------------------------------------------------
* Clear all values.
*/
void Clear()
{
cpr::Proxies::hosts_.clear();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the number of matching values.
*/
SQInteger Count(StackStrF & key) const
{
return static_cast< SQInteger >(cpr::Proxies::hosts_.count(key.ToStr()));
}
/* --------------------------------------------------------------------------------------------
* Remove a value.
*/
bool Erase(StackStrF & key)
{
auto itr = cpr::Proxies::hosts_.find(key.ToStr());
// Does it exist?
if (itr == cpr::Proxies::hosts_.end())
{
return false; // Nope
}
// Erase it
cpr::Proxies::hosts_.erase(itr);
// Erased
return true;
}
/* --------------------------------------------------------------------------------------------
* Check if value exists.
*/
bool Has(StackStrF & key) const
{
return cpr::Proxies::hosts_.find(key.ToStr()) != cpr::Proxies::hosts_.end();
}
/* --------------------------------------------------------------------------------------------
* Retrieve value.
*/
std::string & Get(StackStrF & key)
{
auto itr = cpr::Proxies::hosts_.find(key.ToStr());
// Does it exist?
if (itr == cpr::Proxies::hosts_.end())
{
STHROWF("No cookie named: %s", key.mPtr);
}
// Return it
return itr->second;
}
/* --------------------------------------------------------------------------------------------
* Assign value.
*/
void Set(StackStrF & key, StackStrF & val)
{
cpr::Proxies::hosts_[key.ToStr()] = val.ToStr();
}
/* --------------------------------------------------------------------------------------------
* Iterate all values.
*/
void Each(Function & fn) const
{
for (const auto & p : cpr::Proxies::hosts_)
{
fn.Execute(p.first, p.second);
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all values until stopped.
*/
void While(Function & fn) const
{
for (const auto & p : cpr::Proxies::hosts_)
{
auto ret = fn.Eval(p.first, p.second);
// (null || true) == continue & false == break
if (!ret.IsNull() || !ret.Cast< bool >())
{
break;
}
}
}
};
/* ------------------------------------------------------------------------------------------------
* Wrapper for cpr::Session that can be bound to the script engine.
*/
struct CpSession : public cpr::Session
{
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CpSession() = default;
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
CpSession(const CpSession &) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CpSession(CpSession &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
virtual ~CpSession() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
CpSession & operator = (const CpSession &) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CpSession & operator = (CpSession &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Modify URL option.
*/
CpSession & SetURL_(StackStrF & url)
{
cpr::Session::SetUrl(cpr::Url(url.mPtr, url.GetSize()));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify parameters option.
*/
CpSession & SetParameters_(const CpParameters & parameters)
{
cpr::Session::SetParameters(parameters);
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify parameters option.
*/
CpSession & YieldParameters(CpParameters & parameters)
{
cpr::Session::SetParameters(std::move(static_cast< cpr::Parameters & >(parameters)));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify header option.
*/
CpSession & SetHeader_(const CpHeader & header)
{
cpr::Session::SetHeader(header.mMap);
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify timeout option.
*/
CpSession & SetTimeout_(SQInteger ms)
{
cpr::Session::SetTimeout(cpr::Timeout(std::chrono::milliseconds{ms}));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify connect timeout option.
*/
CpSession & SetConnectTimeout_(SQInteger ms)
{
cpr::Session::SetConnectTimeout(cpr::ConnectTimeout(std::chrono::milliseconds{ms}));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify auth option.
*/
CpSession & SetAuth_(StackStrF & username, StackStrF & password)
{
cpr::Session::SetAuth(cpr::Authentication(username.ToStr(), password.ToStr()));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify digest option.
*/
CpSession & SetDigest_(StackStrF & username, StackStrF & password)
{
cpr::Session::SetAuth(cpr::Digest(username.ToStr(), password.ToStr()));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify user agent option.
*/
CpSession & SetUserAgent_(StackStrF & agent)
{
cpr::Session::SetUserAgent(cpr::UserAgent(agent.mPtr, agent.GetSize()));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify payload option.
*/
CpSession & SetPayload_(const CpPayload & payload)
{
cpr::Session::SetPayload(payload);
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify payload option.
*/
CpSession & YieldPayload(CpPayload & payload)
{
cpr::Session::SetPayload(std::move(static_cast< cpr::Payload & >(payload)));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify proxies option.
*/
CpSession & SetProxies_(const CpProxies & proxies)
{
cpr::Session::SetProxies(proxies);
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify proxies option.
*/
CpSession & YieldProxies(CpProxies & proxies)
{
cpr::Session::SetProxies(std::move(static_cast< cpr::Proxies & >(proxies)));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify multipart option.
*/
//CpSession & SetMultipart_(const cpr::Multipart & multipart)
//{
//}
/* --------------------------------------------------------------------------------------------
* Modify multipart option.
*/
//CpSession & YieldMultipart(cpr::Multipart && multipart)
//{
//}
/* --------------------------------------------------------------------------------------------
* Modify NTLM option.
*/
CpSession & SetNTLM_(StackStrF & username, StackStrF & password)
{
cpr::Session::SetNTLM(cpr::NTLM(username.ToStr(), password.ToStr()));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify redirect option.
*/
CpSession & SetRedirect_(bool redirect)
{
cpr::Session::SetRedirect(redirect);
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify max-redirects option.
*/
CpSession & SetMaxRedirects_(SQInteger max_redirects)
{
cpr::Session::SetMaxRedirects(cpr::MaxRedirects(static_cast< int32_t >(max_redirects)));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify cookies option.
*/
CpSession & SetCookies_(const CpCookies & cookies)
{
cpr::Session::SetCookies(cookies);
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify body option.
*/
CpSession & SetBody_(StackStrF & body)
{
cpr::Session::SetBody(cpr::Body(body.mPtr, body.GetSize()));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify low-speed option.
*/
CpSession & SetLowSpeed_(SQInteger limit, SQInteger time)
{
cpr::Session::SetLowSpeed(cpr::LowSpeed(static_cast< int32_t >(limit), static_cast< int32_t >(time)));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify verify SSL option.
*/
CpSession & SetVerifySsl_(bool verify)
{
cpr::Session::SetVerifySsl(cpr::VerifySsl(verify));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify unix socket option.
*/
CpSession & SetUnixSocket_(StackStrF & socket)
{
cpr::Session::SetUnixSocket(cpr::UnixSocket(socket.ToStr()));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify SSL option.
*/
CpSession & SetSslOptions_(const CpSslOptions & options)
{
cpr::Session::SetSslOptions(options);
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Modify read option.
*/
//CpSession & SetReadCallback_(const cpr::ReadCallback & read)
//{
//}
/* --------------------------------------------------------------------------------------------
* Modify header option.
*/
//CpSession & SetHeaderCallback_(const cpr::HeaderCallback & header)
//{
//}
/* --------------------------------------------------------------------------------------------
* Modify write option.
*/
//CpSession & SetWriteCallback_(const cpr::WriteCallback & write)
//{
//}
/* --------------------------------------------------------------------------------------------
* Modify progress option.
*/
//CpSession & SetProgressCallback_(const cpr::ProgressCallback & progress)
//{
//}
/* --------------------------------------------------------------------------------------------
* Modify debug callback option.
*/
//CpSession & SetDebugCallback_(const cpr::DebugCallback & debug)
//{
//}
/* --------------------------------------------------------------------------------------------
* Modify verbose option.
*/
CpSession & SetVerbose_(bool verbose)
{
cpr::Session::SetVerbose(cpr::Verbose(verbose));
return *this; // Allow chaining
}
/* --------------------------------------------------------------------------------------------
* Delete request.
*/
CpResponse DoDelete()
{
return CpResponse(cpr::Session::Delete());
}
/* --------------------------------------------------------------------------------------------
* Get request.
*/
CpResponse DoGet()
{
return CpResponse(cpr::Session::Get());
}
/* --------------------------------------------------------------------------------------------
* Head request.
*/
CpResponse DoHead()
{
return CpResponse(cpr::Session::Head());
}
/* --------------------------------------------------------------------------------------------
* Options request.
*/
CpResponse DoOptions()
{
return CpResponse(cpr::Session::Options());
}
/* --------------------------------------------------------------------------------------------
* Patch request.
*/
CpResponse DoPatch()
{
return CpResponse(cpr::Session::Patch());
}
/* --------------------------------------------------------------------------------------------
* Post request.
*/
CpResponse DoPost()
{
return CpResponse(cpr::Session::Post());
}
/* --------------------------------------------------------------------------------------------
* Put request.
*/
CpResponse DoPut()
{
return CpResponse(cpr::Session::Put());
}
//CpResponse Download(const WriteCallback& write);
//CpResponse Download(std::ofstream& file);
};
Initial preparations for CURL and Discord integration.
2021-01-27 06:27:48 +01:00
} // Namespace:: SqMod
Copy Permalink